@holokai/holo 1.5.2 → 1.5.3

package/dist/holo.js

@@ -661,7 +661,8 @@ var init_protocol = __esm({
       EMBED: "embed",
       RERANK: "rerank",
       MODELS: "models",
-      METRICS: "metrics"
+      METRICS: "metrics",
+      IMAGE: "image"
     };
   }
 });
@@ -760,6 +761,7 @@ var init_types4 = __esm({
     ProviderEventType = {
       STREAM_EVENT: "stream_event",
       TEXT_DELTA: "text_delta",
+      REASONING_DELTA: "reasoning_delta",
       TOOL_CALL_DELTA: "tool_call_delta",
       DONE: "done",
       ERROR: "error"
@@ -1275,6 +1277,11 @@ data: ${JSON.stringify(data)}
             chunks.push(await this.chunkify(ev, async () => this.formatWire(deltaEvent)));
             return chunks;
           }
+          case "reasoning_delta": {
+            const reasoningEvent = this.emitReasoningDelta(0, ev.text);
+            chunks.push(await this.chunkify(ev, async () => this.formatWire(reasoningEvent)));
+            return chunks;
+          }
           case "tool_call_delta": {
             const tcEv = ev;
             const holoEvent = this.emitToolCallDelta(tcEv.index, tcEv.delta);
@@ -1755,7 +1762,6 @@ var init_env2 = __esm({
       })(env2.redis || (env2.redis = {}));
       (function(queue) {
         queue.url = process.env.RABBITMQ_URL || "amqp://localhost:5672";
-        queue.reconnectAttempts = parseNumber(process.env.RABBITMQ_RECONNECT_ATTEMPTS, 5);
         queue.reconnectDelayMs = parseNumber(process.env.RABBITMQ_RECONNECT_DELAY_MS, 5e3);
         queue.prefetch = parseNumber(process.env.RABBITMQ_PREFETCH, 10);
         queue.maxMessageAgeMs = parseNumber(process.env.RABBITMQ_MAX_MESSAGE_AGE_MS, 18e5);
@@ -1779,14 +1785,13 @@ var init_env2 = __esm({
         queue.auditRoutingKey = process.env.AUDIT_ROUTING_KEY || q("audit");
         queue.batchQueue = process.env.RABBITMQ_BATCH_QUEUE || q("batch-jobs");
         queue.batchRoutingKey = process.env.BATCH_ROUTING_KEY || q("batch-jobs");
-        queue.queueExpiration = process.env.QUEUE_EXPIRATION || 36e5;
+        queue.queueExpiration = parseNumber(process.env.QUEUE_EXPIRATION, 36e5);
         queue.managementQueue = process.env.PROXY_MANAGEMENT_QUEUE || q("proxy_management");
         queue.notificationExchange = process.env.RABBITMQ_NOTIFICATION_EXCHANGE || q("notifications_exchange");
         queue.notificationQueue = process.env.RABBITMQ_NOTIFICATION_QUEUE || q("notifications");
         queue.auditNotificationQueue = process.env.RABBITMQ_AUDIT_NOTIFICATION_QUEUE || q("notifications_audit");
         queue.config = {
           url: queue.url,
-          reconnectAttempts: queue.reconnectAttempts,
           reconnectDelayMs: queue.reconnectDelayMs
         };
       })(env2.queue || (env2.queue = {}));
@@ -1870,7 +1875,7 @@ var VERSION;
 var init_version2 = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.5.2";
+    VERSION = "1.5.3";
   }
 });
 
@@ -2786,8 +2791,9 @@ var init_effective_model_db = __esm({
         this.db = db;
       }
       /**
-       * Resolve the effective binding for `(orgId, selector)`. `p_org` is always the token's
-       * `org_id` — never client-supplied — and the SRF filters org internally.
+       * Resolve the effective binding for `(orgId, selector, profileId)`. `p_org` is always the
+       * token's `org_id`, and `profileId` the token's mint-validated `profile_id` claim (or null
+       * when absent) — never client-supplied — and the SRF filters org internally.
        *
        * The SRF returns the org's set; Holo keys it by the exact selector (never another
        * selector's default — an unknown selector yields no row → 404). The selector is
@@ -2795,18 +2801,18 @@ var init_effective_model_db = __esm({
        * (`widget-jpql` vs `THINK_MAX`), so any normalization would silently break one
        * vocabulary or collide the two.
        *
-       * **`profile_id` is NOT a selection input** — it is attribution, and only becomes a
-       * selector in a later phase. There is exactly one row per `(org_id, alias)`, so this takes that
-       * single row and reads `profile_id` off it to record which profile was active when the
-       * serve happened. Filtering on `profile_id IS NULL` would be actively wrong: a
-       * chat-tier `SYSTEM_DEFAULT` row for an org with an active override profile carries
-       * that concrete profile id even though the override is unapplied, so the null filter
-       * would miss every such org's row and 404 a whole class of orgs.
+       * **`profile_id` is the third selection key** (moku P3 fan-out: one row per selectable
+       * profile, unique on `(org, purpose, profile_id)`). A concrete `profileId` selects its
+       * row; `null` selects the profile-less row (`profile_id IS NULL`) — the shape moku
+       * projects for internal purposes and for orgs with no authored profiles, the only orgs
+       * whose tokens omit the claim (the mint stamps the concrete default-profile id whenever
+       * any profile applies — `SystemModelTokenService.decideProfile`). No row for the triple
+       * fails closed (404); there is no fallback to another profile's row.
        *
        * The returned row may carry a null binding — callers must gate on
        * {@link isServableEffectiveModel} before any provider lookup.
        */
-      async getEffectiveModel(orgId, selector) {
+      async getEffectiveModel(orgId, selector, profileId) {
         return this.db.queryOne(`SELECT emr.provider_id,
                     emr.model_slug,
                     emr.source,
@@ -2816,9 +2822,11 @@ var init_effective_model_db = __esm({
                     emr.profile_id
              FROM ${SRF}($1::uuid) emr
              WHERE emr.${SELECTOR_COLUMN} = $2
+               AND (($3::uuid IS NULL AND emr.profile_id IS NULL) OR emr.profile_id = $3::uuid)
              LIMIT 1`, [
           orgId,
-          selector
+          selector,
+          profileId
         ]);
       }
     };
@@ -5562,6 +5570,27 @@ var init_datastore_db = __esm({
       async getAll() {
         return this.db.systemQuery("SELECT * FROM datastores ORDER BY created_at");
       }
+      /**
+       * Repoint every same-family datastore to the canonical plugin version —
+       * the datastore half of latest-only consolidation (mirrors
+       * ProviderDB.migrateToLatestPlugin; no junction table on this side).
+       * The $2::uuid casts keep PG16/Aurora's parameter-type deduction from
+       * failing when the parameter is reused as both assignment and comparand.
+       */
+      async migrateToLatestPlugin(family, latestPluginId) {
+        const rows = await this.db.systemQuery(`UPDATE datastores d
+             SET plugin_id  = $2::uuid,
+                 updated_at = now()
+             FROM plugins pl
+             WHERE d.plugin_id = pl.id
+               AND pl.family = $1
+               AND d.plugin_id <> $2::uuid
+             RETURNING d.id`, [
+          family.toUpperCase(),
+          latestPluginId
+        ]);
+        return rows.length;
+      }
       async getEnabled() {
         return this.db.systemQuery(`SELECT d.*, ac.encrypted_value, ac.initialization_vector
              FROM datastores d
@@ -6872,16 +6901,26 @@ var init_provider_plugin_service = __esm({
       }
       protocolDB;
       pluginProtocols = /* @__PURE__ */ new Map();
+      /**
+       * Each plugin's declared `defaultProtocol`, learned at registration. Capability
+       * lookups prefer it when it covers the capability — without this, a family with
+       * two protocols of one capability resolves by map insertion order, which is how
+       * OpenAI chat silently dispatched chatCompletions instead of responses.
+       */
+      pluginDefaults = /* @__PURE__ */ new Map();
       constructor(protocolDB) {
         super(), this.protocolDB = protocolDB;
       }
-      async registerProtocols(pluginId, routes) {
+      async registerProtocols(pluginId, routes, defaultProtocol) {
         const logger2 = this.mlog(this.registerProtocols);
         let protocols = this.pluginProtocols.get(pluginId);
         if (!protocols) {
           protocols = /* @__PURE__ */ new Map();
           this.pluginProtocols.set(pluginId, protocols);
         }
+        if (defaultProtocol) {
+          this.pluginDefaults.set(pluginId, defaultProtocol);
+        }
         for (const routeDef of routes) {
           const { protocol } = routeDef;
           const path5 = routeDef.paths.join(",");
@@ -6893,23 +6932,38 @@ var init_provider_plugin_service = __esm({
           }
         }
       }
-      async loadProtocolsFromDB(pluginId) {
+      async loadProtocolsFromDB(pluginId, defaultProtocol) {
         const protocols = await this.protocolDB.getByPlugin(pluginId);
         const map = /* @__PURE__ */ new Map();
         for (const p of protocols) {
           map.set(p.name, p);
         }
         this.pluginProtocols.set(pluginId, map);
+        if (defaultProtocol) {
+          this.pluginDefaults.set(pluginId, defaultProtocol);
+        }
       }
       removeProtocols(pluginId) {
         this.pluginProtocols.delete(pluginId);
+        this.pluginDefaults.delete(pluginId);
       }
       async getProtocol(pluginId, protocolName) {
         return this.pluginProtocols.get(pluginId)?.get(protocolName);
       }
+      /**
+       * The plugin's declared default wins when it covers the capability; otherwise
+       * first match. Both populators (`registerProtocols`, `loadProtocolsFromDB`)
+       * learn the default from the loaded plugin instance, so startup registration
+       * and runtime reload/remote-enable resolve identically.
+       */
       getProtocolByCapability(pluginId, capability) {
         const protocols = this.pluginProtocols.get(pluginId);
         if (!protocols) return void 0;
+        const preferredName = this.pluginDefaults.get(pluginId);
+        if (preferredName) {
+          const preferred = protocols.get(preferredName);
+          if (preferred?.capability === capability) return preferred;
+        }
         for (const protocol of protocols.values()) {
           if (protocol.capability === capability) return protocol;
         }
@@ -7155,6 +7209,13 @@ var init_plugin_registry = __esm({
       pluginDB;
       plugins = /* @__PURE__ */ new Map();
       loading = /* @__PURE__ */ new Map();
+      /**
+       * The DB row's sha256 AS OF the moment each plugin was loaded. Reconcile
+       * uses this as its baseline for plugins loaded outside the lifecycle
+       * service (boot-time loads) — comparing against the CURRENT row hash would
+       * miss an update that landed between load and reconcile.
+       */
+      loadedShas = /* @__PURE__ */ new Map();
       constructor(installer, discovery, loader, pluginDB) {
         super(), this.installer = installer, this.discovery = discovery, this.loader = loader, this.pluginDB = pluginDB;
       }
@@ -7178,6 +7239,10 @@ var init_plugin_registry = __esm({
       has(pluginId) {
         return this.plugins.has(pluginId);
       }
+      /** sha256 the plugin was loaded with, when it is loaded; undefined otherwise. */
+      loadedSha(pluginId) {
+        return this.plugins.has(pluginId) ? this.loadedShas.get(pluginId) : void 0;
+      }
       getAsProvider(pluginId) {
         return this.plugins.get(pluginId);
       }
@@ -7204,6 +7269,7 @@ var init_plugin_registry = __esm({
           plugin.destroy().catch(() => {
           });
           this.plugins.delete(pluginId);
+          this.loadedShas.delete(pluginId);
         }
       }
       async loadAllActive() {
@@ -7249,6 +7315,7 @@ var init_plugin_registry = __esm({
         }
         plugin.id = pluginId;
         this.plugins.set(pluginId, plugin);
+        this.loadedShas.set(pluginId, row.sha256 ?? "");
         log.info(`Plugin ${row.name}@${row.version} loaded and ready (${pluginId})`);
         return plugin;
       }
@@ -9253,6 +9320,7 @@ var init_token_verifier_support = __esm({
 // src/services/auth/on-behalf-token.service.ts
 import "reflect-metadata";
 import { injectable as injectable34 } from "tsyringe";
+import { validate as isUuid } from "uuid";
 function _ts_decorate34(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -9289,9 +9357,9 @@ var init_on_behalf_token_service = __esm({
       /**
        * verify — verify a raw bearer token against the requested alias. Resolves to the
        * request-scoped context (org + resolved selector from the token only) on success;
-       * rejects with a status-bearing, claim-free `HoloError` on any failed claim. The
-       * single-use `jti` is atomically consumed as the final step, so a token is spent only
-       * once fully accepted.
+       * rejects with a status-bearing, claim-free `HoloError` on any failed claim. The `jti` is
+       * consumed as the final step only when the token's `token_limit` selects single-use (the
+       * default); a `token_limit=0` token consumes nothing and may be reused until `exp`.
        *
        * `clientSuppliedProfile` reports only WHETHER the client attempted to select a profile,
        * because the sole thing done with it is refuse it — a value would imply it could
@@ -9299,46 +9367,136 @@ var init_on_behalf_token_service = __esm({
        */
       async verify(rawToken, requestedAlias, clientSuppliedProfile2 = false) {
         const logger2 = this.mlog(this.verify);
+        const loggedAlias = requestedAlias.length > 64 ? `${requestedAlias.slice(0, 64)}\u2026` : requestedAlias;
         if (!rawToken) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("no_bearer", HoloError.unauthorized("Invalid or unauthorized token."), {
+            requestedAlias: loggedAlias
+          });
+        }
+        let issuer;
+        try {
+          issuer = readUnverifiedIssuer(rawToken);
+        } catch (err) {
+          return this.deny("undecodable_jwt", err, {
+            requestedAlias: loggedAlias
+          });
         }
-        const issuer = readUnverifiedIssuer(rawToken);
         if (!env.onBehalf.trustedIssuers.includes(issuer)) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("untrusted_issuer", HoloError.unauthorized("Invalid or unauthorized token."), {
+            issuer,
+            requestedAlias: loggedAlias
+          });
         }
         const jwks = this.jwksResolver.get(issuer);
         if (!jwks) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("jwks_unresolved", HoloError.unauthorized("Invalid or unauthorized token."), {
+            issuer,
+            requestedAlias: loggedAlias
+          });
         }
-        const payload = await verifyRs256(rawToken, jwks, env.onBehalf.audience, issuer);
+        let payload;
+        try {
+          payload = await verifyRs256(rawToken, jwks, env.onBehalf.audience, issuer);
+        } catch (err) {
+          return this.deny("signature_or_standard_claims", err, {
+            issuer,
+            requestedAlias: loggedAlias
+          });
+        }
+        const diag = this.safeDiag(issuer, payload, loggedAlias);
         if (payload.capability !== REQUIRED_CAPABILITY) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("wrong_capability", HoloError.unauthorized("Invalid or unauthorized token."), diag);
+        }
+        try {
+          assertWithinEffectiveWindow(payload, env.onBehalf.maxTtlMs);
+        } catch (err) {
+          return this.deny("effective_window", err, diag);
         }
-        assertWithinEffectiveWindow(payload, env.onBehalf.maxTtlMs);
         if (!payload.org_id || !payload.sub) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("missing_org_or_sub", HoloError.unauthorized("Invalid or unauthorized token."), diag);
         }
         if (!payload.jti) {
-          throw HoloError.unauthorized("Invalid or unauthorized token.");
+          this.deny("missing_jti", HoloError.unauthorized("Invalid or unauthorized token."), diag);
+        }
+        const tokenLimit = payload.token_limit ?? 1;
+        if (tokenLimit !== 0 && tokenLimit !== 1) {
+          this.deny("token_limit_unsupported", HoloError.unauthorized("Invalid or unauthorized token."), diag);
         }
         const allowed = payload.allowed_aliases;
         if (!Array.isArray(allowed) || !allowed.includes(requestedAlias)) {
-          throw HoloError.forbidden("Requested model is not permitted for this token.");
+          this.deny("alias_not_permitted", HoloError.forbidden("Requested model is not permitted for this token."), diag);
         }
         if (clientSuppliedProfile2) {
-          throw HoloError.forbidden("Requested profile is not permitted for this token.");
+          this.deny("client_supplied_profile", HoloError.forbidden("Requested profile is not permitted for this token."), diag);
+        }
+        const profileClaim = payload.profile_id;
+        if (profileClaim !== void 0 && (typeof profileClaim !== "string" || !isUuid(profileClaim))) {
+          this.deny("malformed_profile_claim", HoloError.unauthorized("Invalid or unauthorized token."), diag);
+        }
+        const profileId = profileClaim ?? null;
+        if (tokenLimit === 1) {
+          try {
+            await this.consumeJti(payload.jti);
+          } catch (err) {
+            const replay = err instanceof HoloError && err.statusCode === 401;
+            return this.deny(replay ? "jti_replay" : "replay_store_unavailable", err, diag);
+          }
         }
-        await this.consumeJti(payload.jti);
         const selector = requestedAlias;
         logger2.info("On-behalf token accepted", {
           issuer,
           selector,
-          capability: payload.capability
+          capability: payload.capability,
+          has_profile: profileId !== null
         });
         return {
           organizationId: payload.org_id,
           sub: payload.sub,
-          selector
+          selector,
+          profileId
+        };
+      }
+      /**
+       * deny — log a claim-SAFE rejection reason to the server log, then throw the fixed,
+       * claim-free wire error unchanged (the wire message never gains a claim). Debug aid only:
+       * the `reason` names the exact gate that rejected, and `diag` carries only safe fields.
+       * NEVER logs the raw token (a live bearer credential) or `sub` (which may be an email);
+       * `sub` is reported as presence only. Returns `never` so callers narrow past it.
+       *
+       * The HTTP status rides `http_status`, not `status`: the logger reserves `status` for the log
+       * level and pads it as a string, so a numeric `status` field breaks the formatter.
+       */
+      deny(reason, error, diag = {}) {
+        this.mlog(this.verify).warn("On-behalf token rejected", {
+          reason,
+          http_status: error.statusCode,
+          ...diag
+        });
+        throw error;
+      }
+      /**
+       * safeDiag — claim-SAFE fields for a rejection log. `iss`/`capability`/`token_limit` are fixed
+       * scalars, `org_id`/`jti` are IDs, `iat`/`exp` are timings — all loggable. `sub` is deliberately
+       * reported only as presence (`hasSub`) because it may be an email; the raw token and the full
+       * payload are never dumped. `expiresInMs` is surfaced so an expiry/window rejection is obvious.
+       */
+      safeDiag(issuer, payload, loggedAlias) {
+        return {
+          issuer,
+          capability: payload.capability,
+          iat: payload.iat,
+          exp: payload.exp,
+          expiresInMs: typeof payload.exp === "number" ? payload.exp * 1e3 - Date.now() : null,
+          hasSub: !!payload.sub,
+          orgId: payload.org_id,
+          jti: payload.jti,
+          allowedAliases: Array.isArray(payload.allowed_aliases) ? payload.allowed_aliases : null,
+          requestedAlias: loggedAlias,
+          // The mint's replay-posture claim as sent (null when absent) — one scalar, so it stays
+          // claim-safe while showing why a token was single-use vs reusable. The full payload is
+          // deliberately never dumped: it carries `sub`/`email` PII, and a blanket dump could not
+          // stay claim-safe as the token contract grows.
+          token_limit: payload.token_limit ?? null
         };
       }
       /**
@@ -10136,7 +10294,7 @@ var init_plugin_service = __esm({
               case PluginType.PROVIDER: {
                 const providerPlugin = plugin;
                 const routes = providerPlugin.getRoutes();
-                await this.providerPluginService.registerProtocols(pluginId, routes);
+                await this.providerPluginService.registerProtocols(pluginId, routes, providerPlugin.defaultProtocol);
                 const pricingResult = await this.registerDefaultPricing(providerPlugin, family, pluginId);
                 log.info(`${tag}: ${routes.length} route(s), ${pricingResult}`);
                 break;
@@ -10177,7 +10335,7 @@ var init_plugin_service = __esm({
           case PluginType.PROVIDER: {
             const providerPlugin = plugin;
             const routes = providerPlugin.getRoutes();
-            await this.providerPluginService.registerProtocols(pluginRow.id, routes);
+            await this.providerPluginService.registerProtocols(pluginRow.id, routes, providerPlugin.defaultProtocol);
             await this.registerDefaultPricing(providerPlugin, family, pluginRow.id);
             break;
           }
@@ -10206,7 +10364,7 @@ var init_plugin_service = __esm({
         this.versionedPlugins.get(familyKey).set(pluginRow.version, pluginRow);
         switch (plugin.type) {
           case PluginType.PROVIDER: {
-            await this.providerPluginService.loadProtocolsFromDB(pluginId);
+            await this.providerPluginService.loadProtocolsFromDB(pluginId, plugin.defaultProtocol);
             break;
           }
           case PluginType.DATASTORE: {
@@ -10433,6 +10591,7 @@ var init_provider_impl_service = __esm({
     init_entities2();
     init_provider_db();
     init_plugin_db();
+    init_datastore_db();
     init_auth2();
     init_plugin_registry();
     init_plugin();
@@ -10447,30 +10606,39 @@ var init_provider_impl_service = __esm({
       pluginRegistry;
       providerDB;
       pluginDB;
+      datastoreDB;
       /** One impl per provider↔plugin association, keyed `${providerId}::${pluginId}`. */
       providerImpls = /* @__PURE__ */ new Map();
       /** providerId → primary plugin id, so bare lookups stay map-only on the hot path. */
       primaryPluginIds = /* @__PURE__ */ new Map();
-      constructor(providerService, cryptoService, pluginRegistry, providerDB, pluginDB) {
-        super(), this.providerService = providerService, this.cryptoService = cryptoService, this.pluginRegistry = pluginRegistry, this.providerDB = providerDB, this.pluginDB = pluginDB;
+      constructor(providerService, cryptoService, pluginRegistry, providerDB, pluginDB, datastoreDB) {
+        super(), this.providerService = providerService, this.cryptoService = cryptoService, this.pluginRegistry = pluginRegistry, this.providerDB = providerDB, this.pluginDB = pluginDB, this.datastoreDB = datastoreDB;
       }
       implKey(providerId, pluginId) {
         return `${providerId}::${pluginId}`;
       }
       async consolidateToLatest(seeded) {
         const log = this.mlog(this.consolidateToLatest);
-        const canonicalByFamily = /* @__PURE__ */ new Map();
+        const providersByFamily = /* @__PURE__ */ new Map();
+        const datastoresByFamily = /* @__PURE__ */ new Map();
         for (const plugin of seeded) {
-          if (plugin.type !== PluginType.PROVIDER) continue;
-          canonicalByFamily.set(plugin.family, plugin);
+          if (plugin.type === PluginType.PROVIDER) providersByFamily.set(plugin.family, plugin);
+          if (plugin.type === PluginType.DATASTORE) datastoresByFamily.set(plugin.family, plugin);
         }
-        for (const [family, canonical] of canonicalByFamily) {
+        for (const [family, canonical] of providersByFamily) {
           const repointed = await this.providerDB.migrateToLatestPlugin(family, canonical.id);
           const disabled = await this.pluginDB.deactivateOtherVersions(family, canonical.id);
           if (repointed || disabled) {
             log.info(`Consolidated ${family} to v${canonical.version}: repointed ${repointed} provider(s), disabled ${disabled} older version(s)`);
           }
         }
+        for (const [family, canonical] of datastoresByFamily) {
+          const repointed = await this.datastoreDB.migrateToLatestPlugin(family, canonical.id);
+          const disabled = await this.pluginDB.deactivateOtherVersions(family, canonical.id);
+          if (repointed || disabled) {
+            log.info(`Consolidated ${family} to v${canonical.version}: repointed ${repointed} datastore(s), disabled ${disabled} older version(s)`);
+          }
+        }
       }
       /**
        * Fast path first: a known (provider, plugin) key returns straight from
@@ -10674,7 +10842,8 @@ var init_provider_impl_service = __esm({
         typeof CryptoService === "undefined" ? Object : CryptoService,
         typeof PluginRegistry === "undefined" ? Object : PluginRegistry,
         typeof ProviderDB === "undefined" ? Object : ProviderDB,
-        typeof PluginDB === "undefined" ? Object : PluginDB
+        typeof PluginDB === "undefined" ? Object : PluginDB,
+        typeof DatastoreDB === "undefined" ? Object : DatastoreDB
       ])
     ], ProviderImplService);
   }
@@ -10694,7 +10863,14 @@ function _ts_decorate40(decorators, target, key, desc) {
 function _ts_metadata38(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-var QueueService;
+function errorText(error) {
+  const err = error;
+  if (err?.message) return err.message;
+  const inner = err?.errors?.map((e) => e.code ?? e.message).filter(Boolean);
+  if (inner?.length) return inner.join(", ");
+  return err?.code ?? String(error);
+}
+var QueueUnavailableError, MAX_RETRY_DELAY_MS, QueueService;
 var init_queue_service = __esm({
   "src/services/queue.service.ts"() {
     "use strict";
@@ -10702,27 +10878,50 @@ var init_queue_service = __esm({
     init_src2();
     __name(_ts_decorate40, "_ts_decorate");
     __name(_ts_metadata38, "_ts_metadata");
+    QueueUnavailableError = class extends Error {
+      static {
+        __name(this, "QueueUnavailableError");
+      }
+      constructor(operation) {
+        super(`RabbitMQ unavailable: ${operation}`);
+        this.name = "QueueUnavailableError";
+      }
+    };
+    MAX_RETRY_DELAY_MS = 6e4;
+    __name(errorText, "errorText");
     QueueService = class extends withClassLogger(EventEmitter2) {
       static {
         __name(this, "QueueService");
       }
       isConnected = false;
+      /** Current CONSECUTIVE reconnect attempt count — reset to 0 on success, so /health shows the live outage, not a lifetime tally. */
       reconnectAttempts = 0;
+      /** Start of the current connection outage; null while connected. */
+      disconnectedSince = null;
+      /**
+       * Seam for the fatal-misconfiguration path (406 argument mismatch on
+       * declare). Overridable so tests inject a spy instead of stubbing the
+       * global `process.exit` across concurrently running suites.
+       */
+      fatalExit = /* @__PURE__ */ __name((code) => process.exit(code), "fatalExit");
       config = env.queue.config;
       connection = null;
       channel = null;
       recreatingChannel = false;
       reconnectCallbacks = [];
       activeConsumers = /* @__PURE__ */ new Set();
-      // Static consumers (worker/audit/batch/response) keyed by queue name so a
-      // channel rebuild can re-subscribe them. Dynamic per-user consumers
-      // (notifications) pass replay=false and own their reconciliation.
+      // Legacy/dynamic consumers (notifications, ad-hoc test consumers) keyed by
+      // queue name so a shared-channel rebuild can re-subscribe them. Static
+      // server consumers use registerConsumer/consumerSpecs instead.
       consumerRegistry = /* @__PURE__ */ new Map();
+      /** Spec-registered consumers, keyed by ConsumerSpec.id. */
+      consumerSpecs = /* @__PURE__ */ new Map();
       closing = false;
       replaying = false;
       connecting = null;
       hasConnectedOnce = false;
       reconnectScheduled = false;
+      reconnectTimer = null;
       counters = {
         channelRecreates: 0,
         consumersResubscribed: 0,
@@ -10734,12 +10933,17 @@ var init_queue_service = __esm({
         this.on("channel:lost", () => this.activeConsumers.clear());
       }
       /**
-       * Consumers registered on the live channel. Cleared on channel:lost, so a
+       * Consumers registered on live channels: shared-channel tags (cleared on
+       * channel:lost) plus spec consumers with a live per-consumer channel. A
        * value > 0 means this process is actively consuming — the signal the
        * worker/audit /health probe reports on.
        */
       get activeConsumerCount() {
-        return this.activeConsumers.size;
+        let specCount = 0;
+        for (const entry of this.consumerSpecs.values()) {
+          if (entry.state.channel && entry.state.consumerTag) specCount++;
+        }
+        return this.activeConsumers.size + specCount;
       }
       /**
        * Operational counters for observability (surfaced on the /health endpoint).
@@ -10782,48 +10986,67 @@ var init_queue_service = __esm({
           await this.createChannel();
           this.connection.on("error", (err) => {
             logger2.error(`RabbitMQ connection error: ${err.message}`);
-            this.isConnected = false;
-            this.channel = null;
-            this.connection = null;
+            this.markDisconnected();
             this.emit("channel:lost");
             this.reconnect();
           });
           this.connection.on("close", () => {
             if (this.isConnected) {
               logger2.warn("RabbitMQ connection closed unexpectedly");
-              this.isConnected = false;
-              this.channel = null;
-              this.connection = null;
+              this.markDisconnected();
               this.emit("channel:lost");
               this.reconnect();
             }
           });
           this.isConnected = true;
+          await this.activateAllConsumers();
         } catch (error) {
-          logger2.error(`Failed to connect to RabbitMQ: ${error.message}`);
+          logger2.error(`Failed to connect to RabbitMQ: ${errorText(error)}`);
           throw error;
         }
       }
+      /** Connection-level loss: every channel (shared and per-consumer) died with it. */
+      markDisconnected() {
+        this.isConnected = false;
+        this.channel = null;
+        this.connection = null;
+        if (!this.disconnectedSince) this.disconnectedSince = /* @__PURE__ */ new Date();
+        for (const entry of this.consumerSpecs.values()) {
+          this.teardownConsumerState(entry);
+        }
+      }
+      teardownConsumerState(entry) {
+        if (entry.state.consumerTag) this.activeConsumers.delete(entry.state.consumerTag);
+        entry.state.channel = null;
+        entry.state.consumerTag = null;
+        if (entry.state.retryTimer) {
+          clearTimeout(entry.state.retryTimer);
+          entry.state.retryTimer = null;
+        }
+      }
+      /**
+       * Reconnect indefinitely with capped exponential backoff. The broker being
+       * down for hours must never strand a live process — the previous bounded
+       * give-up (5 attempts, ~2.5 min) left servers permanently disconnected,
+       * which let idle x-expires queues be deleted underneath them.
+       */
       async reconnect() {
         const logger2 = this.mlog(this.reconnect);
         if (this.closing || this.isConnected || this.reconnectScheduled) return;
-        if (this.reconnectAttempts >= this.config.reconnectAttempts) {
-          logger2.error(`Failed to reconnect to RabbitMQ after ${this.reconnectAttempts} attempts`);
-          return;
-        }
         this.reconnectAttempts++;
-        const delay = this.config.reconnectDelayMs * Math.pow(2, this.reconnectAttempts - 1);
+        const delay = Math.min(this.config.reconnectDelayMs * Math.pow(2, this.reconnectAttempts - 1), MAX_RETRY_DELAY_MS);
         logger2.info(`Attempting to reconnect to RabbitMQ in ${delay}ms (attempt ${this.reconnectAttempts})`);
         this.channel = null;
         this.connection = null;
         this.reconnectScheduled = true;
-        setTimeout(async () => {
+        this.reconnectTimer = setTimeout(async () => {
+          this.reconnectTimer = null;
           this.reconnectScheduled = false;
           if (this.closing) return;
           try {
             await this.connect();
           } catch (error) {
-            logger2.error(`Reconnect attempt ${this.reconnectAttempts} failed: ${error.message}`);
+            logger2.error(`Reconnect attempt ${this.reconnectAttempts} failed: ${errorText(error)}`);
             void this.reconnect();
           }
         }, delay);
@@ -10840,6 +11063,18 @@ var init_queue_service = __esm({
       async disconnect() {
         const logger2 = this.mlog(this.disconnect);
         this.closing = true;
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+          this.reconnectScheduled = false;
+        }
+        for (const entry of this.consumerSpecs.values()) {
+          const ch = entry.state.channel;
+          this.teardownConsumerState(entry);
+          if (ch) await ch.close().catch(() => {
+          });
+        }
+        this.consumerSpecs.clear();
         this.consumerRegistry.clear();
         if (!this.isConnected && !this.connection) return;
         await this.closeChannel();
@@ -10851,6 +11086,133 @@ var init_queue_service = __esm({
         this.isConnected = false;
         logger2.info("Disconnected from RabbitMQ");
       }
+      /**
+       * Register a static consumer: stores the spec once, then activates it
+       * (assert → bind → consume on the consumer's own channel). The single
+       * entry point for every server's queue topology — replay after reconnect
+       * reactivates the same specs, so declaration can never drift from
+       * consumption.
+       *
+       * Registration failures propagate (startup contract: a server that cannot
+       * establish its consumers must fail `onInit`, not limp). Failures on later
+       * reactivation retry with bounded backoff instead.
+       */
+      async registerConsumer(spec) {
+        const existing = this.consumerSpecs.get(spec.id);
+        if (existing) {
+          if (existing.spec === spec) return;
+          throw new Error(`Consumer id '${spec.id}' is already registered with a different spec`);
+        }
+        const entry = {
+          spec,
+          state: {
+            channel: null,
+            consumerTag: null,
+            activating: false,
+            retryTimer: null,
+            retryAttempts: 0
+          }
+        };
+        this.consumerSpecs.set(spec.id, entry);
+        if (!this.isConnected) {
+          await this.connect();
+        }
+        await this.activateConsumer(entry, true);
+      }
+      /**
+       * Assert → bind → consume for one spec on its own channel. Single-flight
+       * per id: a channel-error retry racing a full connection replay can never
+       * produce two live consumers for the same spec.
+       */
+      async activateConsumer(entry, throwOnFailure) {
+        const logger2 = this.mlog(this.activateConsumer);
+        const { spec, state } = entry;
+        if (this.closing || state.activating || state.channel && state.consumerTag) return;
+        if (!this.connection) {
+          if (throwOnFailure) throw new QueueUnavailableError(`activate consumer '${spec.id}'`);
+          this.scheduleConsumerRetry(entry);
+          return;
+        }
+        state.activating = true;
+        let channel = null;
+        try {
+          channel = await this.connection.createChannel();
+          await channel.prefetch(env.queue.prefetch);
+          channel.on("error", (err) => {
+            logger2.error(`Consumer '${spec.id}' channel error: ${err.message}`);
+            if (entry.state.channel === channel) {
+              this.teardownConsumerState(entry);
+              if (!this.closing) this.scheduleConsumerRetry(entry);
+            }
+          });
+          try {
+            await channel.assertQueue(spec.queue, spec.assertOptions ?? {
+              durable: true
+            });
+            if (spec.binding) {
+              await channel.assertExchange(spec.binding.exchange, spec.binding.type, {
+                durable: true
+              });
+              for (const pattern of spec.binding.patterns) {
+                await channel.bindQueue(spec.queue, spec.binding.exchange, pattern);
+              }
+            }
+          } catch (declareError) {
+            if (this.isPreconditionMismatch(declareError)) {
+              logger2.error(`FATAL: queue declaration mismatch for consumer '${spec.id}' \u2014 queue=${spec.queue} options=${JSON.stringify(spec.assertOptions ?? {
+                durable: true
+              })} code=${declareError.code} reply=${declareError.message}`);
+              this.fatalExit(1);
+            }
+            throw declareError;
+          }
+          const boundChannel = channel;
+          const result = await boundChannel.consume(spec.queue, this.buildMessageHandler(spec.queue, spec.callback, spec.ignoreErrors ?? false, spec.dropStale ?? false, boundChannel, () => entry.state.channel), spec.consumeOptions ?? {
+            noAck: false
+          });
+          state.channel = channel;
+          state.consumerTag = result.consumerTag;
+          state.retryAttempts = 0;
+          if (state.retryTimer) {
+            clearTimeout(state.retryTimer);
+            state.retryTimer = null;
+          }
+          this.counters.consumersResubscribed++;
+        } catch (error) {
+          if (channel) await channel.close().catch(() => {
+          });
+          state.channel = null;
+          state.consumerTag = null;
+          logger2.error(`Error activating consumer '${spec.id}' on queue ${spec.queue}: ${error.message}`);
+          if (throwOnFailure) throw error;
+          this.scheduleConsumerRetry(entry);
+        } finally {
+          state.activating = false;
+        }
+      }
+      /** Bounded per-consumer backoff — recovery must not depend on a full connection reconnect. */
+      scheduleConsumerRetry(entry) {
+        if (this.closing || entry.state.retryTimer) return;
+        entry.state.retryAttempts++;
+        const delay = Math.min(this.config.reconnectDelayMs * Math.pow(2, entry.state.retryAttempts - 1), MAX_RETRY_DELAY_MS);
+        this.mlog(this.scheduleConsumerRetry).info(`Retrying consumer '${entry.spec.id}' in ${delay}ms (attempt ${entry.state.retryAttempts})`);
+        entry.state.retryTimer = setTimeout(() => {
+          entry.state.retryTimer = null;
+          if (this.closing) return;
+          void this.activateConsumer(entry, false);
+        }, delay);
+      }
+      /** Reactivate every registered spec — the reconnect-time replay path. */
+      async activateAllConsumers() {
+        for (const entry of this.consumerSpecs.values()) {
+          await this.activateConsumer(entry, false);
+        }
+      }
+      /** 406 PRECONDITION_FAILED from a declare — the args-mismatch signature. Everything else is treated as transient. */
+      isPreconditionMismatch(error) {
+        const err = error;
+        return err?.code === 406 && /PRECONDITION[-_]FAILED/i.test(String(err?.message ?? ""));
+      }
       async consume(queueName, callback, ignoreErrors = false, options2 = {
         noAck: false
       }, replay = true, dropStale = false) {
@@ -10860,57 +11222,7 @@ var init_queue_service = __esm({
         }
         try {
           const boundChannel = this.channel;
-          const result = await boundChannel.consume(queueName, async (message) => {
-            if (!message) {
-              logger2.warn(`Received null message from queue: ${queueName}`);
-              return;
-            }
-            let content;
-            try {
-              content = JSON.parse(message.content.toString());
-            } catch {
-              logger2.error(`Dropping unparseable message from ${queueName} (invalid JSON, ${message.content.length} bytes)`);
-              this.counters.messagesDropped++;
-              this.safeNack(boundChannel, message, false);
-              return;
-            }
-            if (!content || typeof content !== "object") {
-              logger2.error(`Dropping non-object message from ${queueName}`);
-              this.counters.messagesDropped++;
-              this.safeNack(boundChannel, message, false);
-              return;
-            }
-            const { requestId } = content;
-            if (dropStale && this.isOverAge(content)) {
-              logger2.warn(`Dropping over-age message ${requestId ?? "<no-id>"} from ${queueName} (older than ${env.queue.maxMessageAgeMs}ms)`);
-              this.counters.messagesDropped++;
-              this.safeNack(boundChannel, message, false);
-              return;
-            }
-            try {
-              await callback(requestId, content, message);
-              this.safeAck(boundChannel, message);
-            } catch (error) {
-              const err = error;
-              logger2.error(`Error processing message from queue: ${queueName}: ${err?.message}`);
-              const pgCode = err?.code ?? err?.error?.code ?? err?.cause?.code;
-              const isUnrecoverable = typeof pgCode === "string" && /^(22|23)/.test(pgCode);
-              if (ignoreErrors || isUnrecoverable) {
-                if (isUnrecoverable) {
-                  logger2.warn(`Dropping message from ${queueName} \u2014 unrecoverable data error (code ${pgCode})`);
-                  this.counters.messagesDropped++;
-                }
-                this.safeAck(boundChannel, message);
-              } else if (message.fields.redelivered) {
-                this.counters.messagesDropped++;
-                this.safeNack(boundChannel, message, false);
-                logger2.warn("Rejected problematic message after redelivery");
-              } else {
-                this.safeNack(boundChannel, message, true);
-                logger2.info("Message re-queued for retry");
-              }
-            }
-          }, options2);
+          const result = await boundChannel.consume(queueName, this.buildMessageHandler(queueName, callback, ignoreErrors, dropStale, boundChannel, () => this.channel), options2);
           this.activeConsumers.add(result.consumerTag);
           if (replay && !this.replaying) {
             this.consumerRegistry.set(queueName, {
@@ -10927,6 +11239,66 @@ var init_queue_service = __esm({
           throw error;
         }
       }
+      /**
+       * The shared delivery pipeline: parse guards, over-age drop, ack/nack
+       * policy. `currentChannel` identifies the channel the owning consumer
+       * currently considers live, so acks for deliveries from a rotated channel
+       * are suppressed (a stale-tag ack is a second channel-killing 406).
+       */
+      buildMessageHandler(queueName, callback, ignoreErrors, dropStale, boundChannel, currentChannel) {
+        const logger2 = this.mlog(this.consume);
+        return async (message) => {
+          if (!message) {
+            logger2.warn(`Received null message from queue: ${queueName}`);
+            return;
+          }
+          let content;
+          try {
+            content = JSON.parse(message.content.toString());
+          } catch {
+            logger2.error(`Dropping unparseable message from ${queueName} (invalid JSON, ${message.content.length} bytes)`);
+            this.counters.messagesDropped++;
+            this.safeNack(boundChannel, message, false, currentChannel);
+            return;
+          }
+          if (!content || typeof content !== "object") {
+            logger2.error(`Dropping non-object message from ${queueName}`);
+            this.counters.messagesDropped++;
+            this.safeNack(boundChannel, message, false, currentChannel);
+            return;
+          }
+          const { requestId } = content;
+          if (dropStale && this.isOverAge(content)) {
+            logger2.warn(`Dropping over-age message ${requestId ?? "<no-id>"} from ${queueName} (older than ${env.queue.maxMessageAgeMs}ms)`);
+            this.counters.messagesDropped++;
+            this.safeNack(boundChannel, message, false, currentChannel);
+            return;
+          }
+          try {
+            await callback(requestId, content, message);
+            this.safeAck(boundChannel, message, currentChannel);
+          } catch (error) {
+            const err = error;
+            logger2.error(`Error processing message from queue: ${queueName}: ${err?.message}`);
+            const pgCode = err?.code ?? err?.error?.code ?? err?.cause?.code;
+            const isUnrecoverable = typeof pgCode === "string" && /^(22|23)/.test(pgCode);
+            if (ignoreErrors || isUnrecoverable) {
+              if (isUnrecoverable) {
+                logger2.warn(`Dropping message from ${queueName} \u2014 unrecoverable data error (code ${pgCode})`);
+                this.counters.messagesDropped++;
+              }
+              this.safeAck(boundChannel, message, currentChannel);
+            } else if (message.fields.redelivered) {
+              this.counters.messagesDropped++;
+              this.safeNack(boundChannel, message, false, currentChannel);
+              logger2.warn("Rejected problematic message after redelivery");
+            } else {
+              this.safeNack(boundChannel, message, true, currentChannel);
+              logger2.info("Message re-queued for retry");
+            }
+          }
+        };
+      }
       /**
        * Send a message to a queue
        * @param {string} queue - Queue name
@@ -10935,9 +11307,7 @@ var init_queue_service = __esm({
        */
       async sendToQueue(queue, message, options2 = {}) {
         const logger2 = this.mlog(this.sendToQueue);
-        if (!this.isConnected) {
-          await this.connect();
-        }
+        const channel = await this.publishChannel("sendToQueue");
         try {
           const buffer = Buffer.from(JSON.stringify(message));
           const defaultOptions = {
@@ -10948,7 +11318,7 @@ var init_queue_service = __esm({
             ...defaultOptions,
             ...options2
           };
-          const sent = this.channel.sendToQueue(queue, buffer, messageOptions);
+          const sent = channel.sendToQueue(queue, buffer, messageOptions);
           if (sent) {
             logger2.debug(`Message sent to queue ${queue} with ID: ${message.id}`);
           } else {
@@ -10969,9 +11339,7 @@ var init_queue_service = __esm({
        */
       async sendToExchange(exchange, routingKey, message, options2 = {}) {
         const logger2 = this.mlog(this.sendToExchange);
-        if (!this.isConnected) {
-          await this.connect();
-        }
+        const channel = await this.publishChannel(`publish to ${exchange}`);
         try {
           const buffer = Buffer.from(JSON.stringify(message));
           const defaultOptions = {
@@ -10982,7 +11350,7 @@ var init_queue_service = __esm({
             ...defaultOptions,
             ...options2
           };
-          const sent = this.channel.publish(exchange, routingKey, buffer, messageOptions);
+          const sent = channel.publish(exchange, routingKey, buffer, messageOptions);
           if (!sent) {
             logger2.warn(`Failed to publish message to exchange ${exchange}, channel back-pressured`);
           }
@@ -10992,6 +11360,27 @@ var init_queue_service = __esm({
           throw error;
         }
       }
+      /**
+       * The shared channel used for publishes and legacy/dynamic operations.
+       * Attempts a (single-flight) lazy connect when disconnected; if the broker
+       * is still unavailable, fails fast with a typed error rather than
+       * null-crashing — reconnection continues in the background.
+       */
+      async publishChannel(operation) {
+        if (!this.isConnected) {
+          try {
+            await this.connect();
+          } catch {
+            void this.reconnect();
+            throw new QueueUnavailableError(operation);
+          }
+        }
+        const channel = this.channel;
+        if (!channel) {
+          throw new QueueUnavailableError(operation);
+        }
+        return channel;
+      }
       /**
        * Stop consuming messages
        */
@@ -11078,8 +11467,8 @@ var init_queue_service = __esm({
         if (Number.isNaN(published)) return false;
         return Date.now() - published > maxAge;
       }
-      safeAck(channel, message) {
-        if (channel !== this.channel) {
+      safeAck(channel, message, currentChannel) {
+        if (channel !== currentChannel()) {
           this.counters.staleDeliveriesSuppressed++;
           return;
         }
@@ -11089,8 +11478,8 @@ var init_queue_service = __esm({
           this.mlog(this.safeAck).warn(`Ack on closed channel ignored: ${error.message}`);
         }
       }
-      safeNack(channel, message, requeue) {
-        if (channel !== this.channel) {
+      safeNack(channel, message, requeue, currentChannel) {
+        if (channel !== currentChannel()) {
           this.counters.staleDeliveriesSuppressed++;
           return;
         }
@@ -11101,10 +11490,10 @@ var init_queue_service = __esm({
         }
       }
       /**
-       * Re-subscribe every registered static consumer onto the current channel.
+       * Re-subscribe every registered legacy consumer onto the shared channel.
        * Runs inside createChannel() so it covers BOTH a connection-level reconnect
-       * and a channel-only recreate (the 406 consumer_timeout path). Fault-isolated:
-       * one queue failing to re-subscribe never aborts the others.
+       * and a channel-only recreate (the 406 consumer_timeout path). Spec-based
+       * consumers reactivate through activateAllConsumers/their own retry instead.
        */
       async replayConsumers() {
         if (this.closing || this.consumerRegistry.size === 0) return;
@@ -11155,6 +11544,7 @@ var init_queue_service = __esm({
         });
         this.isConnected = true;
         this.reconnectAttempts = 0;
+        this.disconnectedSince = null;
         const reconnected = this.hasConnectedOnce;
         this.hasConnectedOnce = true;
         await this.replayConsumers();
@@ -11399,7 +11789,19 @@ var init_plugin_lifecycle_service = __esm({
         for (const pluginRow of enabled) {
           const family = pluginRow.family.toUpperCase();
           enabledFamilies.add(family);
-          const current = this.loadedState.get(family);
+          let current = this.loadedState.get(family);
+          if (!current && this.pluginRegistry.has(pluginRow.id)) {
+            current = {
+              pluginId: pluginRow.id,
+              family,
+              version: pluginRow.version,
+              sha256: this.pluginRegistry.loadedSha(pluginRow.id) ?? "",
+              packageName: pluginRow.name,
+              packageDir: "",
+              loadedAt: Date.now()
+            };
+            this.loadedState.set(family, current);
+          }
           if (current?.sha256 === pluginRow.sha256) continue;
           try {
             if (current) {
@@ -13007,7 +13409,28 @@ var init_response_service = __esm({
       async startLLMResponseConsumer(serverId) {
         this.serverId = serverId || this.serverId;
         const queueName = `${this.responseQueue}.${this.serverId}`;
-        await this.queueService.consume(queueName, async (id, content) => this.processWireChunk(id, content), true);
+        await this.queueService.registerConsumer({
+          id: "api.llm_responses",
+          queue: queueName,
+          // x-expires reclaims the per-instance queue when this API instance is
+          // gone for good; registerConsumer re-asserts it on every reactivation,
+          // so an expiry during an outage can no longer strand the consumer.
+          assertOptions: {
+            durable: true,
+            arguments: {
+              "x-expires": env.queue.queueExpiration
+            }
+          },
+          binding: {
+            exchange: env.queue.responseExchange,
+            type: "direct",
+            patterns: [
+              this.serverId
+            ]
+          },
+          callback: /* @__PURE__ */ __name(async (id, content) => this.processWireChunk(id, content), "callback"),
+          ignoreErrors: true
+        });
       }
       async processWireChunk(_id, wire) {
         const logger2 = this.mlog(this.processWireChunk);
@@ -13439,13 +13862,14 @@ var init_init_service = __esm({
           await this.pluginWatcherService.startWatching();
         }
       }
+      // Queue topology lives with each queue's consumer (QueueService.registerConsumer
+      // asserts immediately before consuming), so this only declares the exchanges the
+      // API publishes to. Consumer-owned queue declarations were removed with the move
+      // to registerConsumer — a second declaration site is how declare/consume drift.
       async setupQueues(serverId) {
         logger_default.debug(`setupQueues called with ${serverId}`);
         this.serverId = serverId || this.serverId;
         await this._setupGlobalExchanges();
-        await this._setupRequestQueues();
-        await this._setupResponseQueues();
-        await this._setupNotificationQueues();
       }
       async _setupGlobalExchanges() {
         await this.queueService.assertExchange(env.queue.requestExchange, "fanout");
@@ -13455,31 +13879,6 @@ var init_init_service = __esm({
         await this.queueService.assertExchange(env.queue.adminResponseExchange, "direct");
         await this.queueService.assertExchange(env.queue.directExchange, "direct");
       }
-      async _setupRequestQueues() {
-        await this.queueService.assertQueue(env.queue.requestQueue, {
-          durable: true
-        }, env.queue.requestExchange);
-        await this.queueService.assertQueue(env.queue.auditRequestQueue, {
-          durable: true
-        }, env.queue.requestExchange);
-      }
-      async _setupResponseQueues() {
-        const responseQueueName = `${env.queue.responseQueue}.${this.serverId}`;
-        await this.queueService.assertQueue(responseQueueName, {
-          durable: true,
-          arguments: {
-            "x-expires": env.queue.queueExpiration
-          }
-        }, env.queue.responseExchange, this.serverId);
-        await this.queueService.assertQueue(env.queue.auditResponseQueue, {
-          durable: true
-        }, env.queue.responseExchange, env.queue.auditRoutingKey);
-      }
-      async _setupNotificationQueues() {
-        await this.queueService.assertQueue(env.queue.auditNotificationQueue, {
-          durable: true
-        }, env.queue.notificationExchange, "#");
-      }
     };
     InitService = _ts_decorate49([
       injectable49(),
@@ -14310,10 +14709,11 @@ var init_system_model_binding_cache = __esm({
        * legitimately mint, including the platform-org sentinel, which is why it asserts UUID
        * *shape* rather than RFC-4122 conformance (see {@link isKeySafeUuid}).
        */
-      key(orgId, selector) {
+      key(orgId, selector, profileId) {
         this.assertOrgId(orgId);
         this.assertSelector(selector);
-        return `${this.prefix}${orgId}:selector:${selector}`;
+        this.assertProfileId(profileId);
+        return `${this.prefix}${orgId}:selector:${selector}:profile:${profileId ?? "none"}`;
       }
       assertOrgId(orgId) {
         if (!isKeySafeUuid(orgId)) {
@@ -14325,16 +14725,26 @@ var init_system_model_binding_cache = __esm({
           throw HoloError.badRequest("Invalid system-model selector.");
         }
       }
-      async get(orgId, selector) {
-        return this.redis.get(this.key(orgId, selector));
+      /**
+       * The profile segment admits exactly two shapes: a UUID (the token's mint-validated
+       * claim, already shape-checked by the verifier — re-asserted here so no other caller
+       * can widen a glob through this segment) or `null`, rendered as the literal `none`.
+       */
+      assertProfileId(profileId) {
+        if (profileId !== null && !isKeySafeUuid(profileId)) {
+          throw HoloError.badRequest("Invalid system-model profile.");
+        }
+      }
+      async get(orgId, selector, profileId) {
+        return this.redis.get(this.key(orgId, selector, profileId));
       }
       /**
        * Admit a binding to the cache. The parameter type is the admission predicate: only a
        * row already proven servable can be passed, so admission is exactly servability
        * rather than an approximation of it re-derived here.
        */
-      async set(orgId, selector, row) {
-        await this.redis.set(this.key(orgId, selector), row, Math.ceil(env.onBehalf.maxTtlMs / 1e3));
+      async set(orgId, selector, profileId, row) {
+        await this.redis.set(this.key(orgId, selector, profileId), row, Math.ceil(env.onBehalf.maxTtlMs / 1e3));
       }
       /**
        * Evict every cached binding for an org (`binding:org:{org}:*`). Returns the count removed.
@@ -14360,7 +14770,7 @@ var init_system_model_binding_cache = __esm({
        */
       async evictSelectorAcrossOrgs(selector) {
         this.assertSelector(selector);
-        return this.scanAndDelete(`${this.prefix}*:selector:${selector}`);
+        return this.scanAndDelete(`${this.prefix}*:selector:${selector}:profile:*`);
       }
       /** Delete every key matching `pattern`. Returns the count removed. */
       async scanAndDelete(pattern) {
@@ -14453,12 +14863,12 @@ var init_holo_request_service = __esm({
       async resolveSystemModel(auth, request) {
         const logger2 = this.mlog(this.resolveSystemModel);
         const orgId = auth.organizationId;
-        const { selector } = auth.onBehalf;
+        const { selector, profileId } = auth.onBehalf;
         if (!selector) {
           throw HoloError.badRequest("A system-model alias is required.");
         }
-        const cached = await this.bindingCache.get(orgId, selector);
-        const row = cached ?? await this.effectiveModelDB.getEffectiveModel(orgId, selector);
+        const cached = await this.bindingCache.get(orgId, selector, profileId);
+        const row = cached ?? await this.effectiveModelDB.getEffectiveModel(orgId, selector, profileId);
         if (!row) {
           this.logSystemModelDeny(logger2, "unknown_selector", auth, selector);
           throw HoloError.notFound("Model");
@@ -14468,7 +14878,7 @@ var init_holo_request_service = __esm({
           throw HoloError.conflict("The configured model binding is currently unservable.", HoloErrorCode.UNSERVABLE_BINDING);
         }
         if (!cached) {
-          await this.bindingCache.set(orgId, selector, row);
+          await this.bindingCache.set(orgId, selector, profileId, row);
         }
         const provider = await this.providerDB.getById(row.provider_id);
         if (!provider) {
@@ -14977,7 +15387,8 @@ function makeOnBehalfPreHandler(verifier) {
         applications: [],
         clientIdentifier: verified.sub,
         onBehalf: {
-          selector: verified.selector
+          selector: verified.selector,
+          profileId: verified.profileId
         }
       };
       req.auth = auth;
@@ -16918,16 +17329,6 @@ function withAdmin(Base) {
       logger_default.debug(`${this.id} is Admin Aware`);
       const commandQueue = `${env.queue.adminCommandQueue}_${this.id}`;
       const exchange = env.queue.adminExchange;
-      await this.queueService.assertExchange(exchange, "topic");
-      await this.queueService.assertQueue(commandQueue, {
-        exclusive: false,
-        durable: true,
-        autoDelete: true
-      }, exchange, "model.#");
-      await this.queueService.bindQueue(commandQueue, exchange, "worker.#");
-      await this.queueService.bindQueue(commandQueue, exchange, "plugin.#");
-      await this.queueService.bindQueue(commandQueue, exchange, "provider.#");
-      await this.queueService.bindQueue(commandQueue, exchange, "datastore.#");
       this.pluginLifecycleService.setServerId(this.id);
       this.adminHandlers.set("plugin.enabled", async (_serverId, payload) => {
         await this.pluginLifecycleService.handleRemoteEnable(payload);
@@ -16968,29 +17369,49 @@ function withAdmin(Base) {
       if (env.api.pluginReconcileIntervalMs > 0) {
         this.pluginLifecycleService.startPeriodicReconciliation(env.api.pluginReconcileIntervalMs);
       }
-      await this.queueService.consume(commandQueue, async (messageId, content, _message) => {
-        const { action, serverId, timestamp, ...payload } = content;
-        logger_default.info(`Worker (${this.id}) received admin command: ${action}, messageId: ${messageId}`);
-        const handler = this.adminHandlers.get(action);
-        let response = {};
-        if (!handler) {
-          logger_default.warn(`No handler registered for admin command: ${action}`);
-          response = {
-            success: false,
-            message: `No handler registered for admin command: ${action}`
-          };
-        } else {
-          try {
-            response = await handler(this.id, payload);
-          } catch (error) {
-            logger_default.error(`Error handling admin command: ${action} - ${error.message}`);
+      await this.queueService.registerConsumer({
+        id: `admin.commands.${this.id}`,
+        queue: commandQueue,
+        assertOptions: {
+          exclusive: false,
+          durable: true,
+          autoDelete: true
+        },
+        binding: {
+          exchange,
+          type: "topic",
+          patterns: [
+            "model.#",
+            "worker.#",
+            "plugin.#",
+            "provider.#",
+            "datastore.#"
+          ]
+        },
+        callback: /* @__PURE__ */ __name(async (messageId, content, _message) => {
+          const { action, serverId, timestamp, ...payload } = content;
+          logger_default.info(`Worker (${this.id}) received admin command: ${action}, messageId: ${messageId}`);
+          const handler = this.adminHandlers.get(action);
+          let response = {};
+          if (!handler) {
+            logger_default.warn(`No handler registered for admin command: ${action}`);
             response = {
               success: false,
-              message: error.message
+              message: `No handler registered for admin command: ${action}`
             };
+          } else {
+            try {
+              response = await handler(this.id, payload);
+            } catch (error) {
+              logger_default.error(`Error handling admin command: ${action} - ${error.message}`);
+              response = {
+                success: false,
+                message: error.message
+              };
+            }
           }
-        }
-        await this.adminService.sendAdminResponse(this.id, serverId, messageId, response);
+          await this.adminService.sendAdminResponse(this.id, serverId, messageId, response);
+        }, "callback")
       });
     }
     async onShutdown() {
@@ -17124,6 +17545,10 @@ function withHealth(Base) {
           status: healthy ? "ok" : "unhealthy",
           connected,
           consumers,
+          // Current consecutive attempt count (0 while connected) +
+          // outage start — makes a stuck-retrying instance visible.
+          reconnectAttempts: queueService?.reconnectAttempts ?? 0,
+          disconnectedSince: queueService?.disconnectedSince?.toISOString() ?? null,
           metrics: queueService?.metrics,
           uptime: process.uptime(),
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -21133,116 +21558,129 @@ var init_worker_server = __esm({
         this.adminHandlers.set("worker.restart", this.adminService.restartWorker);
         const requestQueue = env.queue.requestQueue;
         const logger2 = this.mlog("workerConsume");
-        await this.queueService.consume(requestQueue, async (requestId, workerRequest, message) => {
-          this.stats.totalRequests++;
-          const reqLogger = workerRequest.capability ? logger2.child(capabilityToMetadata(workerRequest.capability)) : logger2;
-          const redelivered = message?.fields?.redelivered ?? false;
-          reqLogger.info(`Worker ${this.id} handling request: ${requestId} provider: ${workerRequest.provider.name} from server ${workerRequest.sourceId} and queue ${requestQueue}${redelivered ? " (redelivered)" : ""}...`);
-          const ai = await this.providerPluginService.getProviderImplById(workerRequest.provider.id, workerRequest.protocol?.plugin_id);
-          const plugin = ai.plugin;
-          logger2.info(`resolved ai provider: ${ai.name}`);
-          const { sourceId, guardResult } = workerRequest;
-          const envelope = await ai.auditor.createWorkerResponseEnvelope(workerRequest, this.id);
-          try {
-            if (guardResult && !guardResult.passed) {
-              logger2.info("Guards failed. Sending back guard errors.");
-              const wire = await plugin.createWireAdapter({
-                requestId,
-                isStreaming: false,
-                protocol: ai.plugin.defaultProtocol
-              });
-              const errorMessage = guardResult.errors?.join("\n\n") || "Policy violation";
-              const evt = {
-                type: "error",
-                requestId,
-                seq: 0,
-                ts: Date.now(),
-                status: 400,
-                metrics: {
-                  inputTokens: 0,
-                  outputTokens: 0,
-                  timeToFirstToken: 0,
-                  totalProcessingTime: 0,
-                  totalTokens: 0
-                },
-                text: errorMessage,
-                error: ai.responseFactory.createError(errorMessage)
-              };
-              for (const wireChunk of await wire.fromProviderEvent(evt)) {
-                logger2.debug(`Guard failed response: ${JSON.stringify(wireChunk)}`);
-                await this.responseService.sendResponseChunk(sourceId, requestId, wireChunk);
-              }
-              await this.responseService.sendToAudit({
-                ...workerRequest,
-                providerEvent: evt,
-                workerId: this.id
-              });
-              await this.notificationService.publish(NotificationEventFactory.fromProviderEvent(envelope, evt));
-            } else {
-              const apiCredentialId = workerRequest.provider.api_credential_id;
-              if (apiCredentialId) {
-                this.apiCredentialDB.updateLastUsed(apiCredentialId).catch((err) => reqLogger.error(`Failed to update api_credential last_used_at: ${err.message}`));
-              }
-              const wirePlugin = this.resolveWirePlugin(workerRequest, plugin);
-              if (wirePlugin) {
-                logger2.info(`Translating inbound: ${wirePlugin.family}/${workerRequest.wireProtocolName} \u2192 holo \u2192 ${plugin.family}/${workerRequest.protocol.name}`);
-                await this.applyInboundTranslation(workerRequest, wirePlugin);
-              }
-              const wire = await this.createWireAdapter(requestId, workerRequest, wirePlugin, plugin);
-              const rawEvents = await ai.processWorkerRequest(workerRequest, {
-                requestTimeoutMs: env.worker.requestTimeoutMs,
-                idleTimeoutMs: env.worker.streamIdleTimeoutMs
-              });
-              const events = wirePlugin ? translateProviderEvents(rawEvents, plugin.translator, wirePlugin.translator) : rawEvents;
-              await processProviderEvents(events, wire, workerRequest, envelope, {
-                publishChunk: this.responseService.sendResponseChunk.bind(this),
-                publishFinal: /* @__PURE__ */ __name(async (final) => {
-                  await this.responseService.sendToAudit(final);
-                  await this.notificationService.publish(NotificationEventFactory.fromProviderEvent(envelope, final.providerEvent));
-                }, "publishFinal")
-              });
-            }
-          } catch (error) {
-            logger2.error(`Error handling request (${requestId}): ${error.message}`);
+        await this.queueService.registerConsumer({
+          id: "worker.llm_requests",
+          queue: requestQueue,
+          assertOptions: {
+            durable: true
+          },
+          binding: {
+            exchange: env.queue.requestExchange,
+            type: "fanout",
+            patterns: [
+              ""
+            ]
+          },
+          callback: /* @__PURE__ */ __name(async (requestId, workerRequest, message) => {
+            this.stats.totalRequests++;
+            const reqLogger = workerRequest.capability ? logger2.child(capabilityToMetadata(workerRequest.capability)) : logger2;
+            const redelivered = message?.fields?.redelivered ?? false;
+            reqLogger.info(`Worker ${this.id} handling request: ${requestId} provider: ${workerRequest.provider.name} from server ${workerRequest.sourceId} and queue ${requestQueue}${redelivered ? " (redelivered)" : ""}...`);
+            const ai = await this.providerPluginService.getProviderImplById(workerRequest.provider.id, workerRequest.protocol?.plugin_id);
+            const plugin = ai.plugin;
+            logger2.info(`resolved ai provider: ${ai.name}`);
+            const { sourceId, guardResult } = workerRequest;
+            const envelope = await ai.auditor.createWorkerResponseEnvelope(workerRequest, this.id);
             try {
-              const errorMessage = error.message;
-              const errorEvent = {
-                type: "error",
-                requestId,
-                seq: 0,
-                ts: Date.now(),
-                status: 500,
-                error: ai.responseFactory.createError(errorMessage),
-                text: errorMessage,
-                metrics: {
-                  inputTokens: 0,
-                  outputTokens: 0,
-                  timeToFirstToken: 0,
-                  totalProcessingTime: 0,
-                  totalTokens: 0
+              if (guardResult && !guardResult.passed) {
+                logger2.info("Guards failed. Sending back guard errors.");
+                const wire = await plugin.createWireAdapter({
+                  requestId,
+                  isStreaming: false,
+                  protocol: ai.plugin.defaultProtocol
+                });
+                const errorMessage = guardResult.errors?.join("\n\n") || "Policy violation";
+                const evt = {
+                  type: "error",
+                  requestId,
+                  seq: 0,
+                  ts: Date.now(),
+                  status: 400,
+                  metrics: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    timeToFirstToken: 0,
+                    totalProcessingTime: 0,
+                    totalTokens: 0
+                  },
+                  text: errorMessage,
+                  error: ai.responseFactory.createError(errorMessage)
+                };
+                for (const wireChunk of await wire.fromProviderEvent(evt)) {
+                  logger2.debug(`Guard failed response: ${JSON.stringify(wireChunk)}`);
+                  await this.responseService.sendResponseChunk(sourceId, requestId, wireChunk);
                 }
-              };
-              const wire = workerRequest.isHoloNative ? new HoloWireAdapter(requestId, false, workerRequest.payload?.model) : await plugin.createWireAdapter({
-                requestId,
-                isStreaming: false,
-                protocol: workerRequest.protocol?.name ?? ai.plugin.defaultProtocol
-              });
-              for (const wireChunk of await wire.fromProviderEvent(errorEvent)) {
-                await this.responseService.sendResponseChunk(sourceId, requestId, wireChunk);
+                await this.responseService.sendToAudit({
+                  ...workerRequest,
+                  providerEvent: evt,
+                  workerId: this.id
+                });
+                await this.notificationService.publish(NotificationEventFactory.fromProviderEvent(envelope, evt));
+              } else {
+                const apiCredentialId = workerRequest.provider.api_credential_id;
+                if (apiCredentialId) {
+                  this.apiCredentialDB.updateLastUsed(apiCredentialId).catch((err) => reqLogger.error(`Failed to update api_credential last_used_at: ${err.message}`));
+                }
+                const wirePlugin = this.resolveWirePlugin(workerRequest, plugin);
+                if (wirePlugin) {
+                  logger2.info(`Translating inbound: ${wirePlugin.family}/${workerRequest.wireProtocolName} \u2192 holo \u2192 ${plugin.family}/${workerRequest.protocol.name}`);
+                  await this.applyInboundTranslation(workerRequest, wirePlugin);
+                }
+                const wire = await this.createWireAdapter(requestId, workerRequest, wirePlugin, plugin);
+                const rawEvents = await ai.processWorkerRequest(workerRequest, {
+                  requestTimeoutMs: env.worker.requestTimeoutMs,
+                  idleTimeoutMs: env.worker.streamIdleTimeoutMs
+                });
+                const events = wirePlugin ? translateProviderEvents(rawEvents, plugin.translator, wirePlugin.translator) : rawEvents;
+                await processProviderEvents(events, wire, workerRequest, envelope, {
+                  publishChunk: this.responseService.sendResponseChunk.bind(this),
+                  publishFinal: /* @__PURE__ */ __name(async (final) => {
+                    await this.responseService.sendToAudit(final);
+                    await this.notificationService.publish(NotificationEventFactory.fromProviderEvent(envelope, final.providerEvent));
+                  }, "publishFinal")
+                });
               }
-              await this.responseService.sendToAudit({
-                ...workerRequest,
-                providerEvent: errorEvent,
-                workerId: this.id
-              });
-            } catch (auditError) {
-              logger2.error(`Failed to send error response for (${requestId}): ${auditError.message}`);
+            } catch (error) {
+              logger2.error(`Error handling request (${requestId}): ${error.message}`);
+              try {
+                const errorMessage = error.message;
+                const errorEvent = {
+                  type: "error",
+                  requestId,
+                  seq: 0,
+                  ts: Date.now(),
+                  status: 500,
+                  error: ai.responseFactory.createError(errorMessage),
+                  text: errorMessage,
+                  metrics: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    timeToFirstToken: 0,
+                    totalProcessingTime: 0,
+                    totalTokens: 0
+                  }
+                };
+                const wire = workerRequest.isHoloNative ? new HoloWireAdapter(requestId, false, workerRequest.payload?.model) : await plugin.createWireAdapter({
+                  requestId,
+                  isStreaming: false,
+                  protocol: workerRequest.protocol?.name ?? ai.plugin.defaultProtocol
+                });
+                for (const wireChunk of await wire.fromProviderEvent(errorEvent)) {
+                  await this.responseService.sendResponseChunk(sourceId, requestId, wireChunk);
+                }
+                await this.responseService.sendToAudit({
+                  ...workerRequest,
+                  providerEvent: errorEvent,
+                  workerId: this.id
+                });
+              } catch (auditError) {
+                logger2.error(`Failed to send error response for (${requestId}): ${auditError.message}`);
+              }
+              await this.onError(error);
             }
-            await this.onError(error);
-          }
-        }, false, {
-          noAck: false
-        }, true, true);
+          }, "callback"),
+          dropStale: true
+        });
       }
       async onShutdown() {
         await super.onShutdown();
@@ -21381,14 +21819,56 @@ var init_audit_server = __esm({
         this.pluginLifecycleService.setPluginsDir(env.audit.pluginsDir);
         await this.pluginRegistry.loadAllActive();
         await this.providerImplService.warmAll();
-        await this.queueService.consume(env.queue.auditNotificationQueue, async (_id, content) => {
-          await this.auditService.logNotification(content);
+        await this.queueService.registerConsumer({
+          id: "audit.notifications_audit",
+          queue: env.queue.auditNotificationQueue,
+          assertOptions: {
+            durable: true
+          },
+          binding: {
+            exchange: env.queue.notificationExchange,
+            type: "topic",
+            patterns: [
+              "#"
+            ]
+          },
+          callback: /* @__PURE__ */ __name(async (_id, content) => {
+            await this.auditService.logNotification(content);
+          }, "callback")
         });
-        await this.queueService.consume(env.queue.auditRequestQueue, async (_id, content) => {
-          await this.auditService.logRequest(content);
+        await this.queueService.registerConsumer({
+          id: "audit.llm_requests_audit",
+          queue: env.queue.auditRequestQueue,
+          assertOptions: {
+            durable: true
+          },
+          binding: {
+            exchange: env.queue.requestExchange,
+            type: "fanout",
+            patterns: [
+              ""
+            ]
+          },
+          callback: /* @__PURE__ */ __name(async (_id, content) => {
+            await this.auditService.logRequest(content);
+          }, "callback")
         });
-        await this.queueService.consume(env.queue.auditResponseQueue, async (_id, content) => {
-          await this.auditService.logResponse(content);
+        await this.queueService.registerConsumer({
+          id: "audit.llm_responses_audit",
+          queue: env.queue.auditResponseQueue,
+          assertOptions: {
+            durable: true
+          },
+          binding: {
+            exchange: env.queue.responseExchange,
+            type: "direct",
+            patterns: [
+              env.queue.auditRoutingKey
+            ]
+          },
+          callback: /* @__PURE__ */ __name(async (_id, content) => {
+            await this.auditService.logResponse(content);
+          }, "callback")
         });
       }
       async onShutdown() {