nubos-pilot 1.2.4 → 1.3.1

package/CHANGELOG.md

@@ -4,7 +4,21 @@ All notable changes to nubos-pilot are documented in this file. Format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning
 follows [SemVer](https://semver.org/spec/v2.0.0.html).
 
-## [1.2.4] - 2026-06-15
+## [1.3.0] — 2026-06-17
+
+Run any agent on any model, not only Claude.
+
+- Per-agent model routing: two new config blocks, `model_providers` and `agent_routing`, send each agent to a specific model in the same run — planner on Claude opus, critic on OpenAI gpt-4o, executor on a local Ollama model. Any provider that speaks the OpenAI `/v1/chat/completions` dialect (OpenAI, xAI/Grok, Ollama, vLLM, LM Studio, LiteLLM) is reached through one `fetch`-based client, with no SDK added. Both blocks are optional; without them, resolution and spawning behave exactly as before.
+- When the host can't route an agent to a non-native model — Claude Code's Agent tool only accepts Claude tiers — nubos-pilot runs the loop itself. It's a one-shot, zero-dependency tool-use harness: builds the prompt from `agents/<name>.md`, advertises the agent's tools as function schemas, runs the model's tool-calls against the workspace, and loops until a final answer. No daemon, the process exits when the loop returns.
+- The off-host path runs through the same guards as the Claude path: working-tree safety, commit-policy, output-schema lint, the Nubosloop Rule-9 audit, and in-session security review, all unchanged. Off-host file writes are confined through `safe-path`. Off-host Bash runs only inside a slice worktree and stays off until `workflow.worktree_isolation` is on.
+- Every workflow spawn now has an off-host branch — execute, plan, discuss, research, architect, validate, verify, scan. A test (`check-offhost-coverage`) walks the workflows and fails the suite if any spawn lacks one, so a new agent can't ship Claude-only by accident.
+- A preflight runs before any off-host spawn and fails loud: it checks the server is reachable, the model is present, and tool-calling works, then aborts with an actionable message (`run: ollama pull <model>`) instead of dying mid-task. A routing entry that names an undefined provider is a hard config error at load time, never a quiet fallback to Claude.
+
+Local models are weaker at multi-step tool-use than frontier Claude, so keep high-risk agents like the planner and security-reviewer on Claude — that's why the whole thing is opt-in. ADR-0021 has the full design.
+
+Full documentation at <https://pilot.nubos.cloud>.
+
+## [1.2.4] — 2026-06-15
 
 Fixed a recursion fault in the in-session hooks that could spawn an unbounded cascade of headless `claude -p` processes.
 
@@ -12,6 +26,8 @@ Fixed a recursion fault in the in-session hooks that could spawn an unbounded ca
 - Three independent guards back this up: the hook scripts and the `security`/`learnings` backends exit early when `NUBOS_PILOT_HEADLESS` is set; `spawn-headless` refuses to start a nested headless run (reentrancy + depth cap, default one level); and a per-agent lockfile under `.nubos-pilot/run/` bounds concurrent headless runs to one per agent even if the environment is not inherited. Headless runs already carry a hard timeout with SIGKILL, so a hung review cannot linger.
 - Escape hatch: the guard keys off `NUBOS_PILOT_HEADLESS`, set automatically on the spawned `claude` — do not set it in your own shell or the in-session hooks will silently no-op. Raise the depth cap with `NUBOS_PILOT_MAX_HOOK_DEPTH` only if you understand the recursion risk.
 
+Full documentation at <https://pilot.nubos.cloud>.
+
 ## [1.2.3] — 2026-06-14
 
 Three opt-in layers that make execution cheaper, more reliable, and self-improving.

package/README.md

@@ -95,7 +95,7 @@ task(M001-S001-T0002): wire login handler
 
 ## Agents
 
-Thirteen spawnable subagents are installed into the host's agent directory (alongside three `np-critic-*` audit modules consumed by `np-critic`):
+Fourteen spawnable subagents are installed into the host's agent directory (alongside three `np-critic-*` audit modules consumed by `np-critic`):
 
 - `np-planner` (opus) — breaks a milestone into slices + tasks
 - `np-plan-checker` (opus) — adversarial goal-backward review before execution
@@ -109,6 +109,7 @@ Thirteen spawnable subagents are installed into the host's agent directory (alon
 - `np-critic` (sonnet) — Nubosloop critic; audits executor output across style, tests and acceptance
 - `np-verifier` (sonnet) — post-execution Pass/Fail/Defer per success_criterion
 - `np-nyquist-auditor` (haiku) — requirement test-coverage audit
+- `np-learnings-extractor` (haiku) — headless continuous-learning observer; distils reusable `{pattern, outcome}` learnings from a session's turn-diff
 - `np-security-reviewer` (sonnet) — OWASP-aligned read-only audit (manual spawn)
 
 Every spawn runs with an **explicit tier** (`haiku` / `sonnet` / `opus`) resolved to a concrete model via `np-tools.cjs resolve-model --profile <frontier|quality|balanced|budget|inherit>`.

package/SECURITY.md

@@ -18,11 +18,10 @@ versions and announced in `CHANGELOG.md`.
 
 | Version | Supported |
 |---------|-----------|
-| 0.2.x   | ✅ active |
-| < 0.2   | ❌ end of life |
+| 1.3.x   | ✅ active |
+| < 1.3   | ❌ end of life |
 
-Only the latest minor on the current major receives security patches until
-1.0 is reached.
+Only the latest minor on the current major (1.x) receives security patches.
 
 ## Threat Model
 

package/bin/np-tools/_commands.cjs

@@ -89,6 +89,8 @@ const COMMANDS = [
   { name: 'knowledge-index',         category: 'Utility', description: 'Build BM25-light index over .nubos-pilot/**/*.md → .nubos-pilot/state/knowledge-index.json', description_de: 'Baut BM25-Light-Index über .nubos-pilot/**/*.md → .nubos-pilot/state/knowledge-index.json' },
   { name: 'knowledge-search',        category: 'Utility', description: 'Query the knowledge index; returns top-N JSON hits (rel_path + lines + score + preview). Pass --task <id> inside a Nubosloop task to record Rule 9 audit evidence', description_de: 'Sucht im Knowledge-Index; liefert Top-N-JSON-Treffer (rel_path + Zeilen + Score + Preview). --task <id> innerhalb eines Nubosloop-Tasks schreibt den Rule-9-Audit-Nachweis' },
   { name: 'knowledge-stats',         category: 'Utility', description: 'Print knowledge-index size + grouping (auto-builds if missing)', description_de: 'Gibt Knowledge-Index-Größe + Gruppierung aus (baut auto bei Fehlen)' },
+  { name: 'elision-get',             category: 'Utility', description: 'Retrieve the original text behind a ⟦elided:<hash>⟧ compression marker. Reversible context compression (ADR-Elision). Positional <hash> or --hash; --json for envelope', description_de: 'Holt den Originaltext hinter einem ⟦elided:<hash>⟧ Kompressions-Marker. Reversible Kontext-Kompression (ADR-Elision). Positional <hash> oder --hash; --json für Envelope' },
+  { name: 'elision-bench',           category: 'Utility', description: 'Measure elision compression: deterministic fidelity (ratio + critical-line preservation + byte-exact reversibility) over a fixture corpus; --with-model adds answer-equivalence (raw vs compressed). --size <small|medium|large> runs a scaled corpus with a deterministic --holdout control group (--max-cases N) and an estimated token saving (--price-per-mtok <p> [--currency EUR] adds a cost estimate). --json, --tier <name>', description_de: 'Misst die Elision-Kompression: deterministische Fidelity (Ratio + Erhalt kritischer Zeilen + byte-exakte Reversibilität) über ein Fixture-Korpus; --with-model ergänzt Antwort-Äquivalenz (roh vs. komprimiert). --size <small|medium|large> fährt ein skaliertes Korpus mit deterministischer --holdout-Kontrollgruppe (--max-cases N) und geschätzter Token-Ersparnis (--price-per-mtok <p> [--currency EUR] ergänzt eine Kostenschätzung). --json, --tier <name>' },
   { name: 'context-stats',           category: 'Utility', description: 'Aggregated context-budget stats (file counts + bytes per group, knowledge-index size)', description_de: 'Aggregierte Context-Budget-Stats (Dateien/Bytes pro Gruppe, Knowledge-Index-Größe)' },
   { name: 'session-snapshot-write',  category: 'Utility', description: 'Capture session snapshot (current_task + recent commits + open handoffs) for resume', description_de: 'Erfasst Session-Snapshot (current_task + letzte Commits + offene Handoffs) für Resume' },
   { name: 'session-snapshot-read',   category: 'Utility', description: 'Print last session snapshot as JSON', description_de: 'Gibt letzten Session-Snapshot als JSON aus' },
@@ -101,6 +103,7 @@ const COMMANDS = [
   { name: 'loop-audit-tool-use',     category: 'Execution', description: 'Record/read the tool-use audit per spawn (Completeness Rule 9 mechanical check)', description_de: 'Tool-use Audit pro Spawn schreiben/lesen (Completeness Rule 9 mechanische Prüfung)' },
   { name: 'loop-stuck',              category: 'Execution', description: 'Mark a task as stuck (writes loop-state + flips checkpoint status to stuck)', description_de: 'Markiert Task als stuck (schreibt Loop-State + setzt Checkpoint-Status auf stuck)' },
   { name: 'spawn-headless',          category: 'Execution', description: 'Spawn an agent as a headless `claude -p` subprocess (ADR-0010 §L6); writes stdout to --output-path and returns exit code', description_de: 'Spawnt einen Agent als headless `claude -p` Subprozess (ADR-0010 §L6); schreibt stdout nach --output-path und liefert Exit-Code' },
+  { name: 'spawn-offhost',           category: 'Execution', description: 'Run an agent routed to an openai-compat provider (Ollama/OpenAI/Grok) as a one-shot tool-use loop (ADR-0021). Args: --agent --task|--task-file [--allow-bash] [--read-only]. Preflights the endpoint, records metrics.', description_de: 'Führt einen auf einen openai-compat-Provider (Ollama/OpenAI/Grok) gerouteten Agent als One-Shot-Tool-Use-Loop aus (ADR-0021). Args: --agent --task|--task-file [--allow-bash] [--read-only]. Preflight des Endpoints, Metrics-Aufzeichnung.' },
   { name: 'security',                category: 'Review',    description: 'In-session security review hook backend (ADR-0020). Verbs: session-start | baseline | scan | review | commit | run-review. Reads the Claude Code hook payload via --stdin; non-blocking, report-once, independent reviewer spawn.', description_de: 'Backend für die In-Session-Security-Review-Hooks (ADR-0020). Verben: session-start | baseline | scan | review | commit | run-review. Liest die Claude-Code-Hook-Payload via --stdin; non-blocking, report-once, unabhängiger Reviewer-Spawn.' },
   { name: 'loop-metrics',            category: 'Utility',   description: 'Aggregate Nubosloop telemetry across all checkpoints (commits, stuck, route distribution)', description_de: 'Aggregiert Nubosloop-Telemetrie über alle Checkpoints (Commits, Stuck, Routing)' },
   { name: 'learning-log',            category: 'Execution', description: 'Persist a learning to the local store (or MCP adapter when configured)', description_de: 'Persistiert ein Learning im lokalen Store (oder MCP-Adapter falls konfiguriert)' },

package/bin/np-tools/_elision-proxy-entry.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const proxy = require('../../lib/elision-proxy.cjs');
+
+proxy.start({
+  cwd: process.env.ELISION_PROXY_CWD || process.cwd(),
+  upstream: process.env.ELISION_PROXY_UPSTREAM || undefined,
+}).then(({ baseUrl }) => {
+  if (process.send) process.send({ ready: true, baseUrl });
+}).catch((err) => {
+  if (process.send) process.send({ ready: false, error: String(err && err.message) });
+  process.exit(1);
+});

package/bin/np-tools/elision-bench.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const bench = require('../../lib/elision-bench.cjs');
+
+function _parseArgs(args) {
+  const out = { json: false, withModel: false, tier: 'frontier', size: null, holdout: 0.2, maxCases: null, charsPerToken: null, pricePerMTok: null, currency: null };
+  for (let i = 0; i < (args || []).length; i += 1) {
+    const a = args[i];
+    if (a === '--json') { out.json = true; continue; }
+    if (a === '--with-model') { out.withModel = true; continue; }
+    if (a === '--tier') { out.tier = args[++i] || out.tier; continue; }
+    if (a === '--size') { out.size = args[++i] || out.size; continue; }
+    if (a === '--holdout') { const v = parseFloat(args[++i]); if (Number.isFinite(v)) out.holdout = v; continue; }
+    if (a === '--max-cases') { const v = parseInt(args[++i], 10); if (Number.isFinite(v)) out.maxCases = v; continue; }
+    if (a === '--chars-per-token') { const v = parseFloat(args[++i]); if (Number.isFinite(v)) out.charsPerToken = v; continue; }
+    if (a === '--price-per-mtok') { const v = parseFloat(args[++i]); if (Number.isFinite(v)) out.pricePerMTok = v; continue; }
+    if (a === '--currency') { out.currency = args[++i] || out.currency; continue; }
+  }
+  return out;
+}
+
+async function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+
+  if (parsed.size) {
+    const scale = bench.runScale({ cwd, size: parsed.size, holdoutRatio: parsed.holdout, maxCases: parsed.maxCases, charsPerToken: parsed.charsPerToken, pricePerMTok: parsed.pricePerMTok, currency: parsed.currency });
+    stdout.write((parsed.json ? JSON.stringify({ scale }) : bench.formatScale(scale)) + '\n');
+    return scale.summary.invariants_ok ? 0 : 1;
+  }
+
+  const fidelity = bench.runFidelity({ cwd });
+  let equivalence = null;
+
+  if (parsed.withModel) {
+    const { resolveFromConfig } = require('./resolve-model.cjs');
+    const { chat } = require('../../lib/runtime/providers/openai-compat.cjs');
+    const res = resolveFromConfig({ agentOrTier: parsed.tier, cwd, format: 'json' });
+    if (!res || !res.model || !res.baseUrl) {
+      stdout.write((parsed.json ? JSON.stringify({ fidelity, equivalence: null, error: 'no-provider' }) : 'No off-host provider resolved for tier "' + parsed.tier + '" — equivalence skipped.') + '\n');
+      return fidelity.summary.invariants_ok ? 0 : 1;
+    }
+    const provider = { baseUrl: res.baseUrl, apiKeyEnv: res.apiKeyEnv, model: res.model };
+    equivalence = await bench.runEquivalence({ chatImpl: chat, provider });
+  }
+
+  if (parsed.json) {
+    stdout.write(JSON.stringify({ fidelity, equivalence }) + '\n');
+  } else {
+    stdout.write(bench.formatReport(fidelity) + '\n');
+    if (equivalence) {
+      stdout.write('\nAnswer equivalence — ' + equivalence.summary.equivalent + '/' + equivalence.summary.cases
+        + ' equivalent, regressions: ' + (equivalence.summary.regressions.length ? equivalence.summary.regressions.join(', ') : 'none') + '\n');
+      for (const c of equivalence.cases) {
+        stdout.write('  ' + (c.regression ? '✗' : '✓') + ' ' + c.name + ' (raw '
+          + (c.raw_ok ? 'ok' : 'miss') + ', compressed ' + (c.compressed_ok ? 'ok' : 'miss') + ')\n');
+      }
+    }
+  }
+
+  const ok = fidelity.summary.invariants_ok && (!equivalence || equivalence.summary.no_regression);
+  return ok ? 0 : 1;
+}
+
+module.exports = { run, _parseArgs };

package/bin/np-tools/elision-get.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const elision = require('../../lib/elision.cjs');
+
+function _parseArgs(args) {
+  const out = { hash: null, json: false };
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--hash') { out.hash = args[++i] || null; continue; }
+    if (a === '--json') { out.json = true; continue; }
+    positional.push(a);
+  }
+  if (out.hash == null) out.hash = positional.join('').trim() || null;
+  return out;
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const parsed = _parseArgs(args || []);
+  if (!parsed.hash) {
+    throw new NubosPilotError(
+      'elision-get-missing-hash',
+      'elision-get requires a hash (positional or --hash)',
+      { hint: 'hash is the 12-char id from a ⟦elided:…⟧ marker' },
+    );
+  }
+  const result = elision.retrieve(parsed.hash, cwd);
+  if (parsed.json) {
+    stdout.write(JSON.stringify(result));
+    return result.status === 'ok' ? 0 : 1;
+  }
+  if (result.status === 'ok') {
+    stdout.write(result.original);
+    return 0;
+  }
+  if (result.status === 'expired') {
+    stdout.write('[elision ' + parsed.hash + ' expired — original no longer cached (ttl elapsed)]\n');
+    return 1;
+  }
+  stdout.write('[elision ' + parsed.hash + ' not found]\n');
+  return 1;
+}
+
+module.exports = { run, _parseArgs };

package/bin/np-tools/elision-get.test.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const elisionGet = require('./elision-get.cjs');
+const elision = require('../../lib/elision.cjs');
+const { NubosPilotError } = require('../../lib/core.cjs');
+
+function sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-elisionget-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  return root;
+}
+
+function capture() {
+  const chunks = [];
+  return { stream: { write: (s) => chunks.push(s) }, text: () => chunks.join('') };
+}
+
+test('ELISIONGET-1: prints the original for a known hash', () => {
+  const root = sandbox();
+  try {
+    const hash = elision.store('the original payload', { type: 'plain' }, root);
+    const out = capture();
+    const code = elisionGet.run([hash], { cwd: root, stdout: out.stream });
+    assert.equal(code, 0);
+    assert.equal(out.text(), 'the original payload');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISIONGET-2: unknown hash exits 1 with a not-found notice', () => {
+  const root = sandbox();
+  try {
+    const out = capture();
+    const code = elisionGet.run(['aaaaaaaaaaaa'], { cwd: root, stdout: out.stream });
+    assert.equal(code, 1);
+    assert.match(out.text(), /not found/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISIONGET-3: --json emits the retrieval envelope', () => {
+  const root = sandbox();
+  try {
+    const hash = elision.store('payload', { type: 'plain' }, root);
+    const out = capture();
+    const code = elisionGet.run([hash, '--json'], { cwd: root, stdout: out.stream });
+    assert.equal(code, 0);
+    const env = JSON.parse(out.text());
+    assert.equal(env.status, 'ok');
+    assert.equal(env.original, 'payload');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISIONGET-4: missing hash throws', () => {
+  assert.throws(() => elisionGet.run([], { cwd: process.cwd(), stdout: { write() {} } }), NubosPilotError);
+});

package/bin/np-tools/learnings.cjs

@@ -90,7 +90,7 @@ async function run(argv, ctx) {
   if (verb === 'run-extract') {
     const sid = args.getFlag(list, '--session') || '';
     try {
-      const result = extract.runExtract({ cwd, sid, config: cfg });
+      const result = await extract.runExtract({ cwd, sid, config: cfg });
       _emit(stdout, result);
     } catch (err) {
       _emit(stdout, { ran: false, reason: 'error', error: String(err && err.code || err) });

package/bin/np-tools/loop-run-round.cjs

@@ -6,16 +6,37 @@ const path = require('node:path');
 const { NubosPilotError, safeAssign } = require('../../lib/core.cjs');
 const safePath = require('../../lib/safe-path.cjs');
 
-function _resolveInsideCwdOrTmp(p, cwd, label, errorCode) {
-  return safePath.assertInsideCwdOrTmp(p, cwd, label, errorCode);
-}
 const checkpoint = require('../../lib/checkpoint.cjs');
 const nubosloop = require('../../lib/nubosloop.cjs');
 const messaging = require('../../lib/messaging.cjs');
+const compress = require('../../lib/compress.cjs');
+const elision = require('../../lib/elision.cjs');
+const logger = require('../../lib/logger.cjs').child('loop-run-round');
 const args = require('./_args.cjs');
 
 const { TASK_ID_RE } = require('../../lib/ids.cjs');
 
+function _resolveInsideCwdOrTmp(p, cwd, label, errorCode) {
+  return safePath.assertInsideCwdOrTmp(p, cwd, label, errorCode);
+}
+
+function _verifyExcerpt(verifyOutput, cwd) {
+  const s = String(verifyOutput);
+  const cx = elision.compressionContext(cwd);
+  const maxBytes = cx.verifyMaxBytes;
+  if (s.length <= maxBytes) return s;
+  if (cx.enabled) {
+    try {
+      const crushed = compress.crushLogToBudget(s, maxBytes);
+      if (crushed && crushed.length < s.length) {
+        const hash = cx.store ? cx.store(s, 'log') : null;
+        return crushed + (hash ? '\n' + compress.marker(hash, 'full verify log') : '');
+      }
+    } catch (err) { logger.warn('verify compression skipped', { cause: err && err.message }); }
+  }
+  return '…[truncated head, original ' + s.length + ' bytes — see VERIFY_LOG]\n' + s.slice(-maxBytes);
+}
+
 const VALID_PHASES = new Set([
   'preflight',
   'post-researcher',
@@ -182,16 +203,9 @@ function _runPostExecutor(taskId, list, cwd) {
     }
   }
   const green = code === 0;
-  const VERIFY_TAIL_BYTES = 2000;
   let verifyExcerpt = null;
   if (verifyOutput) {
-    const s = String(verifyOutput);
-    if (s.length > VERIFY_TAIL_BYTES) {
-      verifyExcerpt = '…[truncated head, original ' + s.length + ' bytes — see VERIFY_LOG]\n'
-        + s.slice(-VERIFY_TAIL_BYTES);
-    } else {
-      verifyExcerpt = s;
-    }
+    verifyExcerpt = _verifyExcerpt(verifyOutput, cwd);
   }
   const merged = checkpoint.mergeCheckpoint(
     taskId,

package/bin/np-tools/plan-milestone.cjs

@@ -95,6 +95,7 @@ async function _initPayload(mNum, cwd, opts) {
     const spawnSpecs = swarm.buildSpawnSpecs(
       { milestone: mNum, milestone_id: layout.mId(mNum), goal: def.goal || '' },
       swarmOpts.k,
+      { cwd },
     );
     let cacheHit = null;
     let cacheMiss = null;

package/bin/np-tools/research-phase.cjs

@@ -107,7 +107,7 @@ async function run(args, ctx) {
   const tmDetail = textMode.resolveTextModeDetail(cwd);
 
   const swarmOpts = swarm.resolveSwarmOpts(cwd);
-  const spawnSpecs = swarm.buildSpawnSpecs({ milestone: mNum, milestone_id: mIdStr, goal: def.goal || '' }, swarmOpts.k);
+  const spawnSpecs = swarm.buildSpawnSpecs({ milestone: mNum, milestone_id: mIdStr, goal: def.goal || '' }, swarmOpts.k, { cwd });
 
   let cacheHit = null;
   let cacheMiss = null;

package/bin/np-tools/resolve-model.cjs

@@ -2,6 +2,7 @@ const { NubosPilotError } = require('../../lib/core.cjs');
 const { readConfig, _CONFIG_PARSE_CODES } = require('../../lib/config.cjs');
 const { loadAgent, loadAgentModule } = require('../../lib/agents.cjs');
 const { resolve: resolveAlias, MODEL_ALIAS_MAP, VALID_TIERS } = require('../../lib/model-profiles.cjs');
+const { resolveProvider } = require('../../lib/model-providers.cjs');
 
 let _warnedCorruptOnce = false;
 function _readConfig(cwd) {
@@ -56,11 +57,13 @@ function resolveFromConfig({ agentOrTier, profileOverride, cwd, format }) {
   const config = _readConfig(cwd);
 
   let tier;
+  let agentName = null;
   if (VALID_TIERS.includes(agentOrTier)) {
     tier = agentOrTier;
   } else {
     const fm = _loadAgentForResolve(agentOrTier, cwd);
     tier = fm.tier;
+    agentName = agentOrTier;
     const override = _criticTierOverride(config, agentOrTier);
     if (override) tier = override;
   }
@@ -91,7 +94,32 @@ function resolveFromConfig({ agentOrTier, profileOverride, cwd, format }) {
     resolved = alias;
   }
 
-  return { tier, profile, alias, resolved, mode };
+  const prov = resolveProvider({ agentName, tier, config });
+  let providerModel = prov.model;
+  if (prov.kind === 'native') {
+    if (prov.model) {
+      resolved = prov.model;
+      mode = 'full-id';
+    } else {
+      providerModel = null;
+    }
+  } else {
+    resolved = prov.model;
+    mode = 'provider';
+  }
+
+  return {
+    tier,
+    profile,
+    alias,
+    resolved,
+    mode,
+    provider: prov.provider,
+    kind: prov.kind,
+    model: providerModel,
+    baseUrl: prov.baseUrl,
+    apiKeyEnv: prov.apiKeyEnv,
+  };
 }
 
 function run(argv) {
@@ -105,12 +133,18 @@ function run(argv) {
   const agentOrTier = args.shift();
   let profileOverride = null;
   let format = null;
+  let asJson = false;
+  let asKind = false;
   while (args.length) {
     const flag = args.shift();
     if (flag === '--profile') {
       profileOverride = args.shift();
     } else if (flag === '--format') {
       format = args.shift();
+    } else if (flag === '--json') {
+      asJson = true;
+    } else if (flag === '--kind') {
+      asKind = true;
     } else if (flag === '--raw') {
 
     }
@@ -122,6 +156,26 @@ function run(argv) {
       cwd: process.cwd(),
       format,
     });
+    if (asKind) {
+      process.stdout.write((out.kind || 'native') + '\n');
+      return 0;
+    }
+    if (asJson) {
+      process.stdout.write(JSON.stringify(out) + '\n');
+      return 0;
+    }
+    if (out.kind === 'openai-compat') {
+      process.stderr.write(
+        JSON.stringify({
+          code: 'off-host-not-on-native-path',
+          message: 'agent "' + agentOrTier + '" routes to provider "' + out.provider
+            + '" (model ' + out.model + '), which the native `claude` spawn path cannot run. '
+            + 'Run it off-host with: np-tools spawn-offhost --agent ' + agentOrTier + ' --task <…>',
+          details: { provider: out.provider, kind: out.kind, model: out.model },
+        }) + '\n',
+      );
+      return 1;
+    }
     process.stdout.write(out.resolved + '\n');
     return 0;
   } catch (err) {

package/bin/np-tools/resolve-model.test.cjs

@@ -72,6 +72,11 @@ test('RM-1: tier branch with empty config returns alias mode, default balanced p
     alias: 'opus',
     resolved: 'opus',
     mode: 'alias',
+    provider: 'claude',
+    kind: 'native',
+    model: null,
+    baseUrl: null,
+    apiKeyEnv: null,
   });
 });
 
@@ -276,3 +281,137 @@ test('RM-18: module agent without override falls back to module frontmatter tier
   });
   assert.equal(out.tier, 'haiku');
 });
+
+test('RM-19: agent_routing to openai-compat resolves model from provider models table by tier', () => {
+  const cwd = _sandbox({
+    model_providers: {
+      default: 'claude',
+      claude: { kind: 'native' },
+      ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'qwen2.5-coder:32b' } },
+    },
+    agent_routing: { 'np-planner': { provider: 'ollama' } },
+  }, { 'np-planner': _plannerAgent });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd });
+  assert.equal(out.provider, 'ollama');
+  assert.equal(out.kind, 'openai-compat');
+  assert.equal(out.model, 'qwen2.5-coder:32b');
+  assert.equal(out.resolved, 'qwen2.5-coder:32b');
+  assert.equal(out.mode, 'provider');
+});
+
+test('RM-20: explicit model pin in agent_routing beats provider models table', () => {
+  const cwd = _sandbox({
+    model_providers: {
+      ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'fallback-model' } },
+    },
+    agent_routing: { 'np-planner': { provider: 'ollama', model: 'qwen3.5' } },
+  }, { 'np-planner': _plannerAgent });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd });
+  assert.equal(out.model, 'qwen3.5');
+  assert.equal(out.resolved, 'qwen3.5');
+});
+
+test('RM-21: native provider with an explicit model pin forces full-id mode', () => {
+  const cwd = _sandbox({
+    model_providers: { claude: { kind: 'native' } },
+    agent_routing: { 'np-planner': { provider: 'claude', model: 'claude-opus-4-7' } },
+  }, { 'np-planner': _plannerAgent });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd });
+  assert.equal(out.kind, 'native');
+  assert.equal(out.resolved, 'claude-opus-4-7');
+  assert.equal(out.mode, 'full-id');
+  assert.equal(out.model, 'claude-opus-4-7');
+});
+
+test('RM-22: glob routing key (np-critic*) matches a critic agent', () => {
+  const cwd = _sandbox({
+    model_providers: { openai: { kind: 'openai-compat', base_url: 'https://api.openai.com/v1', models: { sonnet: 'gpt-4o' } } },
+    agent_routing: { 'np-critic*': { provider: 'openai', model: 'gpt-4o' } },
+  }, { 'np-critic': '---\nname: np-critic\ndescription: x\ntier: sonnet\ntools: Read\n---\nbody' });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'np-critic', cwd });
+  assert.equal(out.provider, 'openai');
+  assert.equal(out.model, 'gpt-4o');
+});
+
+test('RM-23: routing to an undefined provider fails loud (no silent claude fallback)', () => {
+  const cwd = _sandbox({
+    model_providers: { claude: { kind: 'native' } },
+    agent_routing: { 'np-planner': { provider: 'ollama' } },
+  }, { 'np-planner': _plannerAgent });
+  let thrown = null;
+  try { subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd }); } catch (e) { thrown = e; }
+  assert.ok(thrown);
+  assert.equal(thrown.name, 'NubosPilotError');
+  assert.equal(thrown.code, 'provider-undefined');
+});
+
+test('RM-24: openai-compat with no pin and no models[tier] fails loud', () => {
+  const cwd = _sandbox({
+    model_providers: { ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { haiku: 'small' } } },
+    agent_routing: { 'np-planner': { provider: 'ollama' } },
+  }, { 'np-planner': _plannerAgent });
+  let thrown = null;
+  try { subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd }); } catch (e) { thrown = e; }
+  assert.ok(thrown);
+  assert.equal(thrown.code, 'provider-model-unresolved');
+});
+
+test('RM-25: bare tier never routes — stays on implicit claude-native default', () => {
+  const cwd = _sandbox({
+    model_providers: { ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'qwen' } } },
+    agent_routing: { opus: { provider: 'ollama' } },
+  });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'opus', cwd });
+  assert.equal(out.provider, 'claude');
+  assert.equal(out.kind, 'native');
+  assert.equal(out.resolved, 'opus');
+});
+
+test('RM-27: run() refuses an off-host (openai-compat) agent loud — no model id on stdout', () => {
+  const root = _sandbox({
+    model_providers: { ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'qwen2.5-coder:32b' } } },
+    agent_routing: { 'np-planner': { provider: 'ollama' } },
+  }, { 'np-planner': _plannerAgent });
+  const origCwd = process.cwd();
+  process.chdir(root);
+  try {
+    const cap = _captureStdout(() => subcmd.run(['np-planner']));
+    assert.equal(cap.rc, 1);
+    assert.equal(cap.stdout, '');
+    assert.match(cap.stderr, /off-host-not-on-native-path/);
+    assert.match(cap.stderr, /spawn-offhost/);
+  } finally {
+    process.chdir(origCwd);
+  }
+});
+
+test('RM-28: --json reports the full resolution and succeeds even for off-host', () => {
+  const root = _sandbox({
+    model_providers: { ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'qwen2.5-coder:32b' } } },
+    agent_routing: { 'np-planner': { provider: 'ollama' } },
+  }, { 'np-planner': _plannerAgent });
+  const origCwd = process.cwd();
+  process.chdir(root);
+  try {
+    const cap = _captureStdout(() => subcmd.run(['np-planner', '--json']));
+    assert.equal(cap.rc, 0);
+    const out = JSON.parse(cap.stdout.trim());
+    assert.equal(out.kind, 'openai-compat');
+    assert.equal(out.provider, 'ollama');
+    assert.equal(out.baseUrl, 'http://localhost:11434/v1');
+  } finally {
+    process.chdir(origCwd);
+  }
+});
+
+test('RM-26: model_providers.default switches the default provider for all agents', () => {
+  const cwd = _sandbox({
+    model_providers: {
+      default: 'ollama',
+      ollama: { kind: 'openai-compat', base_url: 'http://localhost:11434/v1', models: { opus: 'qwen2.5-coder:32b' } },
+    },
+  }, { 'np-planner': _plannerAgent });
+  const out = subcmd.resolveFromConfig({ agentOrTier: 'np-planner', cwd });
+  assert.equal(out.provider, 'ollama');
+  assert.equal(out.model, 'qwen2.5-coder:32b');
+});

package/bin/np-tools/security.cjs

@@ -170,7 +170,7 @@ async function run(argv, ctx) {
   if (verb === 'run-review') {
     if (!cfg.enabled || !sid) return 0;
     const mode = args.getFlag(list, '--mode') === 'commit' ? 'commit' : 'stop';
-    try { review.runReview({ cwd, sid, mode, config: { ...cfg, guidance_path: _resolveRel(cwd, cfg.guidance_path) } }); } catch {}
+    try { await review.runReview({ cwd, sid, mode, config: { ...cfg, guidance_path: _resolveRel(cwd, cfg.guidance_path) } }); } catch {}
     return 0;
   }