omnius 1.0.843 → 1.0.845

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 37064391 bytes
-sha256: 1c020e46538ba5a79d1d2b7586f2f8922b0f4bab36354bd878b49939461d8d9b
+size: 37075222 bytes
+sha256: a9cbdc655c3f3be3c254f09caaa9149c8677cb9858cb12940142e24dc9eb514e

package/dist/library.js

@@ -349062,7 +349062,23 @@ function routeKey(route) {
   return `${new URL(route.baseUrl).origin}\0${route.model}`;
 }
 function errorStatus(error) {
-  return object4(error) && typeof error.status === "number" ? error.status : void 0;
+  for (const value of errorChain(error)) {
+    if (object4(value) && typeof value.status === "number" && Number.isInteger(value.status) && value.status >= 100 && value.status <= 599)
+      return value.status;
+  }
+  return void 0;
+}
+function errorChain(error) {
+  const chain = [];
+  for (let current = error; current && chain.length < 8 && !chain.includes(current); current = object4(current) ? current.cause : void 0)
+    chain.push(current);
+  return chain;
+}
+function safeFailure(error) {
+  const status = errorStatus(error);
+  const chain = errorChain(error);
+  const category = status === 429 ? "rate_limit" : status === 401 || status === 403 ? "authentication" : status !== void 0 && status >= 400 && status < 500 ? "request_rejected" : status !== void 0 && status >= 500 ? "upstream_unavailable" : chain.some((value) => value instanceof AttemptTimeout || object4(value) && (value.name === "TimeoutError" || value.name === "AbortError" || value.code === "ETIMEDOUT")) ? "timeout" : chain.some((value) => value instanceof EmptyInferenceResponse) ? "empty_response" : chain.some((value) => value instanceof SyntaxError) ? "invalid_response" : "transport";
+  return { category, ...status === void 0 ? {} : { status } };
 }
 function transportFailure(error) {
   if (parseProviderContextOverflow(error))
@@ -349159,9 +349175,12 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     if (!this.eligible(request))
       return local(request);
     this.fence(request);
+    let localSelected = false;
     try {
       if (this.localAdmissionTimeoutMs(request) === 0)
         throw new AttemptTimeout();
+      this.lifecycle(request, "selected");
+      localSelected = true;
       const result = await this.attempt(request, this.policy.localTimeoutMs, async (bounded3) => {
         if (bounded3.localAdmissionFailure !== void 0)
           throw bounded3.localAdmissionFailure;
@@ -349170,16 +349189,19 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
       if (!usableResult(result))
         throw new EmptyInferenceResponse();
       localCooldowns.delete(routeKey(this.primary));
+      this.lifecycle(request, "succeeded");
       return result;
     } catch (error) {
       this.fence(request);
+      if (localSelected)
+        this.lifecycle(request, "failed", void 0, error);
       if (!transportFailure(error))
         throw error;
       this.localCooldown();
     }
     await this.approveRemoteFallback(request);
     const deadline = this.now() + this.policy.totalTimeoutMs;
-    for await (const candidate of this.candidates(request, deadline)) {
+    for await (const candidate of this.retryableCandidates(request, deadline)) {
       if (this.now() >= deadline)
         break;
       try {
@@ -349193,9 +349215,11 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
         if (!usableResult(result))
           throw new EmptyInferenceResponse();
         cooldowns.delete(routeKey(candidate));
+        this.lifecycle(request, "succeeded", candidate);
         return this.scrubber(candidate)(result);
       } catch (error) {
         this.fence(request);
+        this.lifecycle(request, "failed", candidate, error);
         this.cooldown(candidate, error);
       }
     }
@@ -349219,9 +349243,12 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     }
     this.fence(request);
     let emitted = false;
+    let localSelected = false;
     try {
       if (this.localAdmissionTimeoutMs(request) === 0)
         throw new AttemptTimeout();
+      this.lifecycle(request, "selected");
+      localSelected = true;
       if (request.localAdmissionFailure !== void 0)
         throw request.localAdmissionFailure;
       for await (const chunk of this.requireUsableStream(this.boundedStream(request, this.policy.localTimeoutMs, local, true))) {
@@ -349229,9 +349256,12 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
         yield chunk;
       }
       localCooldowns.delete(routeKey(this.primary));
+      this.lifecycle(request, "succeeded");
       return;
     } catch (error) {
       this.fence(request);
+      if (localSelected)
+        this.lifecycle(request, "failed", void 0, error);
       if (emitted)
         throw new StreamInterruptedError();
       if (!transportFailure(error))
@@ -349240,7 +349270,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     }
     await this.approveRemoteFallback(request);
     const deadline = this.now() + this.policy.totalTimeoutMs;
-    for await (const candidate of this.candidates(request, deadline)) {
+    for await (const candidate of this.retryableCandidates(request, deadline)) {
       if (this.now() >= deadline)
         break;
       try {
@@ -349264,9 +349294,11 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
           yield chunk;
         }
         cooldowns.delete(routeKey(candidate));
+        this.lifecycle(request, "succeeded", candidate);
         return;
       } catch (error) {
         this.fence(request);
+        this.lifecycle(request, "failed", candidate, error);
         if (emitted)
           throw new StreamInterruptedError();
         this.cooldown(candidate, error);
@@ -349401,6 +349433,26 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     });
     request.onInferenceRoute?.({ ...this.lastRoute });
     this.options.onRoute?.({ providerId: this.lastRoute.providerId, model: this.lastRoute.model });
+    this.lifecycle(request, "selected", route);
+  }
+  lifecycle(request, phase, route, error) {
+    this.fence(request);
+    if (!request.onInferenceRouteLifecycle)
+      return;
+    const receipt = {
+      location: route ? "remote" : "local",
+      phase,
+      model: route?.model ?? this.primary.model,
+      providerId: route ? route.keyless?.id ?? route.providerId ?? "remote" : this.primary.providerId ?? "ollama",
+      backendType: route ? "vllm" : this.primary.backendType ?? "ollama",
+      ...request.logicalRequestId ? { logicalRequestId: request.logicalRequestId } : {},
+      ...phase === "failed" ? { failure: safeFailure(error) } : {}
+    };
+    try {
+      request.onInferenceRouteLifecycle(this.scrubber(route)(receipt));
+    } catch {
+      this.fence(request);
+    }
   }
   async prepare(route) {
     await this.validate(route.baseUrl);
@@ -349476,14 +349528,14 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
       configuredEndpointOnly: true,
       disableEmptyContentRecovery: true,
       maxTokens: this.remoteOutputTokens(request, route),
-      ...route.contextWindow || route.maxOutputTokens ? { providerDefaultOutput: void 0 } : {},
+      ...route.contextWindow || route.maxOutputTokens ? { providerDefaultOutput: void 0 } : route.keyless ? { providerDefaultOutput: true, remoteProviderDefaultOutput: true } : {},
       preferNativeOllamaChat: false,
       think: false,
       ...route.keyless?.directAnswer ? { chatTemplateKwargs: { enable_thinking: false } } : {},
       timeoutMs: Math.min(request.timeoutMs, this.policy.requestTimeoutMs)
     };
   }
-  compatible(request, route) {
+  compatible(request, route, includeCooling = false) {
     if (this.scrubber(route)(route.model) !== route.model)
       return false;
     if (request.tools.length && !route.nativeToolsHint || hasImages(request) && !route.images)
@@ -349499,7 +349551,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     const minimum = route.contextWindow ? Math.min(request.maxTokens, minimumOutputTokens(route.contextWindow)) : 1;
     if (this.remoteOutputTokens(request, route) < minimum)
       return false;
-    return (cooldowns.get(routeKey(route)) ?? 0) <= this.now();
+    return includeCooling || (cooldowns.get(routeKey(route))?.until ?? 0) <= this.now();
   }
   remoteOutputTokens(request, route) {
     let budget = Math.min(request.maxTokens, route.maxOutputTokens ?? Infinity);
@@ -349514,12 +349566,66 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
     return Math.floor(budget);
   }
   cooldown(route, error) {
-    const hinted = object4(error) && typeof error.retryAfterMs === "number" && Number.isFinite(error.retryAfterMs) ? Math.max(0, Math.min(3e5, error.retryAfterMs)) : 0;
+    const status = errorStatus(error);
+    route.lastAttemptRateLimited = status === 429;
+    if (status !== void 0 && status >= 400 && status < 500 && status !== 429)
+      return;
+    const hint = errorChain(error).find((value) => object4(value) && typeof value.retryAfterMs === "number" && Number.isFinite(value.retryAfterMs));
+    const hinted = object4(hint) && typeof hint.retryAfterMs === "number" ? Math.max(1, Math.min(3e5, hint.retryAfterMs)) : void 0;
     if (cooldowns.size >= 256)
       cooldowns.delete(cooldowns.keys().next().value);
-    cooldowns.set(routeKey(route), this.now() + Math.max(15e3, hinted));
+    cooldowns.set(routeKey(route), {
+      until: this.now() + (status === 429 ? hinted ?? 15e3 : Math.max(15e3, hinted ?? 0)),
+      rateLimited: status === 429
+    });
+  }
+  async *retryableCandidates(request, deadline) {
+    const waiting = /* @__PURE__ */ new Map();
+    const attempts = /* @__PURE__ */ new Map();
+    const defer = (candidate) => {
+      const key = routeKey(candidate);
+      if (candidate.lastAttemptRateLimited && (attempts.get(key) ?? 0) < 3)
+        waiting.set(key, candidate);
+    };
+    for await (const candidate of this.candidates(request, deadline, true)) {
+      const key = routeKey(candidate);
+      if ((cooldowns.get(key)?.until ?? 0) > this.now()) {
+        if (cooldowns.get(key)?.rateLimited)
+          waiting.set(key, candidate);
+        continue;
+      }
+      if (this.now() >= deadline)
+        return;
+      attempts.set(key, 1);
+      yield candidate;
+      defer(candidate);
+    }
+    while (waiting.size && this.now() < deadline) {
+      this.fence(request);
+      const [key, candidate] = [...waiting].sort(([a], [b]) => (cooldowns.get(a)?.until ?? 0) - (cooldowns.get(b)?.until ?? 0))[0];
+      const delay2 = Math.max(0, (cooldowns.get(key)?.until ?? 0) - this.now());
+      if (delay2 >= deadline - this.now())
+        return;
+      if (delay2) {
+        let timer;
+        try {
+          const pause = new Promise((resolve38) => {
+            timer = setTimeout(resolve38, delay2);
+          });
+          await (request.signal ? this.abortable(pause, request.signal) : pause);
+        } finally {
+          clearTimeout(timer);
+        }
+        this.fence(request);
+        continue;
+      }
+      waiting.delete(key);
+      attempts.set(key, (attempts.get(key) ?? 0) + 1);
+      yield candidate;
+      defer(candidate);
+    }
   }
-  async *candidates(request, deadline) {
+  async *candidates(request, deadline, includeCooling = false) {
     let count2 = 0;
     const seen = /* @__PURE__ */ new Set();
     for (const profile3 of this.policy.providers) {
@@ -349538,7 +349644,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
         profile: profile3
       };
       const key = routeKey(route);
-      if (!seen.has(key) && this.compatible(request, route)) {
+      if (!seen.has(key) && this.compatible(request, route, includeCooling)) {
         seen.add(key);
         yield route;
         if (++count2 >= MAX_ROUTES2 || this.now() >= deadline)
@@ -349578,7 +349684,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
         keyless: provider,
         ...provider.anonymousAuthorization === "Bearer unused" ? { apiKey: "unused" } : {}
       };
-      if (seen.has(routeKey(route)) || !this.compatible(request, route))
+      if (seen.has(routeKey(route)) || !this.compatible(request, route, includeCooling))
         continue;
       seen.add(routeKey(route));
       try {
@@ -349609,7 +349715,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
           if (Array.isArray(selected.supported_parameters) && request.tools.length && !selected.supported_parameters.includes("tools"))
             continue;
         }
-        if (!route.model || !this.compatible(request, route))
+        if (!route.model || !this.compatible(request, route, includeCooling))
           continue;
         const actualKey = routeKey(route);
         if (actualKey !== `${new URL(route.baseUrl).origin}\0${provider.model}` && seen.has(actualKey))
@@ -388269,7 +388375,7 @@ ${read.content}`;
           throw new Error("interruption_stale_model_dispatch");
       };
       assertCurrent();
-      const needsRouteHooks = typeof backend.canUseRemoteFallback === "function" || typeof this.backend.canUseRemoteFallback === "function" || outbound.assertCurrentAtDispatch !== void 0 || outbound.onInferenceRoute !== void 0;
+      const needsRouteHooks = typeof backend.canUseRemoteFallback === "function" || typeof this.backend.canUseRemoteFallback === "function" || outbound.assertCurrentAtDispatch !== void 0 || outbound.onInferenceRoute !== void 0 || outbound.onInferenceRouteLifecycle !== void 0;
       const dispatchRequest = needsRouteHooks ? {
         ...outbound,
         assertCurrentAtDispatch: assertCurrent,
@@ -388282,6 +388388,17 @@ ${read.content}`;
             turn: operation.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
+        },
+        onInferenceRouteLifecycle: (receipt) => {
+          assertCurrent();
+          outbound.onInferenceRouteLifecycle?.(receipt);
+          this.emit({
+            type: "inference_route",
+            inferenceRoute: receipt,
+            visibility: "telemetry",
+            turn: operation.turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
         }
       } : outbound;
       const response = await backend.chatCompletion(dispatchRequest);
@@ -421617,11 +421734,22 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
   _knownTransportContextCapability;
   _remoteFallback;
   _inferenceFallbackApprovalHandler;
+  _inferenceRouteLifecycleHandler;
+  setInferenceRouteLifecycleHandler(handler) {
+    this._inferenceRouteLifecycleHandler = handler;
+  }
   setInferenceFallbackApprovalHandler(handler) {
     this._inferenceFallbackApprovalHandler = handler;
   }
   remoteFallback() {
-    return this._remoteFallback ??= new RemoteInferenceFallback({ baseUrl: this.baseUrl, model: this.model, apiKey: this.apiKey, additionalSecrets: () => this._keyPool }, (route) => new _OllamaAgenticBackend(route.baseUrl, route.model, route.apiKey, false, route.protocol, route.providerId));
+    return this._remoteFallback ??= new RemoteInferenceFallback({
+      baseUrl: this.baseUrl,
+      model: this.model,
+      apiKey: this.apiKey,
+      additionalSecrets: () => this._keyPool,
+      providerId: this._provider.providerId,
+      backendType: this._provider.protocol === "ollama" ? "ollama" : "vllm"
+    }, (route) => new _OllamaAgenticBackend(route.baseUrl, route.model, route.apiKey, false, route.protocol, route.providerId));
   }
   /** Remote endpoints never reserve a GPU on this host. */
   usesLocalGpuAdmission() {
@@ -421641,11 +421769,21 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
   requestWithRunSignal(request) {
     const signal = mergeInferenceAbortSignals([request.signal, this._abortSignal]);
     const handler = this._inferenceFallbackApprovalHandler;
-    if (!signal && (request.onInferenceFallbackRequired || !handler))
+    const routeHandler = this._inferenceRouteLifecycleHandler;
+    if (!signal && !routeHandler && !request.onInferenceRouteLifecycle && (request.onInferenceFallbackRequired || !handler))
       return request;
     return {
       ...request,
       ...signal ? { signal } : {},
+      ...routeHandler || request.onInferenceRouteLifecycle ? {
+        logicalRequestId: request.logicalRequestId ?? crypto.randomUUID(),
+        onInferenceRouteLifecycle: (receipt) => {
+          signal?.throwIfAborted();
+          request.assertCurrentAtDispatch?.();
+          request.onInferenceRouteLifecycle?.(receipt);
+          routeHandler?.(receipt);
+        }
+      } : {},
       ...request.onInferenceFallbackRequired || !handler ? {} : {
         onInferenceFallbackRequired: (receipt) => handler({ ...receipt, signal })
       }
@@ -421931,7 +422069,8 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
   }
   brokerRequestOptions(request, body, signal) {
     const nativeContext = request.numCtx ?? request.num_ctx;
-    if (request.providerDefaultOutput === true && request.maxTokens === 16384 && request.contextAdmission !== true && !(Number.isFinite(nativeContext) && (nativeContext ?? 0) > 0) && this._provider.protocol !== "anthropic-messages") {
+    const remoteDefault = request.remoteProviderDefaultOutput === true && request.configuredEndpointOnly === true && this._provider.protocol === "openai-chat";
+    if (request.providerDefaultOutput === true && (remoteDefault || request.maxTokens === 16384 && request.contextAdmission !== true && !(Number.isFinite(nativeContext) && (nativeContext ?? 0) > 0)) && this._provider.protocol !== "anthropic-messages") {
       delete body["max_tokens"];
       const options = body["options"];
       if (options && typeof options === "object" && !Array.isArray(options))

package/docs/DISCOVERY.json

@@ -32454,6 +32454,42 @@
         }
       ]
     },
+    {
+      "id": "guide.work-orders-active-inference-route-remote-probes-20261012",
+      "kind": "guide",
+      "title": "Active Inference Route Remote Probes 20261012",
+      "summary": "Bundled Omnius documentation artifact: docs/work-orders/active-inference-route-remote-probes-20261012.json.",
+      "keywords": [
+        "work",
+        "orders",
+        "active",
+        "inference",
+        "route",
+        "remote",
+        "probes",
+        "20261012",
+        "json"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/active-inference-route-remote-probes-20261012.json"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/active-inference-route-remote-probes-20261012.json",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
     {
       "id": "guide.work-orders-daemon-hud-ui-overhaul",
       "kind": "guide",
@@ -37089,6 +37125,44 @@
         }
       ]
     },
+    {
+      "id": "guide.work-orders-wo-active-inference-route-and-telegram-review-20261012-uppercase",
+      "kind": "guide",
+      "title": "Active inference route and Telegram completion review",
+      "summary": "Status: implementation complete and verified. Publication remains with the user.",
+      "keywords": [
+        "work",
+        "orders",
+        "WO",
+        "active",
+        "inference",
+        "route",
+        "and",
+        "telegram",
+        "review",
+        "20261012",
+        "md"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/WO-active-inference-route-and-telegram-review-20261012.md"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/WO-active-inference-route-and-telegram-review-20261012.md",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
     {
       "id": "guide.work-orders-wo-am-gaps-uppercase",
       "kind": "guide",

package/docs/DISCOVERY.md

@@ -518,6 +518,7 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `guide.trajectory-grounding` | Trajectory Grounding | Trajectory Grounding gives a running agent a compact, evidence-bound account of where a project stands, what changed, what remains uncertain, and the safest next action. Before the first main-agent request, Omnius asks the selected model to form a specific, structured orientation from that evidence. This is a control-plane checkpoint, not free-form self-talk |
 | `guide.vitepress-config` | Config | Bundled Omnius documentation artifact: docs/.vitepress/config.mts. |
 | `guide.voice-flow-architecture` | Voice TTS Flow — Architecture &amp; Implementation Guide | This document describes the voice synthesis system in omnius: how it's built, how all the pieces connect, and how to add new voice features following the same patterns. |
+| `guide.work-orders-active-inference-route-remote-probes-20261012` | Active Inference Route Remote Probes 20261012 | Bundled Omnius documentation artifact: docs/work-orders/active-inference-route-remote-probes-20261012.json. |
 | `guide.work-orders-daemon-hud-ui-overhaul` | Daemon HUD UI Overhaul Work Order | Overhaul the daemon web interface using /home/roko/Desktop/hud-ui-style-kit(6)/hud-ui-style-kit as the source of truth. Preserve current daemon behavior while replacing the OpenWebUI-like rounded dashboard styling with the cold tactical HUD visual system. |
 | `guide.work-orders-hermes-architecture-deltas-01-public-scrutiny-provenance-control-index-uppercase` | Public Scrutiny Provenance Control Index | Bundled Omnius documentation artifact: docs/work-orders/hermes-architecture-deltas/01-public-scrutiny-provenance-control/INDEX.md. |
 | `guide.work-orders-hermes-architecture-deltas-01-public-scrutiny-provenance-control-workorder-uppercase` | Workorder: Public Scrutiny Provenance Control | Add a public Telegram scrutiny control plane that can elevate completion provenance checks when public accuracy risk rises, without hard-coded scenario phrases or shortcut wording that teaches the model to satisfy the gate without evidence. |
@@ -640,6 +641,7 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `guide.work-orders-telegram-progress-browser-20261011-wo-04-download-desktop-handoff-uppercase` | WO-04: Acquire browser files and expose desktop save-dialog tools | Status: complete — integrated and verified offline |
 | `guide.work-orders-telegram-progress-browser-20261011-wo-05-verification-delivery-uppercase` | WO-05: Verify the integrated repair and deliver scoped commits | Status: complete — verified offline and delivered to origin/main |
 | `guide.work-orders-telegram-reliability-consolidation-2026-09-28` | Telegram Reliability Consolidation — 2026-09-28 | Rule: check a box only after the named behavior is implemented and its listed verification passes. A parent box stays open until every child box is checked. |
+| `guide.work-orders-wo-active-inference-route-and-telegram-review-20261012-uppercase` | Active inference route and Telegram completion review | Status: implementation complete and verified. Publication remains with the user. |
 | `guide.work-orders-wo-am-gaps-uppercase` | Associative Memory Gap Work Orders | Generated: 2026-04-13 Source: Deep audit of multimodal associative memory systems Status: READY FOR IMPLEMENTATION |
 | `guide.work-orders-wo-inference-fallback-20261012-uppercase` | Local inference outage fallback | Status: source implementation complete and verified. Installed-runtime activation is separate; the running daemon has not been upgraded or restarted. |
 | `guide.work-orders-wo-primary-checkout-fallback-delivery-20261012-uppercase` | Primary checkout delivery and remote output capacity | Status: implementation complete and verified in the primary checkout. Publication remains with the user. |

package/docs/work-orders/WO-active-inference-route-and-telegram-review-20261012.md

@@ -0,0 +1,94 @@
+# Active inference route and Telegram completion review
+
+Status: implementation complete and verified. Publication remains with the user.
+
+## Observed behavior
+
+The installed 1.0.843 runtime contains the repaired fallback bundle. At 23:36
+UTC, Hermes answered Telegram input 3357. A subsequent native goal assessment
+failed through the remote cascade, leaving the greeting with an incomplete-task
+suffix. The TUI header still displayed the configured local model throughout
+remote inference.
+
+## Work orders and acceptance
+
+1. Trace the actual running process and request artifacts. Separate the primary
+   reply from completion-review failures; reproduce the observed transport
+   incompatibility before repairing it.
+2. Display the actual selected provider model and Local/Remote location in the
+   TUI header for both terminal and Telegram inference. Keep configured local
+   credentials, endpoint and model unchanged. Fence stale request callbacks.
+3. Retry the original local route automatically after its bounded outage
+   cooldown on real work. Restore the local display only when local inference
+   produces usable output. Do not generate background probe requests.
+4. Make Telegram completion reviews usable through the remote fallback while
+   preserving the complete response schema and host validation. Do not bypass
+   evidence or provider acknowledgement checks to declare success.
+5. Keep request-specific provider incompatibilities from disabling unrelated
+   requests. Surface bounded diagnostic classes/statuses without provider error
+   bodies, endpoint credentials, environment values or prompt contents.
+6. Exercise native Telegram greeting and review, route changes, streaming and
+   unary recovery, stale owners, cancellation, manual fallback and exhaustion.
+   Rebuild and verify the actual publication bundle; commit and push only this
+   repair while preserving unrelated working-tree edits.
+
+## Constraints
+
+No Telegram messages, local inference or CUDA workloads are required for the
+regressions. Synthetic remote probes may use only public catalog routes and
+non-sensitive fixture text. The user handles npm publication.
+
+## Diagnosis and implemented behavior
+
+The original review's per-provider errors were not retained. Synthetic probes
+accepted the exact strict assessment schema. Back-to-back streamed Hermes
+requests reproduced a successful first request followed by an empty HTTP 429
+response with `Retry-After: 1`. The prior code immediately exhausted the cascade
+and imposed a minimum 15-second provider cooldown. The native Telegram
+regression reproduced the incomplete suffix before the repair.
+
+Fallback now tries other available compatible routes, then waits for a
+throttled route within the same total request deadline. It honors Retry-After,
+limits each route to three attempts, and retains cancellation, ownership and
+the no-replay boundary after streamed output begins. Non-429 request rejections
+do not suppress unrelated requests. A 429 followed by a deterministic rejection
+does not cause another retry from stale throttle state.
+
+LLM7's `default` selector is absent from its model catalog. For keyless routes
+without output/context metadata, a host-only hint selects provider output
+defaults at the actual pinned OpenAI wire boundary. Complete messages, tools
+and response schemas remain intact. Known-capacity routes retain the explicit
+bounded output ceiling. Local request capacity is unchanged.
+
+Host route lifecycle receipts contain only model/provider identifiers,
+location, phase, request identity and bounded diagnostic category/status. The
+TUI and Telegram paths deliver these receipts to the header. Local selection
+establishes ownership while retaining an active remote label; usable local
+success restores the local label. The existing non-sliding 15-second local
+cooldown permits recovery on subsequent real work without background generation.
+Explicit configuration changes invalidate older UI handlers. Display observer
+failures cannot discard successful inference or trigger replay.
+
+Synthetic probe evidence is recorded in
+`active-inference-route-remote-probes-20261012.json`.
+
+## Verification
+
+- All 11 workspace projects passed a clean rebuild and the staging audit.
+- 350 orchestrator checks passed. The CLI run passed 203 checks and exposed an
+  obsolete primary-telemetry fixture that also failed on clean `14db5c33`.
+  Updating only that fixture to the permitted action profile and one turn
+  preserved every assertion and passed, bringing the selected CLI checks to
+  204. No production permission or completion guard was weakened.
+- The actual tarball passed its 528-file audit with zero warnings. An isolated
+  installation with lifecycle scripts disabled passed all 12 bundled-backend
+  checks: automatic/manual unary and streaming, primary-to-review throttling,
+  successful local recovery, and unknown-selector output defaults on the wire.
+  HTTP and DNS were mocked throughout these bundled checks.
+- Independent review reproduced and verified the fixes for stale throttle
+  eligibility, the actual output-omission gate and display-observer exceptions.
+
+The isolated bundle check does not establish a working native installation:
+the user's ordinary fresh-install gate subsequently reported a required
+`node-datachannel` native-build failure. That installer repair is separate work
+and remains necessary before publication.

package/docs/work-orders/active-inference-route-remote-probes-20261012.json

@@ -0,0 +1,34 @@
+{
+  "schema": "omnius.inference-route-incident-evidence.v1",
+  "date": "2026-10-12",
+  "installedVersion": "1.0.843",
+  "installedBundleSha256": "1c020e46538ba5a79d1d2b7586f2f8922b0f4bab36354bd878b49939461d8d9b",
+  "incident": {
+    "inputMessageId": 3357,
+    "runId": "telegram:e6eb632a9f3e0acd",
+    "primaryFallbackProvider": "hermes",
+    "primaryFallbackSucceededAt": "2026-10-12T23:36:17.680Z",
+    "nativeGoalAssessment": "unavailable",
+    "originalProviderFailureBodiesAvailable": false
+  },
+  "syntheticRemoteProbes": [
+    { "provider": "hermes", "transport": "unary", "format": "exact native assessment schema", "status": 200, "conformingJson": true },
+    { "provider": "hermes", "transport": "stream", "format": "exact native assessment schema", "status": 200, "sseFrames": 43, "done": true },
+    { "provider": "hermes", "transport": "stream", "timing": "immediately after successful identical request", "status": 429, "retryAfterSeconds": 1, "emptyBody": true },
+    { "provider": "llm7", "transport": "stream", "format": "small strict schema", "status": 200, "visibleContent": true, "done": true },
+    { "provider": "ovh_ai_endpoints", "transport": "stream", "format": "small strict schema", "status": 200, "visibleContent": false, "done": true, "outputCeiling": 128 }
+  ],
+  "catalogs": {
+    "hermes": { "model": "turboderp/Qwen3.8-27B-exl3", "max_model_len": 65536 },
+    "llm7": { "modelCount": 65, "selector": "default", "selectorPresentInCatalog": false },
+    "ovh_ai_endpoints": { "model": "gpt-oss-20b", "context_length": 131072, "max_completion_tokens": 131072 }
+  },
+  "limits": [
+    "The original review's per-provider HTTP errors were not durably retained; the throttling probe reproduces a concrete failure path without proving every original provider error.",
+    "The OVH probe used an intentionally small output ceiling and does not establish failure with a normal output allowance."
+  ],
+  "userContextSentByProbes": false,
+  "credentialsSentByProbes": false,
+  "localInferenceRequests": 0,
+  "telegramMessagesSent": 0
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.843",
+  "version": "1.0.845",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.843",
+      "version": "1.0.845",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.843",
+  "version": "1.0.845",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",