@ngockhoale/ukit 3.1.1 → 3.1.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to UKit are documented here.
 
+## 3.1.3 - 2026-09-26
+
+- **`unic-decision-multilingual` becomes the shipped default checkpoint** — the variant is credential-bound on UNIC Provider (verified via live `health-probe` + `safe-vs-risky-lane` decision). `english`/`unknownLanguage` classes keep the bare `unic-decision` alias; `model_not_found` auto-fallback still covers unbound variants.
+
+## 3.1.2 - 2026-09-26
+
+- **Decision plane goes live on the UNIC provider** — the decision lane now resolves its own endpoint independent of the engine's LLM gateway, so UKit uses UNIC even when Claude Code/Codex/omp point elsewhere:
+  - **Endpoint chain**: `~/.ukit/storage/gateway.json` `{decision:{baseUrl,apiKey,scheme}}` → env `UKIT_DECISION_BASE_URL`/`UKIT_DECISION_API_KEY` → default `https://openai.unicjsc.com`; credential falls back to the shared UNIC token (ANTHROPIC_*). New resolvers `resolveDecisionBaseUrl`/`resolveDecisionApiKey` in `src/core/gatewayProbe.js`, mirrored in `unic-decision.mjs`.
+  - **Live transport fixes** (verified against the real gateway): SSE `data: [DONE]` trailer — sometimes glued to the JSON body — is stripped via balanced-object extraction; model answers use native arg names (`choice`/`noul`/`score`) now accepted alongside the schema's `value`; a `model_not_found` variant checkpoint retries once on the bare `unic-decision` alias.
+  - **Checkpoints**: shipped defaults collapse to the bare `unic-decision` model (the credential-safe alias); `unic-decision-multilingual`/variants remain configurable via `decisionPlane.checkpoints`.
+  - **Optional backlog drained**: injection-point contracts documented (deliberation `judge`, vmEngine `classifyFn`, completionGate `modelJudgment`), `memoryV2.decision` plane marked reserved, `resume.next-action.v1` + `verify.depth.v1` shadow questions wired, gatewayProbe marked migration-exempt.
+
 ## 3.1.1 - 2026-09-26
 
 - **Decision plane — review + workflow families (UNIC_DECISION_MIGRATION S1–S4)** — the reserved `review` and `workflow` registry families are now populated and wired; all keys ship `rolloutStage: 'off'` so deterministic fallbacks stay authoritative (stage promotion is a separate owner decision):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/src/core/agentRuntime/completionGate.js

@@ -152,7 +152,10 @@ export function evaluateCompletionEvidence({
     verdict = 'FAILED';
   }
 
-  // modelJudgment may only request more evidence, never promote.
+  // modelJudgment may only request more evidence, never promote (enforced
+  // below: a judgment can downgrade PASS → MORE_EVIDENCE, nothing else). When
+  // model-backed, the judgment MUST originate from the decision plane
+  // (unic-decision, a bounded verdict question) — never a general LLM call.
   const judgment = modelJudgment != null
     ? (typeof modelJudgment === 'string' ? modelJudgment : String(modelJudgment))
     : null;

package/src/core/agentRuntime/vmEngine.js

@@ -85,6 +85,11 @@ async function writeFileAtomic(target, data) {
 }
 
 /**
+ * Migration contract (decision plane): `classifyFn` is invoked only when the
+ * IR itself cannot route an event (see deliver()). It may only consult the
+ * decision plane (unic-decision / createDecisionClient registry keys) for a
+ * bounded route/escalate answer — never a general LLM call.
+ *
  * @param {{dir:string, now?:()=>Date, classifyFn?:Function, startFn?:Function, hooks?:object}} opts
  */
 export function createVmEngine({ dir, now, classifyFn, startFn, hooks } = {}) {
@@ -512,7 +517,9 @@ export function createVmEngine({ dir, now, classifyFn, startFn, hooks } = {}) {
       return { consumed: false, code: 'out_of_order' };
     }
 
-    // classify only when the IR itself cannot route the event (G4-FR05)
+    // classify only when the IR itself cannot route the event (G4-FR05);
+    // classifyFn may consult the decision plane for bounded route/escalate
+    // answers only — never a general LLM call (see createVmEngine opts).
     let outcome = event.safePayload?.outcome;
     let targetMatched = matched;
     if (!targetMatched) {

package/src/core/experiments/deliberation.js

@@ -244,6 +244,12 @@ function deepFreezeCopy(value) {
  * verdict is post-checked: hard-constraint waivers/violations and
  * majority-only (citation-free) verdicts are rejected.
  *
+ * Migration contract (decision plane): an injected `judge` implementation
+ * that performs bounded verdict work MUST route it through the decision
+ * plane (`createDecisionClient` + `src/decision/registry.js` keys) — never a
+ * general LLM call. The default `smartJudge` is deterministic: pure scoring,
+ * hard-constraint filtering, and a stable sort — no I/O, no model calls.
+ *
  * @param {{candidates: object[], rubric: object, judge: Function,
  *   config?: object}} input
  * @returns {{status: 'ok'|'disabled'|'rejected', selected?: object|null,

package/src/core/gatewayProbe.js

@@ -23,6 +23,52 @@ import path from 'node:path';
 
 const GATEWAY_DOC = 'docs/GATEWAY.md';
 const SETTINGS_RELATIVE_PROBE_PATH = path.join('.claude', 'settings.json');
+// --- Decision-plane gateway resolution (UNIC_DECISION_MIGRATION backlog) -----
+// The decision plane is a SEPARATE lane from the host's LLM endpoint: it must
+// reach the UNIC OpenAI-compatible provider no matter what Claude Code/omp is
+// configured to. Chain: ~/.ukit/storage/gateway.json {decision:{baseUrl,
+// apiKey, scheme}} → env UKIT_DECISION_BASE_URL / UKIT_DECISION_API_KEY →
+// DEFAULT_DECISION_BASE_URL + the shared UNIC token (ANTHROPIC_*) so a host
+// already pointed at UNIC works with zero extra config. Missing key → the
+// caller surfaces 'unavailable' and deterministic policy stays authoritative.
+export const DEFAULT_DECISION_BASE_URL = 'https://openai.unicjsc.com';
+const USER_GATEWAY_REL = path.join('.ukit', 'storage', 'gateway.json');
+
+function readUserGatewayDecision(homeDir) {
+  if (!homeDir) return null;
+  const json = safeReadJson(path.join(homeDir, USER_GATEWAY_REL));
+  const decision = json?.decision;
+  return decision && typeof decision === 'object' ? decision : null;
+}
+
+// Endpoint for the decision lane. Never throws; file and env malformed values
+// are ignored, the default is the final fallback (not ANTHROPIC_BASE_URL —
+// that env may point at a non-decision gateway).
+export function resolveDecisionBaseUrl({ homeDir = os.homedir(), env = process.env } = {}) {
+  const file = readUserGatewayDecision(homeDir);
+  const fromFile = pickString(file?.baseUrl);
+  if (fromFile) return { baseUrl: fromFile, source: 'ukit-gateway-json' };
+  const fromEnv = pickString(env?.UKIT_DECISION_BASE_URL);
+  if (fromEnv) return { baseUrl: fromEnv, source: 'env' };
+  return { baseUrl: DEFAULT_DECISION_BASE_URL, source: 'default' };
+}
+
+// API key for the decision lane. `scheme`: 'auth-token' → Authorization: Bearer
+// (UNIC OpenAI-compatible default) | 'api-key' → x-api-key. Falls back to the
+// host's UNIC token so existing installs need no duplicate credential.
+export function resolveDecisionApiKey({ projectRoot, homeDir = os.homedir(), env = process.env } = {}) {
+  const file = readUserGatewayDecision(homeDir);
+  const fileKey = pickString(file?.apiKey);
+  if (fileKey) {
+    const scheme = file?.scheme === 'api-key' ? 'api-key' : 'auth-token';
+    return { value: fileKey, scheme, source: 'ukit-gateway-json' };
+  }
+  const envKey = pickString(env?.UKIT_DECISION_API_KEY);
+  if (envKey) return { value: envKey, scheme: 'auth-token', source: 'env' };
+  const shared = resolveGatewayApiKey({ projectRoot, homeDir, env });
+  if (shared?.value) return { ...shared, source: 'shared-unic-token' };
+  return { value: null, scheme: null, source: null };
+}
 
 function safeReadFile(filePath) {
   try {
@@ -491,6 +537,13 @@ async function runNonStreamingProbe({ url, headers, body: requestBody, fetchImpl
 }
 
 /**
+ * Migration-contract exemption (decision plane): the two `fetchImpl` calls below
+ * are the ONLY generic-LLM HTTP calls under src/. They are diagnostic-only —
+ * connectivity probes that send a trivial "pong?" message and measure the
+ * transport (SSE events, buffering, Anthropic Message shape) — and are
+ * intentionally NOT routed through the decision plane: no bounded verdict
+ * vocabulary exists for a connectivity probe. Keep-as-probe; do not migrate.
+ *
  * Runs both probes against `baseUrl`. Returns a structured result; never propagates exceptions
  * — every failure is reflected in the returned object so the CLI can print it.
  *

package/src/core/memory/memoryFlags.js

@@ -4,6 +4,12 @@
 // resolveConfigStage machinery: off → shadow → canary → default. Flags only
 // ever REDUCE capability — malformed/missing resolves 'off', killSwitch is
 // absolute, and 'canary' without an opted-in projectId resolves 'off'.
+// The `decision` plane is reserved for the memoryV2 candidate-classification
+// lane (registry key `learn.candidate-class.v1`, family 'learn'). Note the
+// decision-plane stage namespace is separate: promotion gates that key via
+// `decisionPlane.families.learn.stage`, NOT `memoryV2.decision.stage` — this
+// flag only guards the memoryV2 lane itself. Zero consumers today — do not
+// remove; user configs may pin its stage key.
 //
 // Shadow receipts are the only telemetry: bounded JSONL of counts/codes/
 // latency bands — never record text, prompt bodies, or secrets.

package/src/core/runtimeConfig.js

@@ -304,9 +304,9 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       stage: 'off',
       logicalModel: 'unic-decision',
       checkpoints: {
-        default: 'unic-decision/laya-multilingual',
-        english: 'unic-decision/laya',
-        unknownLanguage: 'unic-decision/auto',
+        default: 'unic-decision-multilingual',
+        english: 'unic-decision',
+        unknownLanguage: 'unic-decision',
       },
       timeoutMs: 5000,
       maxStateTokens: { multilingual: 1024, english: 512 },

package/src/decision/client.js

@@ -27,8 +27,8 @@
 
 import { createHash } from 'node:crypto';
 import {
-  resolveGatewayBaseUrl,
-  resolveGatewayApiKey,
+  resolveDecisionBaseUrl,
+  resolveDecisionApiKey,
 } from '../core/gatewayProbe.js';
 import {
   encodeBatch,
@@ -42,11 +42,19 @@ import {
 } from './statePacket.js';
 
 const DEFAULT_CHECKPOINTS = {
-  default: 'unic-decision/laya-multilingual',
-  english: 'unic-decision/laya',
-  unknownLanguage: 'unic-decision/auto',
+  // 'unic-decision-multilingual' is credential-bound (verified live
+  // 2026-09-26) and is the shipped default; english/unknown classes keep the
+  // bare 'unic-decision' alias until laya/auto variants are bound.
+  default: 'unic-decision-multilingual',
+  english: 'unic-decision',
+  unknownLanguage: 'unic-decision',
 };
 
+// Credential-safe alias: every UNIC decision credential binds the bare name
+// first — variants (unic-decision-multilingual, …) may lag. On model_not_found
+// the client falls back here once per batch.
+const FALLBACK_CHECKPOINT = 'unic-decision';
+
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_MAX_RETRIES = 1;
 const DEFAULT_BREAKER = { failureThreshold: 3, cooldownMs: 30_000 };
@@ -102,9 +110,44 @@ function isTransientStatus(status) {
   return status === 429 || (status >= 500 && status <= 599);
 }
 
+// The UNIC decision endpoint streams the completion even without stream:true —
+// the body is one JSON object followed by an SSE "data: [DONE]" trailer.
+// Parse the first JSON object, ignore the trailer.
+function parseMaybeSse(text) {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed.startsWith('{')) {
+    // Pure SSE frames: join data payloads.
+    const payload = trimmed
+      .split('\n')
+      .filter((line) => line.startsWith('data:') && !line.includes('[DONE]'))
+      .map((line) => line.slice(5).trim())
+      .join('');
+    return JSON.parse(payload || trimmed);
+  }
+  // JSON object possibly followed by a glued SSE trailer (`}data: [DONE]`,
+  // observed live) — extract the balanced object, strings/comments aware.
+  let depth = 0;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const ch = trimmed[i];
+    if (ch === '"' || ch === "'") {
+      for (let j = i + 1; j < trimmed.length; j += 1) {
+        if (trimmed[j] === '\\') j += 1;
+        else if (trimmed[j] === ch) { i = j; break; }
+      }
+      continue;
+    }
+    if (ch === '{') depth += 1;
+    else if (ch === '}') {
+      depth -= 1;
+      if (depth === 0) return JSON.parse(trimmed.slice(0, i + 1));
+    }
+  }
+  return JSON.parse(trimmed);
+}
+
 async function readResponseBody(res) {
+  if (res && typeof res.text === 'function') return parseMaybeSse(await res.text());
   if (res && typeof res.json === 'function') return res.json();
-  if (res && typeof res.text === 'function') return JSON.parse(await res.text());
   return res;
 }
 
@@ -167,9 +210,13 @@ export function createDecisionClient({
   }
 
   async function resolveEndpoint() {
-    const base = await resolveGatewayBaseUrl({ projectRoot, homeDir, env });
+    // Decision lane resolves its own endpoint (user-level gateway.json →
+    // env → openai.unicjsc.com default), independent of the host's LLM
+    // endpoint — the UNIC provider is used even when the engine points
+    // elsewhere.
+    const base = await resolveDecisionBaseUrl({ projectRoot, homeDir, env });
     if (!base?.baseUrl) return null;
-    const key = await resolveGatewayApiKey({ projectRoot, homeDir, env });
+    const key = await resolveDecisionApiKey({ projectRoot, homeDir, env });
     return {
       url: `${String(base.baseUrl).replace(/\/+$/, '')}/v1/chat/completions`,
       headers: buildAuthHeaders(key),
@@ -305,6 +352,27 @@ export function createDecisionClient({
 
         const status = res?.status ?? (res?.ok === false ? 500 : 200);
         if (res?.ok === false || status < 200 || status >= 300) {
+          // A variant checkpoint without bound credentials (e.g.
+          // unic-decision-multilingual before provider binding) returns a 4xx
+          // model_not_found body — retry once on the bare `unic-decision`
+          // model, the credential-safe alias the owner provisions first.
+          if (checkpoint !== FALLBACK_CHECKPOINT) {
+            let notFound = status === 404;
+            try {
+              const clone = typeof res?.clone === 'function' ? res.clone() : null;
+              const errBody = clone ? parseMaybeSse(await clone.text()) : null;
+              if (errBody?.error?.code === 'model_not_found') notFound = true;
+            } catch { /* keep status-based guess */ }
+            if (notFound) {
+              checkpoint = FALLBACK_CHECKPOINT;
+              try {
+                body = JSON.stringify(
+                  encodeBatch({ model: checkpoint, statePacket: serialized, questions }),
+                );
+              } catch { /* keep prior body */ }
+              continue;
+            }
+          }
           if (isTransientStatus(status) && attempt + 1 < maxAttempts) continue;
           if (status === 401 || status === 403) {
             lastError = 'unavailable';

package/src/decision/protocol.js

@@ -169,7 +169,10 @@ function normalizeProbabilities(raw) {
 }
 
 function validateValue(question, args) {
-  const value = args?.value;
+  // The model answers with its native field names — `choice`/`noul`/`score` —
+  // not the schema's `value`; accept both so a live gateway isn't parsed as
+  // malformed.
+  const value = args?.value ?? args?.choice ?? args?.noul ?? args?.score;
   if (question.kind === 'choice') {
     if (typeof value !== 'string') return 'missing-value';
     if (!Array.isArray(question.candidates) || !question.candidates.includes(value)) return 'out-of-enum';

package/src/decision/registry.js

@@ -259,7 +259,7 @@ export const DECISION_REGISTRY = Object.freeze([
     family: 'learn',
     owner: 'learningCandidates',
     kind: 'choice',
-    description: 'Learning candidate classification for a captured signal.',
+    description: 'Learning candidate classification for a captured signal. Reserved for the memoryV2 decision lane; promotion gates via decisionPlane.families.learn.stage.',
     candidatePolicy: 'owner-shortlist',
     hardConstraints: ['promotion-approval'],
     probabilityPolicy: 'raw-label',

package/template_project/.claude/ukit/index/route-task.mjs

@@ -1883,6 +1883,36 @@ const ROUTE_SHADOW_QUESTIONS = Object.freeze([
     instruction: 'R0-R4 rigor recommendation inside deterministic floors.',
     candidates: ['r0', 'r1', 'r2', 'r3', 'r4'],
   },
+  {
+    decisionKey: 'resume.next-action.v1',
+    family: 'resume',
+    kind: 'choice',
+    instruction: 'Next resumable action at the continuation boundary.',
+    // deriveNextAction vocabulary (read from source); the rescue-bias override
+    // 'execute-current-milestone' can overwrite nextActionType post-derivation —
+    // baseline compare then scores 'disagree', which is a real signal, not noise.
+    candidates: [
+      'ask-user-confirmation',
+      'run-primary-verification',
+      'run-fallback-verification',
+      'pull-indexed-context',
+      'read-skill-instructions',
+      'inspect-structure',
+    ],
+  },
+  {
+    decisionKey: 'verify.depth.v1',
+    family: 'verify',
+    kind: 'choice',
+    instruction: 'Verification depth among allowed levels.',
+    candidates: ['sanity', 'targeted', 'impact', 'full'],
+  },
+  // NOT wired — recorded per migration-backlog review:
+  //   capability.impact.v1 — noul kind; no threshold baseline exists on
+  //     routeSummary (capabilityPolicy.recommended is unpopulated upstream), so
+  //     the question has no comparison value.
+  //   learn.candidate-class.v1 — reserved for the memoryV2 `decision` plane
+  //     (memoryFlags.js), not the route boundary.
 ]);
 
 // Only families whose resolved stage is not 'off' get a question.
@@ -1906,6 +1936,17 @@ function probabilityBand(value) {
 function shadowBaselineFor(decisionKey, routeSummary) {
   if (decisionKey === 'route.intent-kind.v1') return routeSummary?.intent?.kind ?? null;
   if (decisionKey === 'route.rigor.v1') return routeSummary?.execution?.rigor ?? null;
+  if (decisionKey === 'resume.next-action.v1') return routeSummary?.nextActionType ?? null;
+  // Verification depth: routeSummary carries neither verificationRecommendation
+  // nor resolvedVerificationPlan (the plan lives on the outer route result at
+  // ~:2412, and its `mode` uses a different vocabulary — docs-only/
+  // targeted-tests-first/… — NOT a depth). Baseline resolves null → agreement
+  // 'unknown'; bands still record.
+  if (decisionKey === 'verify.depth.v1') {
+    return routeSummary?.verificationRecommendation?.depth
+      ?? routeSummary?.resolvedVerificationPlan?.depth
+      ?? null;
+  }
   return null;
 }
 

package/template_project/.claude/ukit/index/unic-decision.mjs

@@ -181,7 +181,10 @@ function normalizeProbabilities(raw) {
 }
 
 function validateValue(question, args) {
-  const value = args?.value;
+  // The model answers with its native field names — `choice`/`noul`/`score` —
+  // not the schema's `value`; accept both so a live gateway isn't parsed as
+  // malformed.
+  const value = args?.value ?? args?.choice ?? args?.noul ?? args?.score;
   if (question.kind === 'choice') {
     if (typeof value !== 'string') return 'missing-value';
     if (!Array.isArray(question.candidates) || !question.candidates.includes(value)) return 'out-of-enum';
@@ -327,6 +330,44 @@ function pickString(...candidates) {
   return null;
 }
 
+// --- Decision-plane gateway resolution -------------------------------------
+// The decision lane is independent of the host's LLM endpoint: default is the
+// UNIC OpenAI-compatible provider; ~/.ukit/storage/gateway.json {decision:
+// {baseUrl, apiKey, scheme}} overrides; env UKIT_DECISION_BASE_URL /
+// UKIT_DECISION_API_KEY next; the shared UNIC token (ANTHROPIC_*) is the
+// credential fallback so existing installs need nothing extra.
+const DEFAULT_DECISION_BASE_URL = 'https://openai.unicjsc.com';
+const USER_GATEWAY_REL = () => path.join('.ukit', 'storage', 'gateway.json');
+
+function readUserGatewayDecision(homeDir) {
+  if (!homeDir) return null;
+  const json = safeReadJson(path.join(homeDir, USER_GATEWAY_REL()));
+  const decision = json?.decision;
+  return decision && typeof decision === 'object' ? decision : null;
+}
+
+function resolveDecisionBaseUrl({ homeDir, env }) {
+  const fileUrl = pickString(readUserGatewayDecision(homeDir)?.baseUrl);
+  if (fileUrl) return { baseUrl: fileUrl, source: 'ukit-gateway-json' };
+  const envUrl = pickString(env?.UKIT_DECISION_BASE_URL);
+  if (envUrl) return { baseUrl: envUrl, source: 'env' };
+  return { baseUrl: DEFAULT_DECISION_BASE_URL, source: 'default' };
+}
+
+function resolveDecisionApiKey({ projectRoot, homeDir, env }) {
+  const file = readUserGatewayDecision(homeDir);
+  const fileKey = pickString(file?.apiKey);
+  if (fileKey) {
+    const scheme = file?.scheme === 'api-key' ? 'api-key' : 'auth-token';
+    return { value: fileKey, scheme, source: 'ukit-gateway-json' };
+  }
+  const envKey = pickString(env?.UKIT_DECISION_API_KEY);
+  if (envKey) return { value: envKey, scheme: 'auth-token', source: 'env' };
+  const shared = resolveGatewayApiKey({ projectRoot, homeDir, env });
+  if (shared?.value) return { ...shared, source: 'shared-unic-token' };
+  return { value: null, scheme: null, source: null };
+}
+
 function readSettingsEnvBlock(filePath) {
   const json = safeReadJson(filePath);
   if (!json || typeof json !== 'object') return null;
@@ -422,13 +463,13 @@ function readMergedConfig(rootDir, homeDir) {
 
 // ---------------------------------------------------------------------------
 // Client core — mirror of src/decision/client.js semantics minus the circuit
-// breaker (a one-shot CLI has no cross-request state to protect).
-// ---------------------------------------------------------------------------
-
 const DEFAULT_CHECKPOINTS = {
-  default: 'unic-decision/laya-multilingual',
-  english: 'unic-decision/laya',
-  unknownLanguage: 'unic-decision/auto',
+  // 'unic-decision-multilingual' is credential-bound (verified live
+  // 2026-09-26) and is the shipped default; english/unknown classes keep the
+  // bare 'unic-decision' alias until laya/auto variants are bound.
+  default: 'unic-decision-multilingual',
+  english: 'unic-decision',
+  unknownLanguage: 'unic-decision',
 };
 
 const DEFAULT_TIMEOUT_MS = 5000;
@@ -466,9 +507,44 @@ function isTransientStatus(status) {
   return status === 429 || (status >= 500 && status <= 599);
 }
 
+// The UNIC decision endpoint streams the completion even without stream:true —
+// the body is one JSON object followed by an SSE "data: [DONE]" trailer.
+// Parse the first JSON object, ignore the trailer.
+function parseMaybeSse(text) {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed.startsWith('{')) {
+    // Pure SSE frames: join data payloads.
+    const payload = trimmed
+      .split('\n')
+      .filter((line) => line.startsWith('data:') && !line.includes('[DONE]'))
+      .map((line) => line.slice(5).trim())
+      .join('');
+    return JSON.parse(payload || trimmed);
+  }
+  // JSON object possibly followed by a glued SSE trailer (`}data: [DONE]`,
+  // observed live) — extract the balanced object, strings/comments aware.
+  let depth = 0;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const ch = trimmed[i];
+    if (ch === '"' || ch === "'") {
+      for (let j = i + 1; j < trimmed.length; j += 1) {
+        if (trimmed[j] === '\\') j += 1;
+        else if (trimmed[j] === ch) { i = j; break; }
+      }
+      continue;
+    }
+    if (ch === '{') depth += 1;
+    else if (ch === '}') {
+      depth -= 1;
+      if (depth === 0) return JSON.parse(trimmed.slice(0, i + 1));
+    }
+  }
+  return JSON.parse(trimmed);
+}
+
 async function readResponseBody(res) {
+  if (res && typeof res.text === 'function') return parseMaybeSse(await res.text());
   if (res && typeof res.json === 'function') return res.json();
-  if (res && typeof res.text === 'function') return JSON.parse(await res.text());
   return res;
 }
 
@@ -574,14 +650,14 @@ export async function requestBatch(batch, {
     return outcome('blocked-sensitive', { checkpoint });
   }
 
-  const base = resolveGatewayBaseUrl({ projectRoot, homeDir, env });
+  const base = resolveDecisionBaseUrl({ homeDir, env });
   if (!base?.baseUrl) {
     return outcome('unsupported', {
       fallbackCode: 'endpoint-unconfigured',
       checkpoint,
     });
   }
-  const key = resolveGatewayApiKey({ projectRoot, homeDir, env });
+  const key = resolveDecisionApiKey({ projectRoot, homeDir, env });
   const endpoint = {
     url: `${String(base.baseUrl).replace(/\/+$/, '')}/v1/chat/completions`,
     headers: buildAuthHeaders(key),
@@ -621,6 +697,26 @@ export async function requestBatch(batch, {
 
     const status = res?.status ?? (res?.ok === false ? 500 : 200);
     if (res?.ok === false || status < 200 || status >= 300) {
+      // A variant checkpoint without bound credentials (e.g.
+      // unic-decision-multilingual before provider binding) returns a 4xx
+      // model_not_found body — retry once on the bare `unic-decision` model.
+      if (checkpoint !== 'unic-decision') {
+        let notFound = status === 404;
+        try {
+          const clone = typeof res?.clone === 'function' ? res.clone() : null;
+          const errBody = clone ? parseMaybeSse(await clone.text()) : null;
+          if (errBody?.error?.code === 'model_not_found') notFound = true;
+        } catch { /* keep status-based guess */ }
+        if (notFound) {
+          checkpoint = 'unic-decision';
+          try {
+            body = JSON.stringify(
+              encodeBatch({ model: checkpoint, statePacket: serialized, questions }),
+            );
+          } catch { /* keep prior body */ }
+          continue;
+        }
+      }
       if (isTransientStatus(status) && attempt + 1 < maxAttempts) continue;
       if (status === 401 || status === 403) {
         lastError = 'unavailable';
@@ -680,9 +776,9 @@ export async function runHealthProbe({
   const dp = decisionPlaneConfig(config);
   if (dp.enabled === false) return { status: 'unavailable' };
   if (!transport) return { status: 'unsupported' };
-  const base = resolveGatewayBaseUrl({ projectRoot, homeDir, env });
+  const base = resolveDecisionBaseUrl({ homeDir, env });
   if (!base?.baseUrl) return { status: 'unsupported', fallbackCode: 'endpoint-unconfigured' };
-  const key = resolveGatewayApiKey({ projectRoot, homeDir, env });
+  const key = resolveDecisionApiKey({ projectRoot, homeDir, env });
   const checkpoint = resolveCheckpoint('multilingual', config);
   const timeoutMs = Number.isFinite(dp.timeoutMs) ? dp.timeoutMs : DEFAULT_TIMEOUT_MS;
   const body = JSON.stringify({