dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/mcp/src/engine/ollama.js

@@ -0,0 +1,258 @@
+// dexterm local engine: a minimal client for the user's own Ollama server (task-1543).
+//
+// Ollama runs models on the user's machine; dexterm talks to it over HTTP on the loopback interface
+// (http://127.0.0.1:11434 by default). Nothing here ships a model, a key or a download: the user installs
+// Ollama and pulls a model themselves. A host that is not on this machine is allowed only when the user
+// configures it, and every surface that shows the host warns about it (data would leave the machine).
+//
+// Endpoints used: GET /api/version, GET /api/tags, POST /api/show, POST /api/chat (streamed NDJSON or one
+// JSON object). No other host is ever contacted by this module.
+export const DEFAULT_OLLAMA_HOST = 'http://127.0.0.1:11434';
+export const DEFAULT_OLLAMA_PORT = 11434;
+/** True for a loopback host name or address. */
+export function isLoopbackHost(hostname) {
+    const h = hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    if (h === 'localhost' || h.endsWith('.localhost'))
+        return true;
+    if (h === '::1' || h === '0:0:0:0:0:0:0:1')
+        return true;
+    return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
+/**
+ * Parse a user-supplied Ollama host ("127.0.0.1", "localhost:11434", "http://[::1]:11434"). Only http(s), no
+ * credentials, no path or query. The default port is 11434. Returns an error string for anything else.
+ */
+export function parseOllamaHost(raw) {
+    const s = String(raw ?? '').trim();
+    if (!s)
+        return parseOllamaHost(DEFAULT_OLLAMA_HOST);
+    let u;
+    try {
+        u = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(s) ? s : `http://${s}`);
+    }
+    catch {
+        return { error: `not a host: ${s.slice(0, 80)}` };
+    }
+    if (u.protocol !== 'http:' && u.protocol !== 'https:')
+        return { error: `only http or https hosts (got ${u.protocol.replace(':', '')})` };
+    if (u.username || u.password)
+        return { error: 'a host with a user name or password is refused (it would be stored in plain text)' };
+    if ((u.pathname && u.pathname !== '/') || u.search || u.hash)
+        return { error: 'give the host only, without a path or query (e.g. http://127.0.0.1:11434)' };
+    // The URL parser drops a scheme-default port (:80 / :443), so read an explicit port from the text itself.
+    const explicit = /^(?:[a-z][a-z0-9+.-]*:\/\/)?(?:\[[^\]]+\]|[^:/]+):(\d+)\/?$/i.exec(s);
+    const port = explicit ? explicit[1] : /^https:\/\//i.test(s) ? '443' : String(DEFAULT_OLLAMA_PORT);
+    const hostname = u.hostname; // IPv6 keeps its brackets here
+    return { url: `${u.protocol}//${hostname}:${port}`, hostname, local: isLoopbackHost(hostname) };
+}
+/** The one warning every surface shows for a host that is not this machine. */
+export function remoteHostWarning(h) {
+    return h.local ? null : `the Ollama host ${h.hostname} is not this machine: prompts, screen context and tool results are sent to it over the network`;
+}
+export class OllamaError extends Error {
+    kind;
+    status;
+    /** task-1551: the host answered with a redirect, which is never followed (kind is 'unreachable'). */
+    redirect;
+    constructor(kind, message, status, redirect) { super(message); this.kind = kind; this.status = status; if (redirect)
+        this.redirect = true; }
+}
+/** task-1551: why a redirect is refused, for doctor / ask / ai probe. */
+export const REDIRECT_REFUSED = 'answered with a redirect, which dexterm never follows for the local engine (it would send your prompt to another host); set the Ollama host to the Ollama server itself';
+/** Strip a <think>…</think> block some models put in the content. */
+export const stripThink = (s) => s.replace(/<think>[\s\S]*?(<\/think>|$)/g, '');
+function normaliseToolCalls(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const c of raw) {
+        const f = c?.function;
+        if (!f || typeof f.name !== 'string' || !f.name)
+            continue;
+        let args = f.arguments;
+        if (typeof args === 'string') {
+            try {
+                args = JSON.parse(args);
+            }
+            catch {
+                args = {};
+            }
+        }
+        out.push({ function: { name: f.name, arguments: args && typeof args === 'object' && !Array.isArray(args) ? args : {} } });
+    }
+    return out;
+}
+export class OllamaClient {
+    host;
+    f;
+    metaTimeoutMs;
+    constructor(o) {
+        this.host = o.host;
+        this.f = o.fetch ?? ((url, init) => fetch(url, init));
+        this.metaTimeoutMs = o.metaTimeoutMs ?? 4000;
+    }
+    async req(path, init = {}, timeoutMs = this.metaTimeoutMs, outer) {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(new OllamaError('timeout', `Ollama did not answer within ${Math.round(timeoutMs / 1000)} s`)), timeoutMs);
+        timer.unref?.();
+        const onOuter = () => ac.abort(new OllamaError('aborted', 'cancelled'));
+        if (outer) {
+            if (outer.aborted)
+                onOuter();
+            else
+                outer.addEventListener('abort', onOuter, { once: true });
+        }
+        let res;
+        try {
+            // task-1551: redirect 'error' so a 3xx from the configured host never re-sends the prompt to another host.
+            res = await this.f(`${this.host.url}${path}`, {
+                method: init.method ?? 'GET',
+                headers: init.body !== undefined ? { 'content-type': 'application/json' } : undefined,
+                body: init.body !== undefined ? JSON.stringify(init.body) : undefined,
+                signal: ac.signal,
+                redirect: 'error',
+            });
+        }
+        catch (e) {
+            const reason = ac.signal.reason;
+            if (reason instanceof OllamaError)
+                throw reason;
+            const cause = e?.cause?.message;
+            if (/redirect/i.test(String(cause ?? '')) || /redirect/i.test(e?.message ?? ''))
+                throw new OllamaError('unreachable', `Ollama at ${this.host.url} ${REDIRECT_REFUSED}`, undefined, true);
+            throw new OllamaError('unreachable', `cannot reach Ollama at ${this.host.url} (${e.message})`);
+        }
+        finally {
+            clearTimeout(timer);
+            outer?.removeEventListener('abort', onOuter);
+        }
+        // A fetch that ignored the init (or answered 'manual'): never use a redirect or a redirected answer.
+        if (res.redirected || (res.status >= 300 && res.status < 400)) {
+            try {
+                await res.body?.cancel();
+            }
+            catch { /* ignore */ }
+            throw new OllamaError('unreachable', `Ollama at ${this.host.url} ${REDIRECT_REFUSED}`, res.status, true);
+        }
+        return res;
+    }
+    static async fail(res, model) {
+        let msg = '';
+        try {
+            const j = await res.json();
+            msg = String(j?.error ?? '');
+        }
+        catch { /* not json */ }
+        if (res.status === 404 && model && /not found|pull/i.test(msg || 'not found'))
+            throw new OllamaError('model-missing', `model ${model} is not pulled on this Ollama (run: ollama pull ${model})`, 404);
+        throw new OllamaError('http', `Ollama answered HTTP ${res.status}${msg ? `: ${msg.slice(0, 200)}` : ''}`, res.status);
+    }
+    async version() {
+        const res = await this.req('/api/version');
+        if (!res.ok)
+            return OllamaClient.fail(res);
+        const j = await res.json();
+        return typeof j.version === 'string' ? j.version : 'unknown';
+    }
+    /** Pulled model names (e.g. "qwen3:8b"). */
+    async tags() {
+        const res = await this.req('/api/tags');
+        if (!res.ok)
+            return OllamaClient.fail(res);
+        const j = await res.json();
+        return (j.models ?? []).map((m) => String(m.name ?? m.model ?? '')).filter(Boolean);
+    }
+    /** Model metadata: capabilities (tools, thinking, …) and the trained context length. */
+    async show(model) {
+        const res = await this.req('/api/show', { method: 'POST', body: { model } });
+        if (!res.ok)
+            return OllamaClient.fail(res, model);
+        const j = await res.json();
+        let ctx = null;
+        for (const [k, v] of Object.entries(j.model_info ?? {}))
+            if (/\.context_length$/.test(k) && typeof v === 'number')
+                ctx = v;
+        return {
+            capabilities: Array.isArray(j.capabilities) ? j.capabilities.map(String) : null,
+            contextLength: ctx,
+            parameterSize: typeof j.details?.parameter_size === 'string' ? j.details.parameter_size : null,
+            family: typeof j.details?.family === 'string' ? j.details.family : null,
+        };
+    }
+    /**
+     * One /api/chat call. With `onDelta` the response is streamed (NDJSON) and content deltas arrive as they
+     * are generated; tool calls and the final counters are returned either way.
+     */
+    async chat(r, o = {}) {
+        const stream = !!o.onDelta;
+        const res = await this.req('/api/chat', { method: 'POST', body: { ...r, stream } }, o.timeoutMs ?? 600_000, o.signal);
+        if (!res.ok)
+            return OllamaClient.fail(res, r.model);
+        const out = { content: '', toolCalls: [], doneReason: null, promptTokens: 0, evalTokens: 0, totalMs: null, model: null };
+        const take = (j) => {
+            if (typeof j.error === 'string')
+                throw new OllamaError('http', `Ollama: ${j.error.slice(0, 200)}`);
+            const m = (j.message ?? {});
+            if (typeof m.content === 'string' && m.content) {
+                out.content += m.content;
+                o.onDelta?.(m.content);
+            }
+            out.toolCalls.push(...normaliseToolCalls(m.tool_calls));
+            if (typeof j.model === 'string')
+                out.model = j.model;
+            if (j.done) {
+                out.doneReason = typeof j.done_reason === 'string' ? j.done_reason : 'stop';
+                out.promptTokens = Number(j.prompt_eval_count) || 0;
+                out.evalTokens = Number(j.eval_count) || 0;
+                out.totalMs = typeof j.total_duration === 'number' ? Math.round(j.total_duration / 1e6) : null;
+            }
+        };
+        if (!stream || !res.body) {
+            let j;
+            try {
+                j = await res.json();
+            }
+            catch {
+                throw new OllamaError('bad-response', 'Ollama sent a response that is not JSON');
+            }
+            take(j);
+            return out;
+        }
+        const dec = new TextDecoder();
+        let buf = '';
+        try {
+            for await (const chunk of res.body) {
+                buf += dec.decode(chunk, { stream: true });
+                let i;
+                while ((i = buf.indexOf('\n')) >= 0) {
+                    const line = buf.slice(0, i).trim();
+                    buf = buf.slice(i + 1);
+                    if (!line)
+                        continue;
+                    let j;
+                    try {
+                        j = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    take(j);
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof OllamaError)
+                throw e;
+            if (o.signal?.aborted)
+                throw new OllamaError('aborted', 'cancelled');
+            throw new OllamaError('unreachable', `the Ollama stream broke (${e.message})`);
+        }
+        if (buf.trim()) {
+            try {
+                take(JSON.parse(buf));
+            }
+            catch { /* trailing garbage */ }
+        }
+        return out;
+    }
+}

package/dist/packages/mcp/src/engine/probe.js

@@ -0,0 +1,110 @@
+// dexterm local engine: the capability probe and the bar per restriction profile (task-1543).
+//
+// `dexterm doctor` and `dexterm ai probe` ask the user's Ollama: is it reachable, is the model pulled, can it call
+// tools, how much context does it have, and (for paper/full) does it answer a fixed JSON protocol reliably. A
+// model below the bar for the enabled profile gets a warning with the fix; nothing is blocked by the probe
+// itself (the user decides), but the limits outside the model apply regardless.
+import { OllamaError } from "./ollama.js";
+import { RESTRICTION_RANK } from "./restrictions.js";
+/**
+ * Tool-capable model families to start with. These are suggestions from Ollama's public library ("tools"
+ * capability), not a dexterm benchmark: the probe checks the copy you pulled. Smaller = faster, weaker.
+ */
+export const SUGGESTED_MODELS = [
+    { name: 'qwen3:8b', size: '~5 GB', note: 'good default on a 16 GB machine' },
+    { name: 'qwen3:14b', size: '~9 GB', note: 'steadier tool use, needs ~16 GB free' },
+    { name: 'llama3.1:8b', size: '~5 GB', note: 'widely used tool caller' },
+    { name: 'mistral-small3.2', size: '~15 GB', note: 'strong tool use on a 32 GB machine' },
+];
+/** What a model should manage at each profile (json = passes out of 3 protocol probes). */
+export const BAR = {
+    observe: { tools: false, minCtx: 4096, json: 0 },
+    propose: { tools: true, minCtx: 8192, json: 0 },
+    paper: { tools: true, minCtx: 8192, json: 2 },
+    full: { tools: true, minCtx: 16384, json: 3 },
+};
+const PROBE_SCHEMA = {
+    type: 'object',
+    properties: { action: { type: 'string', enum: ['enter', 'wait', 'skip'] }, confidence: { type: 'number' }, reason: { type: 'string' } },
+    required: ['action', 'confidence', 'reason'],
+};
+const PROBE_PROMPTS = [
+    'Coin A: price up 12% in 5 minutes, buyers 40 vs sellers 12, liquidity $80K. Decide.',
+    'Coin B: price down 30% in 5 minutes, liquidity halved, top holder sold. Decide.',
+    'Coin C: flat for an hour, liquidity $5K, 3 holders. Decide.',
+];
+/** Run the probe. Never throws; `json` runs only when asked (it costs three short generations). */
+export async function probeModel(client, model, o) {
+    const p = { host: client.host.url, local: client.host.local, reachable: false, version: null, error: null, models: [], model, present: false, capabilities: null, tools: null, contextLength: null, parameterSize: null, numCtx: o.numCtx, json: null };
+    try {
+        p.version = await client.version();
+        p.reachable = true;
+        p.models = await client.tags();
+    }
+    catch (e) {
+        p.error = e.message;
+        if (e instanceof OllamaError && e.redirect)
+            p.redirect = true;
+        return p;
+    }
+    if (!model)
+        return p;
+    p.present = p.models.includes(model) || p.models.includes(`${model}:latest`) || (!model.includes(':') && p.models.some((m) => m.startsWith(`${model}:`)));
+    if (!p.present)
+        return p;
+    try {
+        const s = await client.show(model);
+        p.capabilities = s.capabilities;
+        p.tools = s.capabilities ? s.capabilities.includes('tools') : null;
+        p.contextLength = s.contextLength;
+        p.parameterSize = s.parameterSize;
+        if (s.contextLength)
+            p.numCtx = Math.min(o.numCtx, s.contextLength);
+    }
+    catch (e) {
+        p.error = e.message;
+        if (e instanceof OllamaError && e.kind === 'model-missing')
+            p.present = false;
+        return p;
+    }
+    if (o.json) {
+        let pass = 0;
+        for (const q of PROBE_PROMPTS) {
+            try {
+                const r = await client.chat({ model, messages: [{ role: 'system', content: 'Answer with the JSON object only: {"action":"enter|wait|skip","confidence":0..1,"reason":"short"}' }, { role: 'user', content: q }], format: PROBE_SCHEMA, options: { num_ctx: Math.min(p.numCtx, 4096), temperature: 0 } }, { timeoutMs: 120_000 });
+                const v = JSON.parse(r.content.trim());
+                if (['enter', 'wait', 'skip'].includes(String(v.action)) && typeof v.confidence === 'number' && v.confidence >= 0 && v.confidence <= 1 && typeof v.reason === 'string')
+                    pass++;
+            }
+            catch { /* a failed run is a miss */ }
+        }
+        p.json = { pass, runs: PROBE_PROMPTS.length };
+    }
+    return p;
+}
+/** Warnings when the probed model is below the bar for a profile (empty = fine). Each says how to fix it. */
+export function belowBar(level, p) {
+    const bar = BAR[level];
+    const w = [];
+    if (!p.reachable || !p.present)
+        return w;
+    if (bar.tools && p.tools === false)
+        w.push(`${p.model} cannot call tools: at ${level} it answers from the dossier only; pull a tool-capable model (e.g. ollama pull ${SUGGESTED_MODELS[0].name})`);
+    const ctx = p.contextLength ?? p.numCtx;
+    if (ctx < bar.minCtx)
+        w.push(`${p.model} has a ${ctx}-token context; ${level} wants at least ${bar.minCtx} (long dossiers get cut)`);
+    if (p.json && p.json.pass < bar.json)
+        w.push(`${p.model} answered ${p.json.pass}/${p.json.runs} protocol probes; ${level} wants ${bar.json}/3 (decisions it cannot format are refused, which means fewer trades, not bigger ones)`);
+    if (RESTRICTION_RANK[level] >= RESTRICTION_RANK.paper && p.json === null)
+        w.push(`run \`dexterm ai probe --json\` to check ${p.model} formats decisions reliably before ${level}`);
+    return w;
+}
+/** Pick a model when none is configured: the first suggested one that is pulled, else the first pulled model. */
+export function pickModel(pulled) {
+    for (const s of SUGGESTED_MODELS) {
+        const hit = pulled.find((m) => m === s.name || m === `${s.name}:latest`);
+        if (hit)
+            return hit;
+    }
+    return pulled.find((m) => !/embed/i.test(m)) ?? null;
+}

package/dist/packages/mcp/src/engine/reason.js

@@ -0,0 +1,35 @@
+// dexterm local engine: the pack REASON stage on Ollama (task-1543).
+//
+// Same contract as the claude runner in @dexterm/packs (reason.ts): one tool-less call over an assembled dossier,
+// structured output forced by the schema, and the reply shaped like `claude -p --output-format json` so the
+// packs' grounding / tighten-only / flags-kept checks run unchanged. The model id of the call is the local one.
+import { stripThink } from "./ollama.js";
+export function ollamaReasonRunner(client, model, numCtx = 16384) {
+    return async ({ prompt, system, schema, timeoutMs }) => {
+        const t0 = Date.now();
+        try {
+            const r = await client.chat({
+                model,
+                messages: [{ role: 'system', content: system }, { role: 'user', content: prompt }],
+                format: schema,
+                options: { num_ctx: numCtx, temperature: 0 },
+            }, { timeoutMs });
+            let structured = null;
+            try {
+                structured = JSON.parse(stripThink(r.content).trim());
+            }
+            catch {
+                structured = null;
+            }
+            const ok = !!structured && typeof structured === 'object' && !Array.isArray(structured);
+            return {
+                stdout: JSON.stringify({ type: 'result', is_error: !ok, structured_output: ok ? structured : null, total_cost_usd: 0, duration_api_ms: Date.now() - t0, num_turns: 1, engine: 'ollama', model: r.model ?? model }),
+                exitCode: ok ? 0 : 1,
+                ...(ok ? {} : { stderr: 'the local model did not return the JSON object' }),
+            };
+        }
+        catch (e) {
+            return { stdout: '', exitCode: 127, stderr: `ollama: ${e.message}` };
+        }
+    };
+}

package/dist/packages/mcp/src/engine/restrictions.js

@@ -0,0 +1,111 @@
+// dexterm local engine: restriction profiles and the engine-parity matrix (task-1543).
+//
+// A local engine (Ollama) can do everything the Claude path does, behind a restriction profile the USER picks:
+//
+//   observe  analyse only: read tools, no UI actions, no proposals, no orders
+//   propose  the analyst's surface: read tools + UI actions (open_ticket only OPENS a paper ticket) + strategy
+//            proposals the user applies by keypress. The default for a new local setup.
+//   paper    propose + paper orders (autotrade paper sessions, agent paper trading inside a mandate you armed)
+//   full     everything the Claude path may do, subject to the same user-set mandate tiers and gates
+//
+// The profile only decides what the engine may ASK for. Every limit that protects money is enforced outside
+// the model and is identical for every engine: the signer's caps, the kill switch, the dead-man switch, live-mode
+// gating, mandate tiers, the strategy clamp and the Telegram button/nonce rules. A model can request; it can
+// never raise a cap, arm a mandate or turn live on, and no tool, MCP call or chat message changes the profile.
+import { ANALYST_ACTION_TYPES } from '../../../data/src/index.js';
+import { PAPER_NOTE_TOOLS, PAPER_READ_TOOLS, PAPER_WRITE_TOOLS, READ_ONLY_TOOLS } from "../server.js";
+import { JOURNEY_CONTROL_TOOLS, JOURNEY_PROPOSE_TOOLS, PARALLEL_CONTROL_TOOLS, STRATEGY_PROPOSE_TOOLS } from "../autotrade-tools.js";
+import { LEDGER_PROPOSE_TOOLS } from "../ledger-tools.js";
+export const RESTRICTION_LEVELS = ['observe', 'propose', 'paper', 'full'];
+export const RESTRICTION_RANK = { observe: 0, propose: 1, paper: 2, full: 3 };
+/** A new local-engine setup starts here. `full` needs a typed confirmation (`dexterm ai engine ollama --full`). */
+export const DEFAULT_RESTRICTION = 'propose';
+export const RESTRICTION_HELP = {
+    observe: 'analyse only (read tools; no UI actions, no proposals, no orders)',
+    propose: 'analyst + proposals (UI actions, a PAPER ticket you confirm, strategy proposals you apply); no orders',
+    paper: 'proposals + paper orders (autotrade paper sessions, agent paper trading inside a mandate you armed)',
+    full: 'everything the Claude path may do, inside the same caps, mandate tiers, kill switch and live gating',
+};
+export function isRestriction(v) {
+    return typeof v === 'string' && RESTRICTION_LEVELS.includes(v);
+}
+export function atLeast(have, need) {
+    return RESTRICTION_RANK[have] >= RESTRICTION_RANK[need];
+}
+export function lowerOf(a, b) {
+    return RESTRICTION_RANK[a] <= RESTRICTION_RANK[b] ? a : b;
+}
+/** What an engine may ask for, by the lowest profile that allows it. */
+export const CAPABILITY_LEVEL = {
+    analyse: 'observe',
+    'ui-actions': 'propose',
+    'strategy-proposals': 'propose',
+    'paper-orders': 'paper',
+    'live-orders': 'full',
+};
+export function allows(level, cap) {
+    return atLeast(level, CAPABILITY_LEVEL[cap]);
+}
+/**
+ * Tool names no local engine is ever handed, whatever a server grows (defence in depth: the dexterm MCP server
+ * has no such tool, and its no-sign registry test keeps it that way).
+ */
+export const NEVER_TOOL = /(^|_)(sign|signer|send|transfer|withdraw|arm|disarm|caps?|key|keys|seed|keystore|live|mainnet|unlock|resume|panic|restrictions?|engine)(_|$)/i;
+/**
+ * The dexterm MCP tools a local engine may call at a profile. `actionTypes` is the session's UI-action list
+ * exactly as the claude path reads it: absent = all of them, `[]` (AI scan) = none and no proposals either.
+ */
+export function engineToolAllowlist(level, actionTypes) {
+    const actions = ANALYST_ACTION_TYPES;
+    const reads = READ_ONLY_TOOLS.filter((n) => !/^paper_/.test(n) && !actions.includes(n));
+    const out = new Set(reads);
+    const observeOnly = !!actionTypes && actionTypes.length === 0;
+    if (allows(level, 'ui-actions') && !observeOnly)
+        for (const t of actions)
+            if (!actionTypes || actionTypes.includes(t))
+                out.add(t);
+    if (allows(level, 'strategy-proposals') && !observeOnly)
+        for (const t of [...STRATEGY_PROPOSE_TOOLS, ...JOURNEY_PROPOSE_TOOLS])
+            out.add(t);
+    // Paper tools: the MCP server still refuses them unless the user armed a mandate and enabled agent paper trading.
+    if (allows(level, 'paper-orders') && !observeOnly)
+        for (const t of [...PAPER_READ_TOOLS, ...PAPER_WRITE_TOOLS])
+            out.add(t);
+    // v0.1.7 integration: the other paper-side writes (start / stop / pause one listed parallel strategy, a paper
+    // journal tag, a backtest request file) join at `paper`, so `paper` and `full` offer every tool the claude path has
+    if (allows(level, 'paper-orders') && !observeOnly)
+        for (const t of [...PARALLEL_CONTROL_TOOLS, ...JOURNEY_CONTROL_TOOLS, ...PAPER_NOTE_TOOLS, ...LEDGER_PROPOSE_TOOLS])
+            out.add(t);
+    return [...out].filter((n) => !NEVER_TOOL.test(n));
+}
+/** The surfaces that run a model, and the profile each needs on a local engine. */
+export const SURFACES = ['analyst', 'autotrade', 'packs', 'agent'];
+/** The profile a surface needs before a local engine may run it (live autotrade needs `full`). */
+export function requiredLevel(surface, o = {}) {
+    if (surface === 'autotrade')
+        return o.live ? 'full' : 'paper';
+    if (surface === 'agent')
+        return 'propose';
+    return 'observe';
+}
+/**
+ * Every place the Claude CLI is spawned or assumed, and its local-engine equivalent. Kept in code so the docs,
+ * `dexterm ai status` and the parity test read the same list.
+ */
+export const ENGINE_PARITY = [
+    { id: 'analyst-chat', surface: 'Analyst chat (token screen, `a`, follow-ups)', claude: 'claude -p with the read-only dexterm MCP server', local: 'Ollama /api/chat (streamed) with the same dexterm MCP server over stdio, same tools, same firewall', status: 'equivalent', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'analyst-skills', surface: 'Structured skills (dossier, rug-check, larp-check, trench-scan)', claude: '--json-schema structured output', local: 'tool loop, then Ollama structured output (format = the same schema)', status: 'equivalent', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'analyst-no-tools', surface: 'A model without tool calling', claude: 'n/a (Claude always has tools)', local: 'dexterm fetches the dossier itself and the model answers from it without tools, and says so', status: 'degrade', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'ai-scan', surface: 'AI scan mode (Z)', claude: 'observe-only analyst session', local: 'same session on the local engine, observe-only at the allowlist, the MCP server and the app', status: 'equivalent', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'jarvis', surface: 'Jarvis voice questions', claude: 'asks through the analyst session', local: 'asks through the same session, on whichever engine /engine picked', status: 'equivalent', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'ask', surface: 'Headless question (`dexterm ai ask`)', claude: 'the analyst backend on claude', local: 'the analyst backend on Ollama', status: 'equivalent', minLevel: 'observe', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'strategy-proposals', surface: 'Tune by chat (strategy_propose_edit / _new)', claude: 'MCP propose tools; the user applies by keypress', local: 'the same tools at `propose`; the same keypress apply path', status: 'equivalent', minLevel: 'propose', test: 'packages/mcp/test/ollama-engine-1543.test.ts' },
+    { id: 'autotrade-sessions', surface: 'Autotrade candidate + position sessions', claude: 'tool-less claude -p, DECISION line, engine clamp', local: 'tool-less Ollama session, the same DECISION line (structured output), the same clamp, caps and ledger', status: 'equivalent', minLevel: 'paper', test: 'packages/autotrade/test/ollama-sessions-1543.test.ts' },
+    { id: 'live-executors', surface: 'Live orders (signer, mandates)', claude: 'requests only; the signer enforces the caps', local: 'requests only, at `full`; the same signer, caps, mandate tiers, kill switch and live gating', status: 'equivalent', minLevel: 'full', test: 'packages/autotrade/test/ollama-sessions-1543.test.ts' },
+    { id: 'packs-reason', surface: 'Pack reasoning stage (tighten-only verdict; a library stage no app screen calls today)', claude: 'tool-less claude -p with --json-schema', local: 'tool-less Ollama structured output, the same grounding/tighten-only checks (ollamaReasonRunner)', status: 'equivalent', minLevel: 'observe', test: 'packages/mcp/test/ollama-engine-1543.test.ts' },
+    { id: 'mcp-agent', surface: 'MCP agent (incl. agent paper trading in an armed mandate)', claude: 'claude -p connected to `dexterm mcp`', local: '`dexterm ai agent`: Ollama as the MCP client, tools by profile, paper tools only at `paper`', status: 'equivalent', minLevel: 'propose', test: 'packages/cli/test/ollama-analyst-1543.test.ts' },
+    { id: 'telegram', surface: 'Telegram control + approvals', claude: 'human buttons (one-time, nonce/hash/expiry, sender allowlist)', local: 'the same: approvals are taps by the user, never by a model, whichever engine proposed', status: 'engine-independent', minLevel: null, test: 'packages/autotrade/test/ollama-sessions-1543.test.ts' },
+    { id: 'agent-bus', surface: 'Loopback agent bus / SDK agents', claude: 'agents bring their own model', local: 'the same; a local agent can use the SDK or `dexterm ai agent`', status: 'engine-independent', minLevel: null, test: 'packages/mcp/test/ollama-engine-1543.test.ts' },
+    { id: 'allowance-guard', surface: 'Claude allowance guard (rate_limit_event)', claude: 'pauses sessions near the plan limit', local: 'no plan limit and $0 cost; the day turn and session caps still apply', status: 'degrade', minLevel: null, test: 'packages/autotrade/test/ollama-sessions-1543.test.ts' },
+    { id: 'routines', surface: 'Scheduled routines', claude: 'none run in the app today (daily-digest is defined only)', local: 'any future routine goes through the same engine seam', status: 'not-in-app', minLevel: null, test: 'packages/mcp/test/ollama-engine-1543.test.ts' },
+];

package/dist/packages/mcp/src/index.js

@@ -1,11 +1,17 @@
 // @dexterm/mcp — read-only MCP server over stdio (SPEC §5, D-09 / task-1302).
 // Every tool is read-only and schema-described; nothing in this package may build,
 // sign or send a transaction (SPEC §5.2, §6.3).
-export { runStdioServer, selfTest, McpTools, TOOLS, READ_ONLY_TOOLS, PAPER_WRITE_TOOLS, PAPER_READ_TOOLS, appHelpAnswer, firewall, listPrompts, getPrompt, resourceList, resourceRead, overlayCounts, userSkillPreamble, BUNDLED_KB_DIR, BUNDLED_SKILLS_DIR } from "./server.js";
+export { runStdioServer, selfTest, McpTools, TOOLS, READ_ONLY_TOOLS, PAPER_WRITE_TOOLS, PAPER_READ_TOOLS, PAPER_NOTE_TOOLS, appHelpAnswer, firewall, listPrompts, getPrompt, resourceList, resourceRead, overlayCounts, userSkillPreamble, BUNDLED_KB_DIR, BUNDLED_SKILLS_DIR } from "./server.js";
 // task-1443: resolve the paper agent desk from the running app's rendezvous (null when agent paper trading is off).
 export { resolvePaperAgentDesk, paperAgentDeskDb } from "./paper-agent.js";
 export { OverlayStore, mergeOverlay, loadBundled, checkKb, checkSkill, moneyToolMentions, isMoneyToolName, parseFrontmatter, dextermHome, userKbDir, userSkillsDir, userDir, contentJournalPath, journalContent, writeOverlayFile, resetOverlayFile, templateFor, KB_LIMITS, SKILL_LIMITS, KB_ID, SKILL_NAME, KB_RULE, MONEY_TOOLS, } from "./user-content.js";
+// task-1507: the AUTOTRADE chat tools (strategy reads + proposals), the model deny-list, the risk delta and the
+// proposal files the Q screen's keypress path re-checks and applies.
+export { AutotradeTools, ProposalFiles, checkProposal, riskDelta, diffLines, screenDelta, deniedChanges, opsPolicyErrors, opsShapeErrors, proposalCardView, proposalsDir, isProposalId, cleanText, loadEngine, STRATEGY_DENIED_FOR_MODELS, STRATEGY_READ_TOOLS, STRATEGY_PROPOSE_TOOLS, AUTOTRADE_TOOLS, PARALLEL_READ_TOOLS, PARALLEL_CONTROL_TOOLS, PARALLEL_TOOLS, JOURNEY_READ_TOOLS, JOURNEY_CONTROL_TOOLS, JOURNEY_PROPOSE_TOOLS, JOURNEY_TOOLS, FORWARD_START_RATE, defaultForwardSpawner, MAX_PROPOSAL_OPS, BACKTEST_MAX_DAYS, BACKTEST_RATE, PROPOSAL_SCHEMA, RUNNER_STATUS_SCHEMA, } from "./autotrade-tools.js";
 export { buildDossier } from "./dossier.js";
+// task-1530: the trade-ledger tools (reads + the backtest request), and the request files the CLI runs or dismisses.
+export { LedgerTools, LEDGER_TOOLS, LEDGER_READ_TOOLS, LEDGER_PROPOSE_TOOLS, tradeView, filterFromArgs } from "./ledger-tools.js";
+export { BacktestRequests, requestsDir, isRequestId, BACKTEST_REQUEST_SCHEMA, REQUEST_MAX_DAYS, MAX_PENDING_REQUESTS, REQUEST_RATE_PER_HOUR } from "./backtest-requests.js";
 // task-1406 + task-1421: the spectator sink the tool-call path writes to when a spectator surface is open
 // (via DEXTERM_SPECTATOR_FILE, or the ~/.dexterm rendezvous an external `dexterm mcp` client uses).
 export { recordForToolCall, maxAgeSec, fileSpectatorSinkFromEnv, resolveSpectatorSink, rendezvousPath, MCP_SPECTATOR_RENDEZVOUS, MCP_FOLLOW_SCREEN, FOLLOW_NAV_ACTIONS, followScreenPath, readFollowScreen, writeFollowScreen, clearFollowScreen, } from "./spectator-sink.js";