ghost-dragon 4.2.1

package/dist/brain/router/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Ghost Router — the spine of the multi-model stack (ROUTER-BLUEPRINT.md §1).
+ *
+ * It IS a Brain, so the agent loop stays unchanged: every turn it classifies the
+ * request (intent × difficulty × stakes), selects the best {provider, model} for
+ * 8 GB, then DELEGATES to that underlying brain. The factory is injected as
+ * `resolve` to avoid a circular import with brain/index.ts.
+ *
+ * Each decision is appended to ~/.dragon/routing.jsonl (observability + the
+ * DragonSpark flywheel) and shown to the operator on stderr (silence with
+ * DRAGON_ROUTER_QUIET=1).
+ *
+ * MVP scope: single-hop selection over the resident Ollama models + Claude
+ * escalation. The reason→tool two-hop and llama-swap co-residency are later phases.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { Brain } from '../types.js';
+export interface RouterOpts {
+    /** Factory injected by brain/index.ts to avoid a circular import. */
+    resolve: (provider: string, model?: string) => Brain;
+    /** Ollama base (…/v1) used for embeddings + tags/ps lookups. */
+    localBaseURL: string;
+}
+export declare function makeRouterBrain(opts: RouterOpts): Brain;
+//# sourceMappingURL=index.d.ts.map

package/dist/brain/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/brain/router/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAAE,KAAK,EAAuB,MAAM,aAAa,CAAA;AAoB7D,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,KAAK,CAAA;IACpD,gEAAgE;IAChE,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CA4EvD"}

package/dist/brain/router/index.js

@@ -0,0 +1,118 @@
+/**
+ * Ghost Router — the spine of the multi-model stack (ROUTER-BLUEPRINT.md §1).
+ *
+ * It IS a Brain, so the agent loop stays unchanged: every turn it classifies the
+ * request (intent × difficulty × stakes), selects the best {provider, model} for
+ * 8 GB, then DELEGATES to that underlying brain. The factory is injected as
+ * `resolve` to avoid a circular import with brain/index.ts.
+ *
+ * Each decision is appended to ~/.dragon/routing.jsonl (observability + the
+ * DragonSpark flywheel) and shown to the operator on stderr (silence with
+ * DRAGON_ROUTER_QUIET=1).
+ *
+ * MVP scope: single-hop selection over the resident Ollama models + Claude
+ * escalation. The reason→tool two-hop and llama-swap co-residency are later phases.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { classify } from './classify.js';
+import { selectTarget } from './select.js';
+import { verifyReasoning } from './verify.js';
+import { twoHop } from './two-hop.js';
+const ROUTE_LOG = process.env.DRAGON_ROUTING_LOG || join(homedir(), '.dragon', 'routing.jsonl');
+function logDecision(rec) {
+    try {
+        mkdirSync(join(homedir(), '.dragon'), { recursive: true });
+        appendFileSync(ROUTE_LOG, JSON.stringify({ ts: new Date().toISOString(), ...rec }) + '\n');
+    }
+    catch { /* best-effort */ }
+}
+function show(line) {
+    if (process.env.DRAGON_ROUTER_QUIET === '1')
+        return;
+    try {
+        process.stderr.write(`\x1b[2m⟐ ${line}\x1b[0m\n`);
+    }
+    catch { /* ignore */ }
+}
+export function makeRouterBrain(opts) {
+    const cache = new Map();
+    const get = (provider, model) => {
+        const safe = provider === 'router' ? 'local' : provider; // never recurse
+        const key = `${safe}:${model ?? ''}`;
+        let b = cache.get(key);
+        if (!b) {
+            b = opts.resolve(safe, model);
+            cache.set(key, b);
+        }
+        return b;
+    };
+    return {
+        id: 'router',
+        model: 'auto',
+        async turn(t) {
+            const hasTools = t.tools.length > 0;
+            const c = await classify(opts.localBaseURL, t.messages, t.tools.length, t.signal);
+            const target = await selectTarget(c, hasTools, opts.localBaseURL, t.signal);
+            const label = `${target.provider}${target.model ? ':' + target.model : ''}`;
+            const base = {
+                intent: c.intent, difficulty: c.difficulty, stakes: c.stakes, via: c.via,
+                hasTools, provider: target.provider, model: target.model ?? null,
+                swap: target.swap, penalty: target.penalty ?? 0, why: target.why,
+            };
+            // Reason→tool two-hop: the reasoner plans (no tools), the workhorse executes.
+            if (target.twoHop && target.provider === 'local' && target.model && target.reasoner) {
+                show(`router → two-hop: ${target.reasoner} plans → ${target.model} executes  [${c.intent}/${c.difficulty.toFixed(2)}/${c.stakes}]`);
+                try {
+                    const { turn, planChars } = await twoHop(opts.localBaseURL, target.reasoner, target.model, t, get);
+                    show(`  ↳ plan ${planChars} chars → ${turn.toolCalls.length} tool call(s)`);
+                    logDecision({ ...base, twoHop: true, planChars, toolCalls: turn.toolCalls.length });
+                    return turn;
+                }
+                catch (e) {
+                    show(`  ↳ two-hop failed (${e.message}) — single call`);
+                    // Log the failure so routing-memory accrues a penalty (a config where
+                    // two-hop keeps failing — e.g. swap OOM/timeout — adaptively backs off).
+                    logDecision({ ...base, twoHop: true, twoHopFailed: true });
+                }
+            }
+            // Verified hard-reasoning path: best-of-N + vote (+ optional execution check),
+            // then a CONFIDENCE CASCADE — escalate to Claude on low agreement / failed
+            // execution. A model with a bad routing-memory track record escalates sooner.
+            if (target.verify && target.provider === 'local' && target.model) {
+                const votes = Math.max(1, parseInt(process.env.DRAGON_ROUTER_VOTES || '3', 10) || 3);
+                show(`router → ${label} ×${votes} verified  [${c.intent}/${c.difficulty.toFixed(2)}/${c.stakes}]`);
+                try {
+                    const { turn, meta } = await verifyReasoning(opts.localBaseURL, target.model, t, votes);
+                    const execFail = !!(meta.exec?.ran && meta.exec.ok === false);
+                    show(`  ↳ agreement ${meta.agreement ?? 'n/a'} (${meta.votes} votes${meta.exec?.ran ? `, exec ${meta.exec.ok ? 'pass' : 'fail'}` : ''})`);
+                    const floor = parseFloat(process.env.DRAGON_ROUTER_ESCALATE_BELOW || '0.5') || 0.5;
+                    const threshold = Math.min(0.85, floor + (target.penalty ?? 0) * 0.3); // worse history → escalate sooner
+                    const lowConf = meta.agreement != null && meta.agreement < threshold;
+                    if ((lowConf || execFail) && process.env.DRAGON_ROUTER_NO_ESCALATE !== '1') {
+                        try {
+                            const claude = get('claude');
+                            show(`  ↳ ${execFail ? 'execution failed' : `low confidence (${meta.agreement} < ${threshold.toFixed(2)})`} → escalating to Claude`);
+                            const esc = await claude.turn(t);
+                            logDecision({ ...base, verify: meta, escalated: true, reason: execFail ? 'exec-fail' : 'low-agreement', threshold });
+                            return esc;
+                        }
+                        catch { /* Claude unavailable → keep the verified local answer */ }
+                    }
+                    logDecision({ ...base, verify: meta, escalated: false });
+                    return turn;
+                }
+                catch (e) {
+                    show(`  ↳ verify failed (${e.message}) — single call`);
+                }
+            }
+            show(`router → ${label}  [${c.intent}/${c.difficulty.toFixed(2)}/${c.stakes}${target.swap ? ' · swap' : ''}]  ${target.why}`);
+            logDecision(base);
+            return get(target.provider, target.model).turn(t);
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/brain/router/routing-memory.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Routing-memory — negative learning over the router's own history
+ * (ROUTER-BLUEPRINT.md §3, dragon-cli-local MVP).
+ *
+ * The router already logs every decision (+ verify agreement + exec pass/fail +
+ * whether it escalated) to ~/.dragon/routing.jsonl. This reads that log and, per
+ * (intent, model), computes a PENALTY in [0..1]: how often that model needed help
+ * for that kind of task (low agreement, failed execution, or had to escalate). The
+ * selector uses it to demote chronically-failing models, and the cascade uses it to
+ * escalate sooner for a model with a bad track record.
+ *
+ * Local now; promotable to the Wyrm memory substrate (the wyrm-routing-rerank
+ * subsystem) — same signal, durable + cross-device.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+interface Stat {
+    n: number;
+    bad: number;
+}
+type Stats = Record<string, Record<string, Stat>>;
+/** 0 = no opinion / reliable; →1 = this model keeps needing help for this intent. */
+export declare function penalty(intent: string, model: string): number;
+/** For telemetry / `dragon` introspection. */
+export declare function routingStats(): Stats;
+export {};
+//# sourceMappingURL=routing-memory.d.ts.map

package/dist/brain/router/routing-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-memory.d.ts","sourceRoot":"","sources":["../../../src/brain/router/routing-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH,UAAU,IAAI;IAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;AACzC,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;AAkCjD,qFAAqF;AACrF,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI7D;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,IAAI,KAAK,CAEpC"}

package/dist/brain/router/routing-memory.js

@@ -0,0 +1,77 @@
+/**
+ * Routing-memory — negative learning over the router's own history
+ * (ROUTER-BLUEPRINT.md §3, dragon-cli-local MVP).
+ *
+ * The router already logs every decision (+ verify agreement + exec pass/fail +
+ * whether it escalated) to ~/.dragon/routing.jsonl. This reads that log and, per
+ * (intent, model), computes a PENALTY in [0..1]: how often that model needed help
+ * for that kind of task (low agreement, failed execution, or had to escalate). The
+ * selector uses it to demote chronically-failing models, and the cascade uses it to
+ * escalate sooner for a model with a bad track record.
+ *
+ * Local now; promotable to the Wyrm memory substrate (the wyrm-routing-rerank
+ * subsystem) — same signal, durable + cross-device.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const LOG = process.env.DRAGON_ROUTING_LOG || join(homedir(), '.dragon', 'routing.jsonl');
+const MIN_SAMPLES = 3; // below this we have no opinion (penalty 0)
+const LOW_AGREEMENT = 0.5;
+let cache = null;
+function compute() {
+    const stats = {};
+    let raw;
+    try {
+        raw = readFileSync(LOG, 'utf-8');
+    }
+    catch {
+        return stats;
+    }
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const intent = r.intent, model = r.model;
+        if (!intent || !model)
+            continue;
+        const v = r.verify || {};
+        const lowAgree = typeof v.agreement === 'number' && v.agreement < LOW_AGREEMENT;
+        const execFail = v.exec && v.exec.ran && v.exec.ok === false;
+        const escalated = r.escalated === true;
+        const twoHopFailed = r.twoHopFailed === true;
+        const bad = lowAgree || execFail || escalated || twoHopFailed;
+        const byModel = (stats[intent] ||= {});
+        const s = (byModel[model] ||= { n: 0, bad: 0 });
+        s.n++;
+        if (bad)
+            s.bad++;
+    }
+    return stats;
+}
+function load() {
+    if (cache && Date.now() - cache.at < 30_000)
+        return cache.stats;
+    cache = { at: Date.now(), stats: compute() };
+    return cache.stats;
+}
+/** 0 = no opinion / reliable; →1 = this model keeps needing help for this intent. */
+export function penalty(intent, model) {
+    const s = load()[intent]?.[model];
+    if (!s || s.n < MIN_SAMPLES)
+        return 0;
+    return Math.max(0, Math.min(1, s.bad / s.n));
+}
+/** For telemetry / `dragon` introspection. */
+export function routingStats() {
+    return load();
+}
+//# sourceMappingURL=routing-memory.js.map

package/dist/brain/router/select.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Ghost Router selection policy — (intent × difficulty × stakes × hasTools) → a
+ * concrete {provider, model}, constrained by what's actually installed and what
+ * fits 8 GB.
+ *
+ * Roles (Ollama tags, all overridable via env/config):
+ *   workhorse (tool/agent turns) → mistral-nemo   (verified tool-caller)
+ *   reasoner  (hard, NO tools)   → vibethinker     (can't tool-call → only when tools=[])
+ *   cheap     (simple chat)      → qwen2.5:1.5b    (fast, tiny)
+ *   escalate  (high stakes / hard) → claude        (cloud, only if available)
+ *
+ * VRAM rule: only one big model fits at a time. When two candidates are equally
+ * acceptable, prefer the one already resident in Ollama (avoids a reload/“swap”).
+ * EMBER is intentionally NOT a default role yet — it earns its way in via the
+ * DragonSpark flywheel.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { Classification } from './classify.js';
+export interface Target {
+    provider: string;
+    model?: string;
+    why: string;
+    swap: boolean;
+    verify?: boolean;
+    penalty?: number;
+    twoHop?: boolean;
+    reasoner?: string;
+}
+/** Decide where this turn goes. Pure policy + availability; never throws. */
+export declare function selectTarget(c: Classification, hasTools: boolean, base: string, signal?: AbortSignal): Promise<Target>;
+//# sourceMappingURL=select.d.ts.map

package/dist/brain/router/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../../src/brain/router/select.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGnD,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAgDD,6EAA6E;AAC7E,wBAAsB,YAAY,CAChC,CAAC,EAAE,cAAc,EACjB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,CAoEjB"}

package/dist/brain/router/select.js

@@ -0,0 +1,146 @@
+/**
+ * Ghost Router selection policy — (intent × difficulty × stakes × hasTools) → a
+ * concrete {provider, model}, constrained by what's actually installed and what
+ * fits 8 GB.
+ *
+ * Roles (Ollama tags, all overridable via env/config):
+ *   workhorse (tool/agent turns) → mistral-nemo   (verified tool-caller)
+ *   reasoner  (hard, NO tools)   → vibethinker     (can't tool-call → only when tools=[])
+ *   cheap     (simple chat)      → qwen2.5:1.5b    (fast, tiny)
+ *   escalate  (high stakes / hard) → claude        (cloud, only if available)
+ *
+ * VRAM rule: only one big model fits at a time. When two candidates are equally
+ * acceptable, prefer the one already resident in Ollama (avoids a reload/“swap”).
+ * EMBER is intentionally NOT a default role yet — it earns its way in via the
+ * DragonSpark flywheel.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { execSync } from 'node:child_process';
+import { loadConfig } from '../../config.js';
+import { penalty } from './routing-memory.js';
+const env = (k, d) => process.env[k] || d;
+function roles() {
+    const c = loadConfig().brain;
+    return {
+        workhorse: env('DRAGON_ROUTER_WORKHORSE', c?.routerWorkhorse || 'mistral-nemo'),
+        reasoner: env('DRAGON_ROUTER_REASONER', c?.routerReasoner || 'vibethinker'),
+        cheap: env('DRAGON_ROUTER_CHEAP', c?.routerCheap || 'qwen2.5:1.5b'),
+    };
+}
+const OLLAMA = (base) => base.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+let installedCache = null;
+async function installed(base, signal) {
+    if (installedCache && Date.now() - installedCache.at < 60_000)
+        return installedCache.names;
+    try {
+        const res = await fetch(OLLAMA(base) + '/api/tags', { signal });
+        if (!res.ok)
+            return new Set(); // don't cache an error as "nothing installed"
+        const data = (await res.json());
+        const names = new Set((data.models || []).map((m) => m.name.replace(/:latest$/, '')));
+        installedCache = { at: Date.now(), names };
+        return names;
+    }
+    catch {
+        return new Set();
+    }
+}
+async function resident(base, signal) {
+    try {
+        const res = await fetch(OLLAMA(base) + '/api/ps', { signal });
+        if (!res.ok)
+            return new Set();
+        const data = (await res.json());
+        return new Set((data.models || []).map((m) => m.name.replace(/:latest$/, '')));
+    }
+    catch {
+        return new Set();
+    }
+}
+function claudeAvailable() {
+    const cfg = loadConfig();
+    if (process.env.ANTHROPIC_API_KEY || cfg.brain?.keys?.anthropic)
+        return true;
+    try {
+        execSync('command -v claude', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const has = (set, name) => set.has(name) || set.has(name.replace(/:latest$/, ''));
+/** Decide where this turn goes. Pure policy + availability; never throws. */
+export async function selectTarget(c, hasTools, base, signal) {
+    const r = roles();
+    const have = await installed(base, signal);
+    const live = await resident(base, signal);
+    const local = (model, why) => ({
+        provider: 'local', model, why, swap: !has(live, model),
+    });
+    // 1) Stakes → escalate to Claude. PRIVACY-FIRST: this ships the turn to the cloud,
+    //    so it is OPT-IN (DRAGON_ROUTER_ESCALATE_STAKES=1) and NEVER fires for
+    //    security-sensitive content. `security` stakes (credentials, ssh, secrets,
+    //    prod, sudo) and any ops_security intent ALWAYS stay local — we never ship
+    //    secrets or target data off the box. Only financial/critical business-
+    //    irreversible decisions may escalate, and only when explicitly enabled.
+    //    (Low-confidence reasoning still escalates separately via the verify cascade.)
+    if (process.env.DRAGON_ROUTER_ESCALATE_STAKES === '1' &&
+        (c.stakes === 'financial' || c.stakes === 'critical') &&
+        c.intent !== 'ops_security' &&
+        claudeAvailable()) {
+        return { provider: 'claude', why: `stakes=${c.stakes} → escalate to Claude (opt-in)`, swap: false };
+    }
+    // 2) Reasoning with NO tools in play → the reasoning specialist (that's exactly
+    //    what it's for; it can't tool-call, so only ever route here when tools=[]).
+    //    Opt into the verified (best-of-N) path with DRAGON_ROUTER_VERIFY=1.
+    if (!hasTools && c.intent === 'reasoning' && has(have, r.reasoner)) {
+        const t = local(r.reasoner, `reasoning, no tools → ${r.reasoner}`);
+        t.verify = process.env.DRAGON_ROUTER_VERIFY === '1';
+        t.penalty = penalty(c.intent, r.reasoner);
+        return t;
+    }
+    // 3) Simple chat, no tools → the cheap/tiny model.
+    if (!hasTools && c.intent === 'chat' && c.difficulty < 0.35 && has(have, r.cheap)) {
+        return local(r.cheap, `simple chat → ${r.cheap}`);
+    }
+    // 4) Default workhorse for tool/agent turns (and everything else): the tool-caller.
+    //    Negative learning: if the workhorse has been unreliable for this intent and a
+    //    better-scoring installed alternative exists, demote to it.
+    //    Two-hop: a HARD tool turn first gets a plan from the reasoner (gated).
+    if (has(have, r.workhorse)) {
+        const wantTwoHop = process.env.DRAGON_ROUTER_TWOHOP === '1' && hasTools && has(have, r.reasoner) &&
+            (c.difficulty >= 0.5 || c.intent === 'reasoning' || c.intent === 'ops_security');
+        const withHop = (t) => {
+            if (wantTwoHop) {
+                t.twoHop = true;
+                t.reasoner = r.reasoner;
+                t.why += ` (+two-hop via ${r.reasoner})`;
+            }
+            return t;
+        };
+        const p = penalty(c.intent, r.workhorse);
+        if (p >= 0.7) {
+            const alt = [...have].find((m) => !/embed/.test(m) && m !== r.workhorse && m !== r.reasoner);
+            if (alt && penalty(c.intent, alt) < p) {
+                const t = local(alt, `routing-memory: ${r.workhorse} unreliable here (penalty ${p.toFixed(2)}) → ${alt}`);
+                t.penalty = penalty(c.intent, alt);
+                return withHop(t);
+            }
+        }
+        const t = local(r.workhorse, `${hasTools ? 'tool turn' : c.intent} → workhorse ${r.workhorse}`);
+        t.penalty = p;
+        return withHop(t);
+    }
+    // 5) Workhorse missing → degrade: any resident big local model, else Claude, else cheap.
+    //    Exclude the reasoner (can't tool-call) so a tool turn never lands on it.
+    const usable = (m) => !/embed/.test(m) && m !== r.reasoner;
+    const fallback = [...live].find(usable) || [...have].find(usable);
+    if (fallback)
+        return local(fallback, `workhorse '${r.workhorse}' not installed → ${fallback}`);
+    if (claudeAvailable())
+        return { provider: 'claude', why: 'no local model available → Claude', swap: false };
+    return { provider: 'local', model: r.cheap, why: 'last-resort cheap local', swap: true };
+}
+//# sourceMappingURL=select.js.map

package/dist/brain/router/two-hop.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reason→tool two-hop (ROUTER-BLUEPRINT.md §1).
+ *
+ * vibethinker reasons brilliantly but CANNOT tool-call; mistral-nemo tool-calls but
+ * reasons less deeply. For a HARD tool turn the router splits the work:
+ *   hop 1 — the reasoner produces a concrete PLAN (no tools), then
+ *   hop 2 — the tool model executes that plan with the real tools.
+ *
+ * On 8 GB this is sequential (the two models can't co-reside) — Ollama swaps them,
+ * so it's gated behind DRAGON_ROUTER_TWOHOP=1 and only fires on hard tool turns.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { Brain, BrainTurn, TurnOpts } from '../types.js';
+export interface TwoHopResult {
+    turn: BrainTurn;
+    planChars: number;
+}
+/**
+ * @param resolve  factory to build the executor brain (from router/index.ts)
+ */
+export declare function twoHop(localBaseURL: string, reasonerModel: string, workhorseModel: string, t: TurnOpts, resolve: (provider: string, model?: string) => Brain): Promise<TwoHopResult>;
+//# sourceMappingURL=two-hop.d.ts.map

package/dist/brain/router/two-hop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-hop.d.ts","sourceRoot":"","sources":["../../../src/brain/router/two-hop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAS7D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,wBAAsB,MAAM,CAC1B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,KAAK,GACnD,OAAO,CAAC,YAAY,CAAC,CAwBvB"}

package/dist/brain/router/two-hop.js

@@ -0,0 +1,39 @@
+/**
+ * Reason→tool two-hop (ROUTER-BLUEPRINT.md §1).
+ *
+ * vibethinker reasons brilliantly but CANNOT tool-call; mistral-nemo tool-calls but
+ * reasons less deeply. For a HARD tool turn the router splits the work:
+ *   hop 1 — the reasoner produces a concrete PLAN (no tools), then
+ *   hop 2 — the tool model executes that plan with the real tools.
+ *
+ * On 8 GB this is sequential (the two models can't co-reside) — Ollama swaps them,
+ * so it's gated behind DRAGON_ROUTER_TWOHOP=1 and only fires on hard tool turns.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { ollamaChat, toOllamaMessages } from './verify.js';
+const PLAN_SYSTEM = '\n\n── PLAN-ONLY MODE ──\n' +
+    'You are the analyst. Read the user request and produce a brief, concrete, numbered ' +
+    'PLAN to accomplish it (which tools to use, in what order, and why). Do NOT call any ' +
+    'tools and do NOT write code blocks — output only the plan.';
+/**
+ * @param resolve  factory to build the executor brain (from router/index.ts)
+ */
+export async function twoHop(localBaseURL, reasonerModel, workhorseModel, t, resolve) {
+    // hop 1 — reasoning/plan, no tools (so vibethinker never has to tool-call)
+    const plan = (await ollamaChat(localBaseURL, reasonerModel, toOllamaMessages(t.system + PLAN_SYSTEM, t.messages), 0.4, Math.min(t.maxTokens ?? 1024, 1024), t.signal)).trim();
+    // hop 2 — execution with the real tools, plan injected as guidance.
+    // Clean the plan (drop stray code fences) and cap it so the executor ACTS on it
+    // rather than engaging with it as prose, plus a firm act-now directive.
+    const cleanPlan = plan.replace(/```[\s\S]*?```/g, '').replace(/```/g, '').trim().slice(0, 700);
+    const enriched = cleanPlan
+        ? t.system +
+            '\n\n── PLAN (from the analyst) ──\n' + cleanPlan +
+            '\n\nExecute this plan NOW by calling the appropriate tool. Do NOT restate or ' +
+            'explain the plan — issue the tool call.'
+        : t.system;
+    const worker = resolve('local', workhorseModel);
+    const turn = await worker.turn({ ...t, system: enriched });
+    return { turn, planChars: cleanPlan.length };
+}
+//# sourceMappingURL=two-hop.js.map

package/dist/brain/router/verify.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Verified hard-reasoning path (ROUTER-BLUEPRINT.md §2).
+ *
+ * Ollama exposes no logits, so confidence = ANSWER-AGREEMENT: sample the reasoner
+ * N times at spread temperatures, extract each final answer, and majority-vote.
+ * The agreement ratio is the router's confidence signal (→ later: escalate if low).
+ * For code/security candidates we additionally run EXECUTION-based verification
+ * (see execute.ts) and use pass/fail as a hard reward.
+ *
+ * optillm: if DRAGON_OPTILLM_URL is set we treat it as a drop-in OpenAI-compatible
+ * test-time-scaling proxy and let IT do the scaling in one call (you run optillm
+ * pointed at Ollama). Otherwise we do best-of-N here — self-contained, no extra
+ * service, which suits the 8 GB local-first box.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { BrainMessage, BrainTurn, TurnOpts } from '../types.js';
+import { type ExecResult } from './execute.js';
+export interface VerifyMeta {
+    via: 'self-consistency' | 'optillm';
+    votes: number;
+    agreement: number | null;
+    distribution?: Record<string, number>;
+    exec?: ExecResult | null;
+}
+export declare function toOllamaMessages(system: string, messages: BrainMessage[]): {
+    role: string;
+    content: string;
+}[];
+export declare function ollamaChat(base: string, model: string, messages: unknown, temperature: number, maxTokens: number, signal?: AbortSignal): Promise<string>;
+export declare function extractAnswer(text: string): string | null;
+/** Run the reasoner with test-time scaling. Returns the chosen turn + how confident. */
+export declare function verifyReasoning(localBaseURL: string, model: string, t: TurnOpts, votes: number): Promise<{
+    turn: BrainTurn;
+    meta: VerifyMeta;
+}>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/brain/router/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/brain/router/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACpE,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AAE7D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,kBAAkB,GAAG,SAAS,CAAA;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CACzB;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE;UACpD,MAAM;aAAW,MAAM;IAM3C;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAU9J;AAcD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOzD;AAID,wFAAwF;AACxF,wBAAsB,eAAe,CACnC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,QAAQ,EACX,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CA0ChD"}