@axiom-lattice/gateway 4.9.0 → 4.9.2

package/dist/index.mjs

@@ -16,7 +16,7 @@ import {
 import {
   PluginToolScopeError,
   invokePluginTool
-} from "./chunk-73QZQQOT.mjs";
+} from "./chunk-MWWLJMYN.mjs";
 import {
   buildPreviewTokenScript
 } from "./chunk-7CG57LEF.mjs";
@@ -8741,14 +8741,15 @@ function registerMcpAppRoutes(fastify2) {
 }
 
 // src/controllers/eval.ts
-import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice11, hasModelLatticeForTenant as hasModelLatticeForTenant2, modelLatticeManager as modelLatticeManager2 } from "@axiom-lattice/core";
 import { v4 as uuidv43 } from "uuid";
 
 // src/services/eval-runner.ts
 import { EventEmitter } from "events";
 import {
   getStoreLattice as getStoreLattice10,
-  modelLatticeManager as modelLatticeManager2,
+  hasModelLatticeForTenant,
+  listModelLatticesForTenant,
   LatticeEvalProject
 } from "@axiom-lattice/core";
 import { v4 as uuidv42 } from "uuid";
@@ -8860,19 +8861,19 @@ var EvalRunner = class {
     const judgeModelKey = judgeCfg.modelKey || "";
     let resolvedJudgeModelKey;
     if (judgeModelKey) {
-      if (!modelLatticeManager2.hasLattice(judgeModelKey)) {
+      if (!await hasModelLatticeForTenant(tenantId, judgeModelKey)) {
         throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
       resolvedJudgeModelKey = judgeModelKey;
     } else {
-      const models = modelLatticeManager2.getAllLattices();
-      const defaultModel = models.find((m) => m.key === "default");
-      resolvedJudgeModelKey = defaultModel?.key ?? models[0]?.key ?? "";
-      if (!resolvedJudgeModelKey) {
-        throw new Error("No model registered \u2014 cannot run eval without a judge model");
-      }
-      if (!defaultModel) {
-        console.warn(`[eval-runner] Project "${project.name}" has no judge modelKey and no "default" model \u2014 falling back to first registered model "${resolvedJudgeModelKey}"`);
+      resolvedJudgeModelKey = "default";
+      if (!await hasModelLatticeForTenant(tenantId, resolvedJudgeModelKey)) {
+        const models = listModelLatticesForTenant(tenantId);
+        resolvedJudgeModelKey = models[0]?.key ?? "";
+        if (!resolvedJudgeModelKey) {
+          throw new Error("No model registered \u2014 cannot run eval without a judge model");
+        }
+        console.warn(`[eval-runner] Project "${project.name}" has no judge modelKey and no default model \u2014 falling back to "${resolvedJudgeModelKey}"`);
       }
     }
     const runId = uuidv42();
@@ -9125,8 +9126,7 @@ async function createProject(request, reply) {
     const judgeCfg = data.judgeModelConfig || {};
     const modelKey2 = judgeCfg.modelKey || "";
     if (modelKey2) {
-      const { modelLatticeManager: modelLatticeManager4 } = await import("@axiom-lattice/core");
-      if (!modelLatticeManager4.hasLattice(modelKey2)) {
+      if (!await hasModelLatticeForTenant2(tenantId, modelKey2)) {
         return reply.status(400).send({ success: false, message: `Judge model "${modelKey2}" is not registered` });
       }
     }
@@ -9172,8 +9172,7 @@ async function listProjects(request, reply) {
     let projects = await store.getProjectsByTenant(tenantId);
     if (projects.length === 0) {
       try {
-        const { modelLatticeManager: modelLatticeManager4 } = await import("@axiom-lattice/core");
-        const models = modelLatticeManager4.getAllLattices();
+        const models = modelLatticeManager2.getAllLattices();
         const first = models[0];
         const judgeModel = first ? { modelKey: first.key } : {};
         const host = request.hostname || "localhost";
@@ -9241,8 +9240,7 @@ async function updateProject(request, reply) {
       const judgeCfg = body.judgeModelConfig || {};
       const modelKey2 = judgeCfg.modelKey || "";
       if (modelKey2) {
-        const { modelLatticeManager: modelLatticeManager4 } = await import("@axiom-lattice/core");
-        if (!modelLatticeManager4.hasLattice(modelKey2)) {
+        if (!modelLatticeManager2.hasLattice(modelKey2)) {
           return reply.status(400).send({ success: false, message: `Judge model "${modelKey2}" is not registered` });
         }
       }
@@ -10641,6 +10639,7 @@ import { randomUUID as randomUUID11 } from "crypto";
 import {
   descriptorDataValue
 } from "@axiom-lattice/protocols";
+import { getStoreLattice as getStoreLattice15 } from "@axiom-lattice/core";
 var _adapterRegistry;
 var _router;
 function setChannelControllerDeps(deps) {
@@ -10764,8 +10763,7 @@ function snapshotPlainObject(value) {
   }
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice30 } = await import("@axiom-lattice/core");
-  const store = getStoreLattice30("default", "channelInstallation").store;
+  const store = getStoreLattice15("default", "channelInstallation").store;
   if (store) return store;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -11084,7 +11082,7 @@ import {
   DuplicateChannelBindingSubjectError,
   descriptorDataValue as descriptorDataValue2
 } from "@axiom-lattice/protocols";
-import { getBindingRegistry, getStoreLattice as getStoreLattice15 } from "@axiom-lattice/core";
+import { getBindingRegistry, getStoreLattice as getStoreLattice16 } from "@axiom-lattice/core";
 function getTenantId13(request) {
   const userTenantId = request.user?.tenantId;
   if (typeof userTenantId === "string" && userTenantId) return userTenantId;
@@ -11142,7 +11140,7 @@ function snapshotPublicUpdate(value) {
   return body;
 }
 function getInstallationStore2() {
-  return getStoreLattice15("default", "channelInstallation").store;
+  return getStoreLattice16("default", "channelInstallation").store;
 }
 async function isValidPublicInstallation(tenantId, channelInstallationId, channel) {
   const installation = await getInstallationStore2().getInstallationById(channelInstallationId);
@@ -11642,7 +11640,7 @@ var registerSTTRoutes = (app2) => {
 };
 
 // src/controllers/local-a2a.ts
-import { getStoreLattice as getStoreLattice16 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice17 } from "@axiom-lattice/core";
 import {
   AgentType as AgentType2
 } from "@axiom-lattice/protocols";
@@ -11658,7 +11656,7 @@ function getLocalRuntime(assistant) {
   return graphDefinition.localRuntime;
 }
 async function getLocalA2AAssistants(tenantId) {
-  const storeLattice = getStoreLattice16("default", "assistant");
+  const storeLattice = getStoreLattice17("default", "assistant");
   const assistants = await storeLattice.store.getAllAssistants(tenantId);
   const results = [];
   for (const assistant of assistants) {
@@ -11670,7 +11668,7 @@ async function getLocalA2AAssistants(tenantId) {
   return results;
 }
 async function getLocalA2AAssistant(tenantId, assistantId) {
-  const storeLattice = getStoreLattice16("default", "assistant");
+  const storeLattice = getStoreLattice17("default", "assistant");
   const assistant = await storeLattice.store.getAssistantById(tenantId, assistantId);
   if (!assistant) return null;
   const runtime = getLocalRuntime(assistant);
@@ -11920,9 +11918,11 @@ import {
   createTrustedAgentMessageDispatcher,
   executionAuthorityRegistry,
   getReplicaId as getReplicaId6,
-  getStoreLattice as getStoreLattice17,
+  getStoreLattice as getStoreLattice18,
+  hasModelLatticeForTenant as hasModelLatticeForTenant3,
   ManagedTaskStartError,
   modelLatticeManager as modelLatticeManager3,
+  resolveModelLatticeForTenant,
   ProjectTaskOwnerPolicy,
   ProjectTaskOwnerPolicyError as ProjectTaskOwnerPolicyError2,
   projectMutationMutex as projectMutationMutex2,
@@ -12374,10 +12374,10 @@ var ProjectTaskExecutionService = class {
     return { kind: "ready", task: current, thread: ensured.thread, rosterExempt: validated.rosterExempt };
   }
   /** Resumes an interrupted Project Task on its canonical existing Thread. */
-  async resume(input, signal) {
+  async resume(input, signal, options) {
     const prepared = await this.prepareResume(input, signal);
     if (prepared.kind === "aborted") return prepared.outcome;
-    return this.dispatchRun(prepared.task, prepared.thread, "resume", prepared.rosterExempt, signal);
+    return this.dispatchRun(prepared.task, prepared.thread, "resume", prepared.rosterExempt, signal, options);
   }
   /** Clears the durable interruption and loads the exact resumed task. */
   async prepareResume(input, signal) {
@@ -12410,6 +12410,7 @@ var ProjectTaskExecutionService = class {
    *
    * @param input Tenant, task identity, and optional command actor.
    * @param signal Optional cancellation signal for the armed settlement.
+   * @param options Optional resume command carried into the queued run message.
    * @returns The settled run outcome.
    * @remarks `start` semantics: make this task run. `pending` starts,
    * `interrupted` resumes, `failed` retries, and `completed`/`cancelled`
@@ -12417,14 +12418,15 @@ var ProjectTaskExecutionService = class {
    * conflict. This is a record transition plus an application-layer side
    * effect; the kernel only records the status change. `actor` attributes the
    * start/resume/retry/reopen transition and defaults to the system actor.
+   * `options.command` is only carried on an interrupted-task resume.
    */
-  async dispatch(input, signal) {
+  async dispatch(input, signal, options) {
     const task = await this.requireTask(input);
     if (task.ownerType !== "agent") {
       throw new ProjectTaskExecutionError("PROJECT_TASK_NOT_READY", "Project task is not agent-owned");
     }
     if (task.status === "pending") return this.start(input, signal);
-    if (task.status === "interrupted") return this.resume(input, signal);
+    if (task.status === "interrupted") return this.resume(input, signal, options);
     if (task.status === "failed" || task.status === "completed" || task.status === "cancelled") {
       return this.dispatchRestartable(task, input.actor ?? SYSTEM_ACTOR, signal);
     }
@@ -12435,6 +12437,7 @@ var ProjectTaskExecutionService = class {
    *
    * @param input Tenant, task identity, and optional command actor.
    * @param signal Optional cancellation signal for the pre-run transition.
+   * @param options Optional resume command carried into the queued run message.
    * @returns The `in_progress` task snapshot and whether the run was queued.
    * @remarks Intended for command HTTP handlers that must release the Project
    * mutation mutex immediately: the armed settlement keeps running in the
@@ -12442,20 +12445,25 @@ var ProjectTaskExecutionService = class {
    * awaits it. Enqueue failure converges the task exactly like the awaited
    * path before throwing, so no phantom run is left behind.
    */
-  async dispatchDetached(input, signal) {
+  async dispatchDetached(input, signal, options) {
     const task = await this.requireTask(input);
+    if (options?.expectedStatus !== void 0 && task.status !== options.expectedStatus) {
+      throw new ProjectTaskExecutionError("PROJECT_TASK_NOT_RESUMABLE", "Project task is not in the expected status");
+    }
     if (task.ownerType !== "agent") {
       throw new ProjectTaskExecutionError("PROJECT_TASK_NOT_READY", "Project task is not agent-owned");
     }
     const actor3 = input.actor ?? SYSTEM_ACTOR;
     let prepared;
     let mode;
+    let resumeOptions;
     if (task.status === "pending") {
       prepared = await this.prepareStart(input, signal);
       mode = "start";
     } else if (task.status === "interrupted") {
       prepared = await this.prepareResume(input, signal);
       mode = "resume";
+      resumeOptions = options;
     } else if (task.status === "failed" || task.status === "completed" || task.status === "cancelled") {
       prepared = await this.prepareRestartable(task, actor3, signal);
       mode = "resume";
@@ -12463,7 +12471,7 @@ var ProjectTaskExecutionService = class {
       throw new ProjectTaskExecutionError("PROJECT_TASK_NOT_READY", `Project task is '${task.status}'`);
     }
     if (prepared.kind === "aborted") return { task: prepared.outcome.task, queued: false };
-    return this.enqueueDetached(prepared.task, prepared.thread, mode, prepared.rosterExempt);
+    return this.enqueueDetached(prepared.task, prepared.thread, mode, prepared.rosterExempt, resumeOptions);
   }
   /** Recovers one exact pending or processing queue row without dispatching a duplicate input. */
   async recover(input, signal) {
@@ -12708,10 +12716,10 @@ var ProjectTaskExecutionService = class {
     }
     return current;
   }
-  async dispatchRun(task, thread, mode, rosterExempt, signal) {
+  async dispatchRun(task, thread, mode, rosterExempt, signal, options) {
     const messageId = (this.options.idFactory ?? randomUUID13)();
     if (signal?.aborted) return this.compensateCancellation(task, thread, messageId, false);
-    const armed = await this.armAndEnqueue(task, thread, mode, messageId, rosterExempt, signal);
+    const armed = await this.armAndEnqueue(task, thread, mode, messageId, rosterExempt, signal, options);
     if (armed.cancelled) return this.cancelSettlement(armed.settlement, task, thread, messageId, false);
     if (signal?.aborted) return this.cancelSettlement(armed.settlement, task, thread, messageId, armed.queued);
     if (!armed.queued) {
@@ -12726,7 +12734,7 @@ var ProjectTaskExecutionService = class {
    *   enqueue yields `queued: false` with a stable reason; the caller decides
    *   whether to converge only (awaited path) or converge and throw (detached).
    */
-  async armAndEnqueue(task, thread, mode, messageId, rosterExempt, signal) {
+  async armAndEnqueue(task, thread, mode, messageId, rosterExempt, signal, options) {
     const settlement = this.armSettlement(task, thread, messageId);
     if (signal?.aborted) return { settlement, queued: false, error: "", cancelled: true };
     try {
@@ -12736,7 +12744,10 @@ var ProjectTaskExecutionService = class {
         project_id: task.projectId,
         assistant_id: task.ownerId,
         thread_id: thread.id
-      }, { input: { id: messageId, message: buildTaskPrompt(task, mode) } }, {
+      }, {
+        input: { id: messageId, message: buildTaskPrompt(task, mode) },
+        ...mode === "resume" && options?.command ? { command: options.command } : {}
+      }, {
         executionMode: "followup",
         trustedRunContext: { projectTask: buildTrustedTaskContext(task, thread, messageId, rosterExempt) }
       });
@@ -12762,9 +12773,9 @@ var ProjectTaskExecutionService = class {
    * task is converged exactly like the awaited path before throwing, so no
    * phantom in-progress run is left behind.
    */
-  async enqueueDetached(task, thread, mode, rosterExempt) {
+  async enqueueDetached(task, thread, mode, rosterExempt, options) {
     const messageId = (this.options.idFactory ?? randomUUID13)();
-    const armed = await this.armAndEnqueue(task, thread, mode, messageId, rosterExempt);
+    const armed = await this.armAndEnqueue(task, thread, mode, messageId, rosterExempt, void 0, options);
     void armed.settlement.promise.catch(() => void 0);
     if (!armed.queued) {
       await this.claimDispatchFailure(armed.settlement, task, thread, messageId, armed.error);
@@ -12895,12 +12906,14 @@ var ProjectTaskExecutionService = class {
   async settleInterruptedEvent(task, thread, messageId, state) {
     const current = await this.withLifecycleTimeout(this.reloadTask(task), void 0);
     if (current?.status === "interrupted" && this.matchesExecution(current, task, thread)) {
+      this.emitInterrupted(current, thread, messageId, state);
       return { kind: "interrupted", task: current, thread, messageId };
     }
     const clarify = readClarifyInterrupt(state ?? await this.readInterruptedThreadState(task, thread));
     if (clarify !== void 0) {
       const interrupted = await this.interruptForClarify(current ?? task, thread, clarify);
       if (interrupted?.status === "interrupted" && this.matchesExecution(interrupted, task, thread)) {
+        this.emitInterrupted(interrupted, thread, messageId, state);
         return { kind: "interrupted", task: interrupted, thread, messageId };
       }
     }
@@ -12912,6 +12925,22 @@ var ProjectTaskExecutionService = class {
       "interruption_not_durable"
     );
   }
+  /**
+   * Fire-and-forget best-effort projection of a durable interruption.
+   *
+   * @remarks Never awaited and never allowed to affect settlement. The state is
+   * resolved lazily so a missing/undefined event state only triggers a thread
+   * read when the hook is actually wired.
+   */
+  emitInterrupted(task, thread, messageId, state) {
+    const hook = this.deps.onTaskInterrupted;
+    if (!hook) return;
+    void Promise.resolve().then(async () => {
+      const resolved = state ?? await this.readInterruptedThreadState(task, thread);
+      await hook({ task, thread, messageId, state: resolved });
+    }).catch(() => {
+    });
+  }
   /** Reads the paused thread snapshot when no interrupt event payload is available (recovery). */
   async readInterruptedThreadState(task, thread) {
     try {
@@ -14005,10 +14034,14 @@ var AgentWebAppService = class {
         throw new AgentWebAppError("PROJECT_NOT_FOUND", 404, "Project not found");
       }
     }
-    const scope = this.validateModels(input.scope, input.features.modelSelector);
+    const scope = await this.validateModels(
+      tenantId,
+      input.scope,
+      input.features.modelSelector
+    );
     return { ...input, scope: { ...scope, allowedProjectIds } };
   }
-  validateModels(scope, modelSelector) {
+  async validateModels(tenantId, scope, modelSelector) {
     const allowedModelKeys = scope.allowedModelKeys ? [...new Set(scope.allowedModelKeys)] : void 0;
     if (!allowedModelKeys?.length) {
       if (scope.defaultModelKey || modelSelector) {
@@ -14023,7 +14056,7 @@ var AgentWebAppService = class {
       throw new AgentWebAppError("MODEL_SCOPE_INVALID", 400, "Default model must be in the model allowlist");
     }
     for (const key of allowedModelKeys) {
-      if (!this.deps.modelRegistry.has(key)) {
+      if (!await this.deps.modelRegistry.has(tenantId, key)) {
         throw new AgentWebAppError("MODEL_NOT_FOUND", 400, "Configured model is not registered");
       }
     }
@@ -14252,15 +14285,22 @@ var AgentWebAppRuntimeService = class {
       return { id: project.id, name: project.name };
     }));
     const defaultModelKey = runtime.webApp.scope.defaultModelKey;
-    if (defaultModelKey && !this.deps.modelRegistry.has(defaultModelKey)) {
+    const tenantId = runtime.webApp.tenantId;
+    if (defaultModelKey && !await this.deps.modelRegistry.has(tenantId, defaultModelKey)) {
       this.fail("MODEL_NOT_ALLOWED", 400, "Default model is not available");
     }
     const configuredPublicModelKeys = runtime.webApp.features.modelSelector ? runtime.webApp.scope.allowedModelKeys ?? [] : defaultModelKey ? [defaultModelKey] : [];
-    const publicModelKeys = [...new Set(configuredPublicModelKeys)].filter((key) => this.deps.modelRegistry.has(key));
-    const models = publicModelKeys.map((key) => ({
-      key,
-      label: this.deps.modelRegistry.label(key)
-    }));
+    const candidateModelKeys = [...new Set(configuredPublicModelKeys)];
+    const resolvable = await Promise.all(
+      candidateModelKeys.map((key) => this.deps.modelRegistry.has(tenantId, key))
+    );
+    const publicModelKeys = candidateModelKeys.filter((_, index) => resolvable[index]);
+    const models = await Promise.all(
+      publicModelKeys.map(async (key) => ({
+        key,
+        label: await this.deps.modelRegistry.label(tenantId, key)
+      }))
+    );
     const result = {
       webApp: {
         id: runtime.webApp.id,
@@ -14483,7 +14523,7 @@ ${formatFileRefsSection(refs)}` : input.content;
     }
     const modelKey2 = selection.modelKey ?? webApp.scope.defaultModelKey;
     const allowedModels = webApp.scope.allowedModelKeys;
-    if (modelKey2 && (!allowedModels?.includes(modelKey2) || !this.deps.modelRegistry.has(modelKey2))) {
+    if (modelKey2 && (!allowedModels?.includes(modelKey2) || !await this.deps.modelRegistry.has(webApp.tenantId, modelKey2))) {
       this.fail("MODEL_NOT_ALLOWED", 400, "Model is not allowed");
     }
     return { webApp, project, modelKey: modelKey2 };
@@ -15841,6 +15881,8 @@ import { randomUUID as randomUUID15 } from "crypto";
 import { toModelKey } from "@axiom-lattice/protocols";
 import {
   assertSafeUpstreamUrl,
+  buildModelLlmConfig,
+  UnsupportedModelProviderError,
   UnsafeUpstreamUrlError
 } from "@axiom-lattice/core";
 
@@ -16045,7 +16087,6 @@ function getDiscoveryAdapter(protocol) {
 
 // src/services/model-provider/ModelProviderService.ts
 var PHASE1_REGISTRY_TENANT = "default";
-var ALLOWED_LLM_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
 var unsafeReasonToErrorCode = {
   INVALID_BASE_URL: "INVALID_BASE_URL",
   UNSUPPORTED_SCHEME: "INVALID_BASE_URL",
@@ -16112,6 +16153,8 @@ var ModelProviderService = class {
       source: "snapshot",
       enabled: model.enabled,
       stale: model.stale ?? false,
+      extra: model.extra,
+      isDefault: model.isDefault,
       executable: model.enabled && // A disabled provider is a kill switch: its models stay visible in the
       // catalog but are no longer reported as runnable.
       !disabledProviderIds.has(model.providerId) && this.deps.registry.has(
@@ -16119,20 +16162,20 @@ var ModelProviderService = class {
         toModelKey(model.providerId, model.modelId)
       )
     }));
-    const known = new Set(models.map((model) => model.modelKey));
-    for (const modelKey2 of this.deps.registry.listRegistered(tenantId)) {
-      if (known.has(modelKey2)) {
-        continue;
+    if (models.length === 0) {
+      for (const modelKey2 of this.deps.registry.listRegistered(
+        PHASE1_REGISTRY_TENANT
+      )) {
+        models.push({
+          modelKey: modelKey2,
+          providerId: "",
+          providerName: "registered",
+          source: "registered",
+          enabled: true,
+          stale: false,
+          executable: true
+        });
       }
-      models.push({
-        modelKey: modelKey2,
-        providerId: "",
-        providerName: "registered",
-        source: "registered",
-        enabled: true,
-        stale: false,
-        executable: true
-      });
     }
     return {
       providers: providers.map(
@@ -16209,7 +16252,6 @@ var ModelProviderService = class {
    */
   async create(userId, tenantId, input) {
     await this.assertAdmin(userId, tenantId);
-    this.assertHasApiKey(input.apiKey);
     if (!getDiscoveryAdapter(input.protocol)) {
       throw new ModelProviderServiceError(
         "UNSUPPORTED_PROTOCOL",
@@ -16250,9 +16292,6 @@ var ModelProviderService = class {
   async update(userId, tenantId, id3, updates) {
     await this.assertAdmin(userId, tenantId);
     const existing = await this.requireProvider(tenantId, id3);
-    if (updates.clearApiKey || !(updates.apiKey?.trim() || existing.apiKey)) {
-      this.assertHasApiKey(void 0);
-    }
     if (updates.protocol && !getDiscoveryAdapter(updates.protocol)) {
       throw new ModelProviderServiceError(
         "UNSUPPORTED_PROTOCOL",
@@ -16373,6 +16412,8 @@ var ModelProviderService = class {
       void 0,
       now
     );
+    await this.ensureDefaultModel(tenantId);
+    this.deps.registry.forgetTenantDefaultMiss?.(tenantId);
     const registered = [];
     if (this.shouldRegister(tenantId)) {
       const snapshot = await this.deps.providerStore.listModels(tenantId, id3);
@@ -16473,6 +16514,13 @@ var ModelProviderService = class {
   async setModels(userId, tenantId, id3, selection) {
     await this.assertAdmin(userId, tenantId);
     const provider = await this.requireProvider(tenantId, id3);
+    if (selection.filter((entry) => entry.isDefault === true).length > 1) {
+      throw new ModelProviderServiceError(
+        "INVALID_INPUT",
+        400,
+        "Only one model can be the tenant's default"
+      );
+    }
     const previous = await this.deps.providerStore.listModels(tenantId, id3);
     const previousById = new Map(
       previous.map((model) => [model.modelId, model])
@@ -16490,9 +16538,18 @@ var ModelProviderService = class {
         // The selection carries only ids and states, so a model already in the
         // snapshot keeps the metadata discovery gave it.
         displayName: previousById.get(entry.modelId)?.displayName,
-        ownedBy: previousById.get(entry.modelId)?.ownedBy
+        ownedBy: previousById.get(entry.modelId)?.ownedBy,
+        // An omitted `extra` means "keep what is stored" — the picker sends no
+        // config, and a sync must not wipe one set by hand. The store resolves
+        // the fallback against the row's current value.
+        extra: entry.extra,
+        // Same rule: omitted leaves the flag alone, so a sync cannot quietly
+        // move the tenant's default.
+        isDefault: entry.isDefault
       }))
     );
+    await this.ensureDefaultModel(tenantId);
+    this.deps.registry.forgetTenantDefaultMiss?.(tenantId);
     const models = await this.deps.providerStore.listModels(tenantId, id3);
     const kept = new Set(models.map((model) => model.modelId));
     for (const model of previous) {
@@ -16507,6 +16564,40 @@ var ModelProviderService = class {
     this.notifyChanged(tenantId, id3);
     return this.toPublicEntry(provider, models.length);
   }
+  /**
+   * Give a tenant's sole model the default flag.
+   *
+   * A tenant with exactly one runnable model has an obvious default, and saying
+   * so is what keeps the invariant the rest of the feature leans on: a tenant
+   * either has no models at all — and falls back to the deployment's default —
+   * or has a default, which cannot be deleted. Without this a tenant could sit
+   * with one model and no default, and deleting that model would leave nothing
+   * behind.
+   *
+   * Deliberately narrow: more than one model is the tenant's choice to make,
+   * and a disabled model is not a candidate for "the model this tenant runs".
+   *
+   * @param tenantId - The tenant whose model set just changed
+   */
+  async ensureDefaultModel(tenantId) {
+    const models = await this.deps.providerStore.listModels(tenantId);
+    if (models.length !== 1) {
+      return;
+    }
+    const [only] = models;
+    if (only.isDefault || !only.enabled) {
+      return;
+    }
+    await this.deps.providerStore.replaceProviderModels(tenantId, only.providerId, [
+      {
+        id: only.modelId,
+        enabled: only.enabled,
+        stale: only.stale,
+        extra: only.extra,
+        isDefault: true
+      }
+    ]);
+  }
   syncRegistry(tenantId, provider, models) {
     if (!this.shouldRegister(tenantId)) {
       return [];
@@ -16521,7 +16612,7 @@ var ModelProviderService = class {
       this.deps.registry.register(
         tenantId,
         modelKey2,
-        this.toLlmConfig(provider, model.modelId)
+        this.buildLlmConfig(provider, model)
       );
       registered.push(modelKey2);
     }
@@ -16534,6 +16625,28 @@ var ModelProviderService = class {
     } catch {
     }
   }
+  /**
+   * Build a model's runtime config, keeping this service's error contract.
+   *
+   * The builder itself lives in core, because the registry's lazy loader needs
+   * the same one when a replica materialises a model it never discovered.
+   * Wrapping here preserves the `ModelProviderServiceError` the API layer
+   * renders — core cannot import a gateway error type.
+   */
+  buildLlmConfig(provider, model) {
+    try {
+      return buildModelLlmConfig(provider, model);
+    } catch (error) {
+      if (error instanceof UnsupportedModelProviderError) {
+        throw new ModelProviderServiceError(
+          "UNSUPPORTED_PROTOCOL",
+          400,
+          "Provider is configured with an unsupported LLM provider"
+        );
+      }
+      throw error;
+    }
+  }
   /**
    * Enable or disable a single discovered model.
    */
@@ -16564,34 +16677,6 @@ var ModelProviderService = class {
   shouldRegister(tenantId) {
     return tenantId === PHASE1_REGISTRY_TENANT;
   }
-  /**
-   * Build the runtime LLM config for a discovered model.
-   *
-   * `apiKeyEnvName`, `extra` and `modelKwargs` are deliberately omitted — they
-   * would let a tenant name an arbitrary process environment variable to read
-   * credentials from, or inject arbitrary constructor options.
-   */
-  toLlmConfig(provider, modelId) {
-    if (!ALLOWED_LLM_PROVIDERS.has(provider.llmProvider)) {
-      throw new ModelProviderServiceError(
-        "UNSUPPORTED_PROTOCOL",
-        400,
-        "Provider is configured with an unsupported LLM provider"
-      );
-    }
-    return {
-      provider: provider.llmProvider,
-      model: modelId,
-      displayName: modelId,
-      streaming: true,
-      apiKey: provider.apiKey,
-      baseURL: provider.baseURL,
-      // Chat Completions and the Responses API are different routes with
-      // different request fields; without this the gateway would post
-      // `messages` to an endpoint expecting `input`.
-      ...provider.apiStyle === "responses" ? { useResponsesApi: true } : {}
-    };
-  }
   /**
    * The sole projection from an internal provider entry to an API-safe shape.
    */
@@ -16616,21 +16701,6 @@ var ModelProviderService = class {
       updatedAt: provider.updatedAt.toISOString()
     };
   }
-  /**
-   * Reject a provider that would end up without a credential.
-   *
-   * @param apiKey - The key the provider would hold, if any
-   * @throws {ModelProviderServiceError} When no key is present
-   */
-  assertHasApiKey(apiKey) {
-    if (!apiKey?.trim()) {
-      throw new ModelProviderServiceError(
-        "INVALID_INPUT",
-        400,
-        "A model provider must have an API key"
-      );
-    }
-  }
   /**
    * Load a provider or fail with 404.
    *
@@ -16740,15 +16810,18 @@ var providerId = z9.string().trim().min(1).max(255);
 var providerParamsSchema = z9.object({ providerId }).strict();
 var protocolSchema = z9.enum(["openai-compatible"]);
 var apiStyleSchema = z9.enum(["chat-completions", "responses"]);
+var extraSchema = z9.record(z9.string(), z9.unknown());
 var createProviderSchema = z9.object({
   name: z9.string().trim().min(1).max(255),
   displayName: z9.string().trim().max(255).optional(),
   protocol: protocolSchema,
   apiStyle: apiStyleSchema.optional(),
   baseURL: z9.string().trim().min(1).max(2048),
-  // Required, not optional: see CreateModelProviderRequest.apiKey — a
-  // keyless provider would make the gateway send its own env credential.
-  apiKey: z9.string().trim().min(1).max(1024),
+  // Optional: omitting it means the upstream needs no authentication, which
+  // is the normal case for a locally hosted model server. The service turns
+  // that into an explicit no-auth marker rather than an absent key, so the
+  // runtime never falls back to the gateway's own environment credentials.
+  apiKey: z9.string().trim().max(1024).optional(),
   enabled: z9.boolean().optional()
 }).strict();
 var updateProviderSchema = createProviderSchema.partial().extend({
@@ -16768,7 +16841,15 @@ var setModelsSchema = z9.object({
     z9.object({
       modelId: z9.string().trim().min(1).max(512),
       enabled: z9.boolean(),
-      stale: z9.boolean().optional()
+      stale: z9.boolean().optional(),
+      // Omitted means "leave the stored config alone" — the picker sends
+      // only ids and states, and must not wipe a config set by hand.
+      extra: extraSchema.optional(),
+      // At most one per tenant; the service rejects a tie with a
+      // readable error rather than letting the unique index raise one.
+      // Omitted means "leave the stored flag alone", which is what a
+      // sync carries.
+      isDefault: z9.boolean().optional()
     }).strict()
   ).max(1e3)
 }).strict();
@@ -17414,7 +17495,13 @@ var ProjectRosterService = class {
     }
     const agent = (await this.deps.agents.list(actor3.tenantId, actor3.userId)).find((item) => item.assistantId === assistantId);
     if (!agent || agent.ownerUserId !== void 0) throw new ProjectRosterServiceError("ASSISTANT_NOT_FOUND", 404, "Agent not found");
-    const room = await this.deps.roomService.ensureMainRoom(actor3);
+    const room = await this.deps.roomStore.ensureMainRoom({
+      id: randomUUID18(),
+      tenantId: actor3.tenantId,
+      workspaceId: project.workspaceId,
+      projectId: actor3.projectId,
+      name: project.name
+    });
     const taken = new Set((await this.deps.membershipStore.list(actor3.tenantId, actor3.projectId)).map((item) => item.mentionName));
     const mentionName = uniqueMentionName(agent.name, taken);
     let ids = await this.findSafePresence(actor3, room, assistantId);
@@ -18129,6 +18216,13 @@ import { toProjectRoomPublicMessage } from "@axiom-lattice/protocols";
 
 // src/services/collaboration/RoomInterruptService.ts
 import { randomUUID as randomUUID20 } from "crypto";
+var RESUMABLE_TASK_INTERRUPT_CODES = /* @__PURE__ */ new Set([
+  "PROJECT_TASK_NOT_RESUMABLE",
+  "PROJECT_TASK_NOT_READY",
+  "PROJECT_TASK_START_CONFLICT",
+  "TASK_STATUS_CONFLICT",
+  "REVIEW_APPROVAL_REQUIRED"
+]);
 var RoomInterruptServiceError = class extends Error {
   /** Creates a stable room interrupt error. */
   constructor(code, statusCode, message) {
@@ -18151,7 +18245,16 @@ var RoomInterruptService = class {
   /** Resolves a pending interrupt with an explicit resume command. */
   async resume(input, command) {
     await this.deps.requireAccess({ tenantId: input.tenantId, userId: input.userId, projectId: input.projectId });
-    const membership = await this.deps.resolveMembership(input);
+    if (input.ref.kind === "task") {
+      await this.resumeTask(input, command);
+      return;
+    }
+    await this.resumePresence(input, command);
+  }
+  /** Resolves a bot presence-thread interrupt by dispatching a follow-up resume. */
+  async resumePresence(input, command) {
+    const membershipId = input.ref.kind === "presence" ? input.ref.membershipId : "";
+    const membership = await this.deps.resolveMembership({ tenantId: input.tenantId, projectId: input.projectId, membershipId });
     if (!membership || membership.status !== "active" || !membership.roomThreadId || membership.projectId !== input.projectId) {
       throw new RoomInterruptServiceError("ROOM_INTERRUPT_TARGET_UNAVAILABLE", 404, "Room interrupt target is unavailable");
     }
@@ -18204,6 +18307,47 @@ var RoomInterruptService = class {
       }
     );
   }
+  /** Resolves a Project Task interrupt by re-reading the task thread and resuming its durable run. */
+  async resumeTask(input, command) {
+    if (!this.deps.tasks || !this.deps.execution) throw new RoomInterruptServiceError("ROOM_INTERRUPT_TARGET_UNAVAILABLE", 404, "Project task runtime is unavailable");
+    const taskId = input.ref.kind === "task" ? input.ref.taskId : "";
+    const task = await this.deps.tasks.getById(input.tenantId, taskId);
+    if (!task || task.tenantId !== input.tenantId || task.projectId !== input.projectId || task.status !== "interrupted" || typeof task.context?.thread_id !== "string") {
+      throw new RoomInterruptServiceError("ROOM_INTERRUPT_NOT_PENDING", 409, "Room interrupt is no longer pending");
+    }
+    const status = await this.deps.getThreadStatus({
+      tenantId: task.tenantId,
+      assistantId: task.ownerId,
+      threadId: task.context.thread_id,
+      workspaceId: task.workspaceId ?? "",
+      projectId: task.projectId ?? ""
+    });
+    if (String(status) !== "interrupted") throw new RoomInterruptServiceError("ROOM_INTERRUPT_NOT_PENDING", 409, "Room interrupt is no longer pending");
+    if (this.deps.getThreadState) {
+      const state = await this.deps.getThreadState({
+        tenantId: task.tenantId,
+        assistantId: task.ownerId,
+        threadId: task.context.thread_id,
+        workspaceId: task.workspaceId ?? "",
+        projectId: task.projectId ?? ""
+      });
+      if (readClarifyInterrupt(state) === void 0) {
+        throw new RoomInterruptServiceError("ROOM_INTERRUPT_NOT_PENDING", 409, "Room interrupt is no longer pending");
+      }
+    }
+    try {
+      await this.deps.execution.dispatchDetached(
+        { tenantId: task.tenantId, taskId: task.id, actor: `user:${input.userId}` },
+        void 0,
+        { command, expectedStatus: "interrupted" }
+      );
+    } catch (error) {
+      if (error instanceof ProjectTaskExecutionError && RESUMABLE_TASK_INTERRUPT_CODES.has(error.code)) {
+        throw new RoomInterruptServiceError("ROOM_INTERRUPT_NOT_PENDING", 409, error.message);
+      }
+      throw error;
+    }
+  }
 };
 
 // src/schemas/project-room.ts
@@ -18247,14 +18391,18 @@ var updateProjectBotSchema = z10.object({
   expectedUpdatedAt: isoDate
 }).strict().refine((value) => value.role !== void 0 || value.title !== void 0 || value.responsibility !== void 0 || value.mentionName !== void 0, { message: "At least one mutable field is required" });
 var resumeInterruptSchema = z10.object({
-  membershipId: id2,
+  ref: z10.discriminatedUnion("kind", [
+    z10.object({ kind: z10.literal("presence"), membershipId: id2 }).strict(),
+    z10.object({ kind: z10.literal("task"), taskId: id2 }).strict()
+  ]).optional(),
+  membershipId: id2.optional(),
   answers: z10.array(z10.object({
     questionIndex: z10.number().int().nonnegative(),
     otherText: z10.string().optional(),
     selectedOptions: z10.array(z10.string()).optional(),
     filePath: z10.string().optional()
   }).strict()).optional()
-}).strict();
+}).strict().refine((v) => v.ref !== void 0 || v.membershipId !== void 0, { message: "ref or membershipId is required" });
 
 // src/routes/project-rooms.ts
 var ProjectRoomAuthError = class extends Error {
@@ -18305,8 +18453,9 @@ function registerProjectRoomRoutes(app2, deps) {
     const params = projectRoomParamsSchema.parse(request.params);
     const requestActor = actor(request, params.projectId);
     const body = resumeInterruptSchema.parse(request.body ?? {});
+    const ref = body.ref ?? { kind: "presence", membershipId: body.membershipId };
     await deps.interruptService.resume(
-      { tenantId: requestActor.tenantId, projectId: requestActor.projectId, userId: requestActor.userId, membershipId: body.membershipId },
+      { tenantId: requestActor.tenantId, projectId: requestActor.projectId, userId: requestActor.userId, ref },
       { resume: { data: { answers: body.answers ?? [] } } }
     );
     return { data: { resolved: true } };
@@ -19787,6 +19936,54 @@ var ProjectTaskExecutionMutex = class {
   }
 };
 
+// src/services/collaboration/TaskInterruptCardProjector.ts
+function clarifyFence(data) {
+  return ["```clarify", JSON.stringify(data), "```"].join("\n");
+}
+var TaskInterruptCardProjector = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Projects the interruption as a correlated room card when it is a clarify. */
+  async project(input) {
+    const clarify = readClarifyInterrupt(input.state);
+    if (!clarify) return;
+    const { task, messageId } = input;
+    const workspaceId = task.workspaceId;
+    const projectId = task.projectId;
+    if (!workspaceId || !projectId) return;
+    const adapter = this.deps.adapter;
+    const sendInterrupt = adapter.sendInterrupt;
+    if (!sendInterrupt) {
+      this.safeWarn("project-room:task-interrupt-card-unsupported", { taskId: task.id });
+      return;
+    }
+    try {
+      const room = snapshotProjectRoom(await this.deps.rooms.getMainRoom(task.tenantId, projectId));
+      if (!room || !room.id || room.tenantId !== task.tenantId || room.workspaceId !== workspaceId || room.projectId !== projectId) return;
+      const membership = snapshotBotMembership(await this.deps.bots.findByAssistant(task.tenantId, projectId, task.ownerId));
+      if (!membership || membership.tenantId !== task.tenantId || membership.workspaceId !== workspaceId || membership.projectId !== projectId || membership.roomId !== room.id || membership.assistantId !== task.ownerId || membership.status !== "active") return;
+      const installation = await this.deps.installation.ensure(task.tenantId);
+      const text = clarifyFence({ taskId: task.id, questions: clarify.questions });
+      await sendInterrupt.call(
+        adapter,
+        { adapterChannel: "room", channelInstallationId: installation.id, rawTarget: { targetMembershipId: membership.id } },
+        { text, metadata: { correlationKey: `task:${task.id}:${messageId}` } },
+        installation
+      );
+    } catch (error) {
+      this.safeWarn("project-room:task-interrupt-card-failed", { taskId: task.id, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  /** Logs without ever letting a failing logger reject `project()`. */
+  safeWarn(message, context) {
+    try {
+      this.deps.log.warn(message, context);
+    } catch {
+    }
+  }
+};
+
 // src/services/collaboration/ProjectTaskObserver.ts
 import { createHash as createHash7 } from "crypto";
 import {
@@ -22707,25 +22904,25 @@ async function transferGovernedDispatchOwner(task, options, deps) {
 function broadcastModelProviderChanged(tenantId, providerId2) {
   if (!tenantId) return;
   try {
-    const outbox = getStoreLattice17("default", "outbox").store;
+    const outbox = getStoreLattice18("default", "outbox").store;
     void publishModelProviderChanged(outbox, getReplicaId6(), tenantId, providerId2);
   } catch {
   }
 }
 var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
-  const webAppStore = getStoreLattice17("default", "agentWebApp").store;
-  const assistantStore = getStoreLattice17("default", "assistant").store;
-  const projectStore = getStoreLattice17("default", "project").store;
-  const projectMembershipStore = getStoreLattice17("default", "projectMembership").store;
-  const userTenantLinkStore = getStoreLattice17("default", "userTenantLink").store;
-  const projectRoomStore = getStoreLattice17("default", "projectRoom").store;
-  const projectBotMembershipStore = getStoreLattice17("default", "projectBotMembership").store;
-  const projectRoomMessageStore = getStoreLattice17("default", "projectRoomMessage").store;
-  const projectRoomReadStateStore = getStoreLattice17("default", "projectRoomReadState").store;
-  const userPushSubscriptionStore = getStoreLattice17("default", "userPushSubscription").store;
-  const threadStore = getStoreLattice17("default", "thread").store;
-  const taskStore = getStoreLattice17("default", "task").store;
-  const taskWorkItemStore = getStoreLattice17("default", "taskWorkItem").store;
+  const webAppStore = getStoreLattice18("default", "agentWebApp").store;
+  const assistantStore = getStoreLattice18("default", "assistant").store;
+  const projectStore = getStoreLattice18("default", "project").store;
+  const projectMembershipStore = getStoreLattice18("default", "projectMembership").store;
+  const userTenantLinkStore = getStoreLattice18("default", "userTenantLink").store;
+  const projectRoomStore = getStoreLattice18("default", "projectRoom").store;
+  const projectBotMembershipStore = getStoreLattice18("default", "projectBotMembership").store;
+  const projectRoomMessageStore = getStoreLattice18("default", "projectRoomMessage").store;
+  const projectRoomReadStateStore = getStoreLattice18("default", "projectRoomReadState").store;
+  const userPushSubscriptionStore = getStoreLattice18("default", "userPushSubscription").store;
+  const threadStore = getStoreLattice18("default", "thread").store;
+  const taskStore = getStoreLattice18("default", "task").store;
+  const taskWorkItemStore = getStoreLattice18("default", "taskWorkItem").store;
   const projectTaskEnabled = options.projectTaskEnabled ?? process.env.AXIOM_PROJECT_TASK_EXECUTION_ENABLED !== "false";
   const accessService = new ProjectAccessService({ projectStore, membershipStore: projectMembershipStore, userTenantLinkStore });
   const realtimeMode = resolveProjectRoomRealtimeMode();
@@ -22791,7 +22988,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     updateAssistant: assistantStore.updateAssistant.bind(assistantStore)
   });
   const resolveCoordinatorMentionName = async (tenantId) => {
-    const tenant2 = await getStoreLattice17("default", "tenant").store.getTenantById(tenantId);
+    const tenant2 = await getStoreLattice18("default", "tenant").store.getTenantById(tenantId);
     const value = tenant2?.metadata?.coordinatorMentionName;
     return typeof value === "string" && value.length > 0 ? value : void 0;
   };
@@ -22809,31 +23006,11 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope),
     log: realtimeLog
   });
-  const roomInterruptService = new RoomInterruptService({
-    requireAccess: async ({ tenantId, userId, projectId }) => {
-      await accessService.requireProjectAccess({ tenantId, userId, projectId, capability: "send" });
-    },
-    resolveMembership: async ({ tenantId, projectId, membershipId }) => {
-      const membership = await projectBotMembershipStore.findById(tenantId, membershipId);
-      return membership !== null && membership.projectId === projectId ? membership : null;
-    },
-    getThreadStatus: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
-      const agent = agentInstanceManager6.getAgent({
-        tenant_id: tenantId,
-        assistant_id: assistantId,
-        thread_id: threadId,
-        workspace_id: workspaceId,
-        project_id: projectId
-      });
-      return String(await agent.getRunStatus());
-    },
-    dispatcher: createTrustedAgentMessageDispatcher((scope) => agentInstanceManager6.getAgent(scope)),
-    projects: projectStore
-  });
   const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: projectMutationMutex2, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
   const rosterService = new ProjectRosterService({
     accessService,
     roomService,
+    roomStore: projectRoomStore,
     membershipStore: projectBotMembershipStore,
     projects: projectStore,
     agents: { list: async (tenantId, userId) => (await collectTenantAssistants(tenantId, userId)).map((assistant) => ({ assistantId: assistant.id, name: assistant.name, ...assistant.ownerUserId === void 0 ? {} : { ownerUserId: assistant.ownerUserId } })) },
@@ -22883,6 +23060,14 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       messageId: event.messageId
     }) : void 0
   });
+  const roomAdapter = channelDeps?.adapterRegistry.get("room");
+  const taskInterruptProjector = installation && roomAdapter ? new TaskInterruptCardProjector({
+    rooms: projectRoomStore,
+    bots: projectBotMembershipStore,
+    installation,
+    adapter: roomAdapter,
+    log: realtimeLog
+  }) : void 0;
   const projectTaskRuntime = projectTaskEnabled ? tryCreateProjectTaskRuntime({
     taskStore,
     taskWorkItemStore,
@@ -22894,7 +23079,10 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     realtime,
     log: options.projectTaskLog,
     ensurePublicOwner: (scope) => rosterService.ensurePublicProjectAgent(scope),
-    ...coordinatorWakeNotifier === void 0 ? {} : { coordinatorWake: coordinatorWakeNotifier }
+    ...coordinatorWakeNotifier === void 0 ? {} : { coordinatorWake: coordinatorWakeNotifier },
+    ...taskInterruptProjector === void 0 ? {} : {
+      onTaskInterrupted: (input) => taskInterruptProjector.project(input)
+    }
   }) : { reason: void 0 };
   const projectTaskComposition = "composition" in projectTaskRuntime ? projectTaskRuntime.composition : void 0;
   const projectTaskUnavailableReason = "reason" in projectTaskRuntime ? projectTaskRuntime.reason : void 0;
@@ -22924,6 +23112,39 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     }),
     reassign: unsupportedHumanReassign
   });
+  const roomInterruptService = new RoomInterruptService({
+    requireAccess: async ({ tenantId, userId, projectId }) => {
+      await accessService.requireProjectAccess({ tenantId, userId, projectId, capability: "send" });
+    },
+    resolveMembership: async ({ tenantId, projectId, membershipId }) => {
+      const membership = await projectBotMembershipStore.findById(tenantId, membershipId);
+      return membership !== null && membership.projectId === projectId ? membership : null;
+    },
+    getThreadStatus: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
+      const agent = agentInstanceManager6.getAgent({
+        tenant_id: tenantId,
+        assistant_id: assistantId,
+        thread_id: threadId,
+        workspace_id: workspaceId,
+        project_id: projectId
+      });
+      return String(await agent.getRunStatus());
+    },
+    getThreadState: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
+      const agent = agentInstanceManager6.getAgent({
+        tenant_id: tenantId,
+        assistant_id: assistantId,
+        thread_id: threadId,
+        workspace_id: workspaceId,
+        project_id: projectId
+      });
+      return agent.getCurrentState();
+    },
+    dispatcher: createTrustedAgentMessageDispatcher((scope) => agentInstanceManager6.getAgent(scope)),
+    projects: projectStore,
+    tasks: taskStore,
+    execution: projectTaskComposition?.lease.runtime.execution
+  });
   const publicRoomService = new WorkspacePublicRoomService({
     getProjectById: projectStore.getProjectById.bind(projectStore),
     createProject: projectStore.createProject.bind(projectStore),
@@ -22954,7 +23175,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     readStateService,
     interruptService: roomInterruptService,
     userDirectory: {
-      getUserById: (id3) => getStoreLattice17("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
+      getUserById: (id3) => getStoreLattice18("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
     }
   });
   registerProjectRosterRoutes(app2, { service: rosterService });
@@ -22965,7 +23186,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       createProject: projectStore.createProject.bind(projectStore)
     },
     workspaceStore: {
-      getWorkspaceById: (tenantId, id3) => getStoreLattice17("default", "workspace").store.getWorkspaceById(tenantId, id3)
+      getWorkspaceById: (tenantId, id3) => getStoreLattice18("default", "workspace").store.getWorkspaceById(tenantId, id3)
     },
     membershipStore: {
       list: projectMembershipStore.list.bind(projectMembershipStore),
@@ -22988,7 +23209,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       getUsersByTenant: userTenantLinkStore.getUsersByTenant.bind(userTenantLinkStore)
     },
     userStore: {
-      getUserById: (id3) => getStoreLattice17("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
+      getUserById: (id3) => getStoreLattice18("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
     },
     assistantStore: {
       getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
@@ -23010,17 +23231,18 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     }
   });
   registerCapabilityBundleRoutes(app2, new CapabilityBundleController({
-    bundleStore: getStoreLattice17("default", "capabilityBundle").store,
+    bundleStore: getStoreLattice18("default", "capabilityBundle").store,
     projectStore
   }, { authRequired: process.env.AUTH_REQUIRED === "true" }));
   const modelProviderController = new ModelProviderController({
-    providerStore: getStoreLattice17("default", "modelProvider").store,
+    providerStore: getStoreLattice18("default", "modelProvider").store,
     userTenantLinkStore,
     registry: {
       register: (tenantId, modelKey2, config) => modelLatticeManager3.registerLatticeWithTenant(tenantId, modelKey2, config),
       has: (tenantId, modelKey2) => modelLatticeManager3.hasLatticeWithTenant(tenantId, modelKey2),
       remove: (tenantId, modelKey2) => modelLatticeManager3.removeLatticeWithTenant(tenantId, modelKey2),
-      listRegistered: (tenantId) => modelLatticeManager3.getLatticeKeysByTenant(tenantId)
+      listRegistered: (tenantId) => modelLatticeManager3.getLatticeKeysByTenant(tenantId),
+      forgetTenantDefaultMiss: (tenantId) => modelLatticeManager3.forgetTenantDefaultMiss(tenantId)
     },
     onChanged: (tenantId, providerId2) => broadcastModelProviderChanged(tenantId, providerId2)
   }, { authRequired: process.env.AUTH_REQUIRED === "true" });
@@ -23031,7 +23253,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       webAppStore,
       assistantStore,
       projectStore,
-      modelRegistry: { has: (key) => modelLatticeManager3.hasLattice(key) },
+      modelRegistry: {
+        has: (tenantId, key) => hasModelLatticeForTenant3(tenantId, key)
+      },
       configuredAgentResolver: createConfiguredAgentResolver({
         hydrate: (tenantId) => agentLatticeManager4.initializeStoredAssistantsForTenant(tenantId),
         has: (tenantId, assistantId) => agentLatticeManager4.hasAgentLatticeWithTenant(tenantId, assistantId)
@@ -23076,7 +23300,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
-      threadStore: getStoreLattice17("default", "thread").store,
+      threadStore: getStoreLattice18("default", "thread").store,
       projectStore,
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
@@ -23088,8 +23312,8 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         }
       },
       modelRegistry: {
-        has: (key) => modelLatticeManager3.hasLattice(key),
-        label: (key) => key
+        has: (tenantId, key) => hasModelLatticeForTenant3(tenantId, key),
+        label: async (tenantId, key) => (await resolveModelLatticeForTenant(tenantId, key))?.client.getConfig().displayName ?? key
       },
       messageReader: {
         getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => agentInstanceManager6.getAgentForRead({
@@ -23502,9 +23726,9 @@ function tryCreateProjectTaskRuntime(input) {
   let stores;
   try {
     stores = {
-      tenants: getStoreLattice17("default", "tenant").store,
-      workspaces: getStoreLattice17("default", "workspace").store,
-      queue: getStoreLattice17("default", "threadMessageQueue").store
+      tenants: getStoreLattice18("default", "tenant").store,
+      workspaces: getStoreLattice18("default", "workspace").store,
+      queue: getStoreLattice18("default", "threadMessageQueue").store
     };
     const missing = missingRuntimeMethod(input, stores);
     if (missing) return { reason: missing };
@@ -23564,7 +23788,8 @@ function createRuntime(input, stores, log2) {
       dispatcher: createTrustedAgentMessageDispatcher((scope) => agentInstanceManager6.getAgent(scope)),
       queue: stores.queue,
       agentFor,
-      ...input.ensurePublicOwner === void 0 ? {} : { ensurePublicOwner: input.ensurePublicOwner }
+      ...input.ensurePublicOwner === void 0 ? {} : { ensurePublicOwner: input.ensurePublicOwner },
+      ...input.onTaskInterrupted === void 0 ? {} : { onTaskInterrupted: input.onTaskInterrupted }
     },
     {
       settlementTimeoutMs: PROJECT_TASK_SETTLEMENT_TIMEOUT_MS,
@@ -23886,9 +24111,9 @@ var skillRegistration = {
 };
 
 // src/export_registrations/agent.registration.ts
-import { getStoreLattice as getStoreLattice18 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice19 } from "@axiom-lattice/core";
 function getStore2() {
-  return getStoreLattice18("default", "assistant").store;
+  return getStoreLattice19("default", "assistant").store;
 }
 var agentRegistration = {
   entityType: "agent",
@@ -23968,9 +24193,9 @@ var agentRegistration = {
 };
 
 // src/export_registrations/database-config.registration.ts
-import { getStoreLattice as getStoreLattice19 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice20 } from "@axiom-lattice/core";
 function getStore3() {
-  return getStoreLattice19("default", "database").store;
+  return getStoreLattice20("default", "database").store;
 }
 var databaseConfigRegistration = {
   entityType: "database_config",
@@ -24050,9 +24275,9 @@ var databaseConfigRegistration = {
 };
 
 // src/export_registrations/metrics-config.registration.ts
-import { getStoreLattice as getStoreLattice20 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice21 } from "@axiom-lattice/core";
 function getStore4() {
-  return getStoreLattice20("default", "metrics").store;
+  return getStoreLattice21("default", "metrics").store;
 }
 var metricsConfigRegistration = {
   entityType: "metrics_config",
@@ -24132,9 +24357,9 @@ var metricsConfigRegistration = {
 };
 
 // src/export_registrations/mcp-config.registration.ts
-import { getStoreLattice as getStoreLattice21 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice22 } from "@axiom-lattice/core";
 function getStore5() {
-  return getStoreLattice21("default", "mcp").store;
+  return getStoreLattice22("default", "mcp").store;
 }
 var mcpConfigRegistration = {
   entityType: "mcp_config",
@@ -24217,9 +24442,9 @@ var mcpConfigRegistration = {
 };
 
 // src/export_registrations/connection.registration.ts
-import { getStoreLattice as getStoreLattice22 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice23 } from "@axiom-lattice/core";
 function getStore6() {
-  return getStoreLattice22("default", "connection").store;
+  return getStoreLattice23("default", "connection").store;
 }
 async function listAllConnections(tenantId) {
   const store = getStore6();
@@ -24304,9 +24529,9 @@ var connectionRegistration = {
 };
 
 // src/export_registrations/collection.registration.ts
-import { getStoreLattice as getStoreLattice23 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice24 } from "@axiom-lattice/core";
 function getStore7() {
-  return getStoreLattice23("default", "collection").store;
+  return getStoreLattice24("default", "collection").store;
 }
 var collectionRegistration = {
   entityType: "collection",
@@ -24377,7 +24602,7 @@ var collectionRegistration = {
 };
 
 // src/export_registrations/channel-installation.registration.ts
-import { getStoreLattice as getStoreLattice24 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice25 } from "@axiom-lattice/core";
 import { randomUUID as randomUUID25 } from "crypto";
 var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var PUBLIC_CHANNELS = /* @__PURE__ */ new Set(["lark", "email", "slack", "wechat"]);
@@ -24411,7 +24636,7 @@ function validateImportData(data) {
   };
 }
 function getStore8() {
-  return getStoreLattice24("default", "channelInstallation").store;
+  return getStoreLattice25("default", "channelInstallation").store;
 }
 function getOverwriteError(tenantId, incomingChannel, existing) {
   if (!existing) return "Channel installation overwrite target must exist";
@@ -24545,9 +24770,9 @@ var channelInstallationRegistration = {
 };
 
 // src/export_registrations/menu.registration.ts
-import { getStoreLattice as getStoreLattice25 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice26 } from "@axiom-lattice/core";
 function getStore9() {
-  return getStoreLattice25("default", "menu").store;
+  return getStoreLattice26("default", "menu").store;
 }
 var menuRegistration = {
   entityType: "menu",
@@ -24625,9 +24850,9 @@ var menuRegistration = {
 };
 
 // src/export_registrations/eval.registration.ts
-import { getStoreLattice as getStoreLattice26 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice27 } from "@axiom-lattice/core";
 function getStore10() {
-  return getStoreLattice26("default", "eval").store;
+  return getStoreLattice27("default", "eval").store;
 }
 var evalRegistration = {
   entityType: "eval",
@@ -25488,13 +25713,16 @@ import {
   getLoggerLattice,
   loggerLatticeManager,
   sandboxLatticeManager as sandboxLatticeManager2,
-  getStoreLattice as getStoreLattice29,
+  getStoreLattice as getStoreLattice30,
   agentInstanceManager as agentInstanceManager9,
   createSandboxProvider,
   TokenCache,
   mcpManager as mcpManager3,
   convertToConnection as convertToConnection2,
   createTrustedAgentMessageDispatcher as createTrustedAgentMessageDispatcher2,
+  connectAllChannels,
+  disconnectAllChannels,
+  ChannelConnectionLeader,
   runAsLeader,
   configureCoordinationLeaseStore,
   getReplicaId as getReplicaId7,
@@ -25516,7 +25744,7 @@ import { RoomAgentMessageService } from "@axiom-lattice/core";
 
 // src/router/MessageRouter.ts
 import {
-  getStoreLattice as getStoreLattice27,
+  getStoreLattice as getStoreLattice28,
   agentInstanceManager as agentInstanceManager8
 } from "@axiom-lattice/core";
 import {
@@ -25807,7 +26035,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = getStoreLattice27("default", "thread").store;
+          const threadStore = getStoreLattice28("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -25844,7 +26072,7 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = getStoreLattice27("default", "thread").store;
+          const threadStore = getStoreLattice28("default", "thread").store;
           const newThreadId = randomUUID27();
           console.log({
             event: "dispatch:thread:create",
@@ -26106,10 +26334,23 @@ function createRoomChannelAdapter(writer) {
       const installed = installationValues(installation);
       if (!installed) throw new Error("Invalid room installation");
       const targetEnvelope = exactValues2(replyTarget, ["adapterChannel", "channelInstallationId", "rawTarget"]);
-      const target = exactStrings(targetEnvelope?.rawTarget, ["sourceRoomMessageId", "targetMembershipId", "inputMessageId"]);
       const envelope = exactValues2(message, ["text", "metadata"]);
-      const metadata = exactStrings(envelope?.metadata, ["inputMessageId"]);
-      if (!targetEnvelope || targetEnvelope.adapterChannel !== "room" || targetEnvelope.channelInstallationId !== installation.id || !target || !metadata || typeof envelope?.text !== "string") throw new Error("Invalid room interrupt");
+      if (!targetEnvelope || targetEnvelope.adapterChannel !== "room" || targetEnvelope.channelInstallationId !== installation.id || typeof envelope?.text !== "string") throw new Error("Invalid room interrupt");
+      const correlationKey = exactStrings(envelope.metadata, ["correlationKey"])?.correlationKey;
+      if (correlationKey) {
+        const correlatedTarget = exactStrings(targetEnvelope.rawTarget, ["targetMembershipId"]);
+        if (!correlatedTarget) throw new Error("Invalid room interrupt correlation");
+        await writer.postCorrelatedInterrupt({
+          tenantId: installed.tenantId,
+          membershipId: correlatedTarget.targetMembershipId,
+          correlationKey,
+          text: envelope.text
+        });
+        return;
+      }
+      const target = exactStrings(targetEnvelope.rawTarget, ["sourceRoomMessageId", "targetMembershipId", "inputMessageId"]);
+      const metadata = exactStrings(envelope.metadata, ["inputMessageId"]);
+      if (!target || !metadata) throw new Error("Invalid room interrupt");
       if (target.inputMessageId !== metadata.inputMessageId) throw new Error("Invalid room interrupt correlation");
       await writer.postInterrupt({
         tenantId: installed.tenantId,
@@ -26246,7 +26487,7 @@ var PluginDeploymentService = class {
     this.now = deps.clock ?? Date.now;
     this.logger = deps.logger ?? { info: () => void 0 };
     this.limits = deps.limits ?? {};
-    this.serviceBaseUrl = (deps.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_URL ?? "").replace(
+    this.serviceBaseUrl = (deps.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_BASE_URL ?? "").replace(
       /\/$/,
       ""
     );
@@ -26934,7 +27175,7 @@ function isPluginDeploymentRuntimeEnabled(env = process.env) {
   const flag = env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG];
   if (flag === "false" || flag === "0") return false;
   if (flag === "true" || flag === "1") return true;
-  return Boolean(env.MICROSANDBOX_SERVICE_URL);
+  return Boolean(env.MICROSANDBOX_SERVICE_BASE_URL);
 }
 function readPluginDeploymentLimits(env = process.env) {
   return {
@@ -26951,10 +27192,10 @@ function readPluginDeploymentLimits(env = process.env) {
 function startPluginDeploymentRuntime(options) {
   const { lease, holder, logger: logger7 } = options;
   const forcedOn = process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "true" || process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "1";
-  const effectiveServiceBaseUrl = options.wiring.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_URL;
+  const effectiveServiceBaseUrl = options.wiring.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_BASE_URL;
   if (forcedOn && !effectiveServiceBaseUrl) {
     logger7.warn(
-      `${PLUGIN_DEPLOYMENT_RUNTIME_FLAG} is enabled but MICROSANDBOX_SERVICE_URL is empty; skipping plugin deployment runtime`,
+      `${PLUGIN_DEPLOYMENT_RUNTIME_FLAG} is enabled but MICROSANDBOX_SERVICE_BASE_URL is empty; skipping plugin deployment runtime`,
       { holder }
     );
     return { reconcile: Promise.resolve(), dispose: async () => void 0 };
@@ -27104,7 +27345,7 @@ function errorMessage5(error) {
 }
 
 // src/services/multiReplicaReadiness.ts
-import { getStoreLattice as getStoreLattice28 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice29 } from "@axiom-lattice/core";
 var SHARED_STORE_KINDS = [
   "lease",
   "outbox",
@@ -27115,7 +27356,7 @@ var SHARED_STORE_KINDS = [
 ];
 function storeClassName(kind) {
   try {
-    return getStoreLattice28("default", kind).store.constructor?.name;
+    return getStoreLattice29("default", kind).store.constructor?.name;
   } catch {
     return void 0;
   }
@@ -27403,7 +27644,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = getStoreLattice29("default", "mcp");
+    const storeLattice = getStoreLattice30("default", "mcp");
     const store = storeLattice.store;
     if (!store) {
       logger6.info("MCP store not configured, skipping connection restoration");
@@ -27458,9 +27699,9 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: getStoreLattice29("default", "task").store,
-        rooms: getStoreLattice29("default", "projectRoom").store,
-        memberships: getStoreLattice29("default", "projectBotMembership").store,
+        tasks: getStoreLattice30("default", "task").store,
+        rooms: getStoreLattice30("default", "projectRoom").store,
+        memberships: getStoreLattice30("default", "projectBotMembership").store,
         log: { warn: (message, context) => logger6.warn(message, context) }
       });
     }
@@ -27470,10 +27711,9 @@ var start = async (config) => {
     const { wechatChannelAdapter } = await import("./WechatChannelAdapter-7WHE5UGY.mjs");
     adapterRegistry.register(wechatChannelAdapter);
     try {
-      const { getStoreLattice: getStore11 } = await import("@axiom-lattice/core");
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
-        getStore: ((kind) => getStore11("default", kind).store),
+        getStore: ((kind) => getStoreLattice30("default", kind).store),
         trustedDispatcher: createTrustedAgentMessageDispatcher2((scope) => agentInstanceManager9.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
@@ -27503,7 +27743,7 @@ var start = async (config) => {
     }
     setEvalRunService(evalRunner);
     try {
-      const menuStore = getStoreLattice29("default", "menu").store;
+      const menuStore = getStoreLattice30("default", "menu").store;
       setMenuRegistry(menuStore);
       logger6.info("Menu registry initialized");
     } catch {
@@ -27521,10 +27761,10 @@ var start = async (config) => {
       const { A2AAuthService: A2AAuthService2, parseEnvKeys: parseEnvKeys2 } = await import("./A2AAuthService-7UGQ7GMW.mjs");
       const { registerA2AStandardRoutes } = await import("./a2a-standard-PBYPNHOA.mjs");
       const a2a = await import("./a2a-BHBLACJV.mjs");
-      const a2aKeyStore = getStoreLattice29("default", "a2aApiKey").store;
-      const assistantStore = getStoreLattice29("default", "assistant").store;
-      const projectStore = getStoreLattice29("default", "project").store;
-      const taskStore = getStoreLattice29("default", "task").store;
+      const a2aKeyStore = getStoreLattice30("default", "a2aApiKey").store;
+      const assistantStore = getStoreLattice30("default", "assistant").store;
+      const projectStore = getStoreLattice30("default", "project").store;
+      const taskStore = getStoreLattice30("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -27549,22 +27789,22 @@ var start = async (config) => {
       });
     }
     try {
-      const { registerOpenRoutes } = await import("./open-UVKMONVE.mjs");
+      const { registerOpenRoutes } = await import("./open-FJ3BY3CL.mjs");
       const { registerOpenSessionRoutes } = await import("./open-session-2Y7XJJW2.mjs");
       const { registerOpenCatalogRoutes } = await import("./open-catalog-SZQ435AY.mjs");
-      const { registerOpenFilesRoutes } = await import("./open-files-X3HXVEEM.mjs");
+      const { registerOpenFilesRoutes } = await import("./open-files-V3R2BFTV.mjs");
       const { registerOpenAuditRoutes } = await import("./open-audit-UJ3NXCGW.mjs");
-      const { registerOpenExposureRoutes } = await import("./open-exposure-27ESFWTB.mjs");
+      const { registerOpenExposureRoutes } = await import("./open-exposure-OX5NKWDG.mjs");
       const { openLattice } = await import("./openLattice-Q6M5S6CY.mjs");
       const { createKbProvider } = await import("./kbProvider-2D6DZ34N.mjs");
-      const { createOpenSandboxProvider } = await import("./sandboxProvider-DUYWHYJN.mjs");
+      const { createOpenSandboxProvider } = await import("./sandboxProvider-FILMFVIM.mjs");
       const { createAgentProvider } = await import("./agentProvider-X4FVQPKW.mjs");
       const { registerExposedPluginTools } = await import("./registerExposedPlugins-6GCOE64C.mjs");
       const { CollectionService: CollectionService2 } = await import("./collection_service-RTRJEQFL.mjs");
       openLattice.register(createKbProvider(new CollectionService2()));
       openLattice.register(createOpenSandboxProvider());
-      const threadStore = getStoreLattice29("default", "thread").store;
-      const assistantStore = getStoreLattice29("default", "assistant").store;
+      const threadStore = getStoreLattice30("default", "thread").store;
+      const assistantStore = getStoreLattice30("default", "assistant").store;
       openLattice.register(
         createAgentProvider({
           threadStore,
@@ -27604,9 +27844,9 @@ var start = async (config) => {
     }
     if (isPluginDeploymentRuntimeEnabled()) {
       try {
-        const pluginDeploymentStore = getStoreLattice29("default", "pluginDeployment").store;
-        const tenantStore = getStoreLattice29("default", "tenant").store;
-        const leaseStore2 = getStoreLattice29("default", "lease").store;
+        const pluginDeploymentStore = getStoreLattice30("default", "pluginDeployment").store;
+        const tenantStore = getStoreLattice30("default", "tenant").store;
+        const leaseStore2 = getStoreLattice30("default", "lease").store;
         const listAllDeployments = async () => {
           const tenants = await tenantStore.getAllTenants();
           const lists = await Promise.all(
@@ -27648,7 +27888,7 @@ var start = async (config) => {
     }
     try {
       const { ResourceController } = await import("./resources-2L3KSUUU.mjs");
-      const sharedResourceStore = getStoreLattice29("default", "sharedResource").store;
+      const sharedResourceStore = getStoreLattice30("default", "sharedResource").store;
       const cache = new TokenCache();
       const resourceController = new ResourceController({
         store: sharedResourceStore,
@@ -27664,10 +27904,9 @@ var start = async (config) => {
       });
     }
     if (channelDeps && process.env.CHANNELS_ENABLED !== "false") {
-      const { connectAllChannels, disconnectAllChannels, ChannelConnectionLeader } = await import("@axiom-lattice/core");
       try {
         const channelLeader = new ChannelConnectionLeader({
-          leaseStore: getStoreLattice29("default", "lease").store,
+          leaseStore: getStoreLattice30("default", "lease").store,
           owner: getReplicaId7(),
           connect: () => connectAllChannels((channel) => adapterRegistry.get(channel), {
             deps: { router: channelDeps.router }
@@ -27686,8 +27925,8 @@ var start = async (config) => {
       }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
-    configureCoordinationLeaseStore(getStoreLattice29("default", "lease").store);
-    const outboxStore = getStoreLattice29("default", "outbox").store;
+    configureCoordinationLeaseStore(getStoreLattice30("default", "lease").store);
+    const outboxStore = getStoreLattice30("default", "outbox").store;
     taskLifecycleNotifier3.setOutbox(outboxStore);
     projectTaskAdmissionNotifier2.setOutbox(outboxStore);
     configurePluginCatalogSync({ outbox: outboxStore, owner: getReplicaId7() });
@@ -27713,7 +27952,7 @@ var start = async (config) => {
         "assistant-changed": (payload) => handleAssistantChanged(payload, (tenantId) => agentLatticeManager5.initializeStoredAssistantsForTenant(tenantId)),
         [A2A_KEY_CHANGED_TOPIC]: (payload) => handleA2AKeyChanged(payload, () => refreshStoreKeyMap()),
         [MCP_CONFIG_CHANGED_TOPIC]: (payload) => reconcileMcpConfigChange(payload, {
-          store: getStoreLattice29("default", "mcp").store,
+          store: getStoreLattice30("default", "mcp").store,
           manager: mcpManager3,
           convertToConnection: convertToConnection2
         }),
@@ -27734,7 +27973,7 @@ var start = async (config) => {
     } catch (err) {
       logger6.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
     }
-    const leaseStore = getStoreLattice29("default", "lease").store;
+    const leaseStore = getStoreLattice30("default", "lease").store;
     if (leaseStore.constructor?.name === "InMemoryLeaseStore") {
       logger6.warn(
         "Startup recovery leader gate uses a non-distributed lease store (per-process only); configure a shared 'lease' store for multi-replica deployments",
@@ -27751,9 +27990,9 @@ var start = async (config) => {
           const { createOrphanRecoveryRuntime: createOrphanRecoveryRuntime2 } = await import("./OrphanRecoveryRuntime-BEFILJMU.mjs");
           const { createRecoveryCallerDeps: createRecoveryCallerDeps2 } = await import("./RecoveryCallerDeps-6SJUYJ5S.mjs");
           const runtime = createOrphanRecoveryRuntime2({
-            taskStore: getStoreLattice29("default", "task").store,
-            workItemStore: getStoreLattice29("default", "taskWorkItem").store,
-            tenantStore: getStoreLattice29("default", "tenant").store,
+            taskStore: getStoreLattice30("default", "task").store,
+            workItemStore: getStoreLattice30("default", "taskWorkItem").store,
+            tenantStore: getStoreLattice30("default", "tenant").store,
             ...createRecoveryCallerDeps2(),
             log: logger6
           });