ghost-dragon 4.2.1

package/dist/ui.d.ts

@@ -0,0 +1,57 @@
+/**
+ * UI design system — the "ops console" premium look (stealth silver).
+ *
+ * One place for the chrome: framed panels (boxen, ANSI-width-aware), a chrome
+ * gradient wordmark, status dots, key/value rows, rules + section headers. Every
+ * command composes these so the whole CLI reads as one flagship tool.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+/** Brushed-chrome gradient across a string — the premium wordmark treatment. */
+export declare function chrome(s: string): string;
+/** A framed panel with an optional left-aligned title (rendered in the border). */
+export declare function panel(lines: string[], opts?: {
+    title?: string;
+    borderColor?: string;
+    width?: number;
+}): string;
+export declare const emerald: import("chalk").ChalkInstance;
+export declare const emeraldDim: import("chalk").ChalkInstance;
+/** Zip two rectangular blocks side-by-side. `leftWidth` = the left block's visible
+ *  width (set a fixed `width` on the left panel so padding lines up). */
+export declare function joinColumns(left: string, right: string, leftWidth: number, gap?: number): string;
+/** A brushed-chrome horizontal rule. */
+export declare function chromeRule(width: number): string;
+/** A unicode sparkline (8 vertical levels). Emerald where there's signal, faint for zero. */
+export declare function sparkline(values: number[]): string;
+/** A fractional gauge bar (eighth-cell precision). Colour ramps green→amber→red. */
+export declare function gauge(frac: number, width: number): string;
+/**
+ * A multi-row Braille area/line chart — 4× the vertical resolution of a
+ * sparkline and 2× horizontal (values are interpolated across dot columns).
+ * Returns `height` colored rows of `width` cells. Emerald signal by default.
+ */
+export declare function brailleChart(values: number[], opts?: {
+    width?: number;
+    height?: number;
+    max?: number;
+    color?: (s: string) => string;
+    area?: boolean;
+}): string[];
+export declare const dot: {
+    on: string;
+    off: string;
+    live: string;
+    warn: string;
+    crit: string;
+};
+export declare const statusDot: (on: boolean) => string;
+/** "label  value" with the label dim + padded to a column. */
+export declare function kv(label: string, value: string, pad?: number): string;
+/** A hairline rule, optionally with a section label on the left. */
+export declare function rule(width?: number, label?: string): string;
+/** Collapse $HOME → ~ for tidy paths. */
+export declare function tidyPath(p: string): string;
+/** The ops-console brand splash (global header). */
+export declare function brandHeader(version: string): string;
+//# sourceMappingURL=ui.d.ts.map

package/dist/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../src/ui.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAaxC;AAED,mFAAmF;AACnF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CASlH;AAGD,eAAO,MAAM,OAAO,+BAAuB,CAAA;AAC3C,eAAO,MAAM,UAAU,+BAAuB,CAAA;AAE9C;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAI,GAAG,MAAM,CAS3F;AAED,wCAAwC;AACxC,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAMD,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAIlD;AAED,oFAAoF;AACpF,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CASzD;AAWD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1G,MAAM,EAAE,CAkCV;AAED,eAAO,MAAM,GAAG;;;;;;CAMf,CAAA;AACD,eAAO,MAAM,SAAS,GAAI,IAAI,OAAO,WAA4B,CAAA;AAEjE,8DAA8D;AAC9D,wBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAI,GAAG,MAAM,CAEhE;AAED,oEAAoE;AACpE,wBAAgB,IAAI,CAAC,KAAK,SAAK,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED,yCAAyC;AACzC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED,oDAAoD;AACpD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQnD"}

package/dist/ui.js

@@ -0,0 +1,174 @@
+/**
+ * UI design system — the "ops console" premium look (stealth silver).
+ *
+ * One place for the chrome: framed panels (boxen, ANSI-width-aware), a chrome
+ * gradient wordmark, status dots, key/value rows, rules + section headers. Every
+ * command composes these so the whole CLI reads as one flagship tool.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { homedir } from 'node:os';
+import { C } from './utils.js';
+const BORDER = '#454e57'; // dim slate — the frame
+const SILVER_STOPS = ['#dfe6ec', '#99a3ac', '#eef3f7', '#99a3ac', '#dfe6ec'];
+function hexLerp(a, b, t) {
+    const A = [1, 3, 5].map((i) => parseInt(a.slice(i, i + 2), 16));
+    const B = [1, 3, 5].map((i) => parseInt(b.slice(i, i + 2), 16));
+    const c = A.map((v, i) => Math.round(v + (B[i] - v) * t));
+    return '#' + c.map((v) => v.toString(16).padStart(2, '0')).join('');
+}
+/** Brushed-chrome gradient across a string — the premium wordmark treatment. */
+export function chrome(s) {
+    const chars = [...s];
+    const n = chars.length;
+    if (n === 0)
+        return s;
+    return chars
+        .map((ch, i) => {
+        if (ch === ' ')
+            return ch;
+        const p = (n === 1 ? 0 : i / (n - 1)) * (SILVER_STOPS.length - 1);
+        const lo = Math.floor(p);
+        const hi = Math.min(lo + 1, SILVER_STOPS.length - 1);
+        return chalk.hex(hexLerp(SILVER_STOPS[lo], SILVER_STOPS[hi], p - lo)).bold(ch);
+    })
+        .join('');
+}
+/** A framed panel with an optional left-aligned title (rendered in the border). */
+export function panel(lines, opts = {}) {
+    return boxen(lines.join('\n'), {
+        title: opts.title,
+        titleAlignment: 'left',
+        padding: { top: 0, bottom: 0, left: 1, right: 2 },
+        borderStyle: 'round',
+        borderColor: opts.borderColor ?? BORDER,
+        ...(opts.width ? { width: opts.width } : {}),
+    });
+}
+// ghosts.lk "live/online" accent — a whisper of emerald (oklch 0.55 0.15 155).
+export const emerald = chalk.hex('#2bb673');
+export const emeraldDim = chalk.hex('#1c6e49');
+/** Zip two rectangular blocks side-by-side. `leftWidth` = the left block's visible
+ *  width (set a fixed `width` on the left panel so padding lines up). */
+export function joinColumns(left, right, leftWidth, gap = 3) {
+    const L = left.split('\n');
+    const R = right.split('\n');
+    const n = Math.max(L.length, R.length);
+    const blank = ' '.repeat(leftWidth);
+    const sep = ' '.repeat(gap);
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push((L[i] ?? blank) + sep + (R[i] ?? ''));
+    return out.join('\n');
+}
+/** A brushed-chrome horizontal rule. */
+export function chromeRule(width) {
+    return chrome('─'.repeat(Math.max(4, width)));
+}
+// ── sub-cell data viz (the obscure terminal-graphics craft) ──
+const SPARK = '▁▂▃▄▅▆▇█';
+const PARTIAL = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█']; // eighth-cell fills
+/** A unicode sparkline (8 vertical levels). Emerald where there's signal, faint for zero. */
+export function sparkline(values) {
+    if (!values.length)
+        return '';
+    const max = Math.max(...values, 1);
+    return values.map((v) => (v <= 0 ? C.faint('▁') : emerald(SPARK[Math.min(7, Math.max(0, Math.round((v / max) * 7)))]))).join('');
+}
+/** A fractional gauge bar (eighth-cell precision). Colour ramps green→amber→red. */
+export function gauge(frac, width) {
+    const f = Math.max(0, Math.min(1, frac));
+    const cells = f * width;
+    const full = Math.floor(cells);
+    const rem = Math.round((cells - full) * 8);
+    const bar = '█'.repeat(full) + (rem > 0 ? PARTIAL[rem] : '');
+    const used = full + (rem > 0 ? 1 : 0);
+    const col = f < 0.7 ? emerald : f < 0.9 ? C.high : C.critical;
+    return col(bar) + C.faint('·'.repeat(Math.max(0, width - used)));
+}
+// Braille (U+2800 + 8-bit mask) = a 2x4 dot grid per cell → 8 sub-pixels, the
+// densest text-only renderer (see the terminal-subcell-graphics skill).
+const BR_DOTS = [
+    [0x01, 0x08],
+    [0x02, 0x10],
+    [0x04, 0x20],
+    [0x40, 0x80],
+];
+/**
+ * A multi-row Braille area/line chart — 4× the vertical resolution of a
+ * sparkline and 2× horizontal (values are interpolated across dot columns).
+ * Returns `height` colored rows of `width` cells. Emerald signal by default.
+ */
+export function brailleChart(values, opts = {}) {
+    const width = Math.max(2, opts.width ?? 32);
+    const height = Math.max(1, opts.height ?? 3);
+    const W = width * 2;
+    const H = height * 4;
+    const max = opts.max ?? Math.max(...values, 1);
+    const color = opts.color ?? emerald;
+    const area = opts.area ?? true;
+    const bits = new Uint8Array(width * height);
+    const set = (x, y) => {
+        if (x < 0 || x >= W || y < 0 || y >= H)
+            return;
+        bits[(y >> 2) * width + (x >> 1)] |= BR_DOTS[y & 3][x & 1];
+    };
+    const n = values.length;
+    for (let x = 0; x < W; x++) {
+        const idx = n <= 1 ? 0 : (x / (W - 1)) * (n - 1);
+        const lo = Math.floor(idx);
+        const hi = Math.min(lo + 1, n - 1);
+        const v = (values[lo] ?? 0) + ((values[hi] ?? 0) - (values[lo] ?? 0)) * (idx - lo);
+        const lvl = Math.max(0, Math.min(H - 1, Math.round((v / max) * (H - 1))));
+        const top = H - 1 - lvl;
+        if (area)
+            for (let y = H - 1; y >= top; y--)
+                set(x, y);
+        else
+            set(x, top);
+    }
+    const rows = [];
+    for (let cy = 0; cy < height; cy++) {
+        let s = '';
+        for (let cx = 0; cx < width; cx++) {
+            const b = bits[cy * width + cx];
+            s += b ? String.fromCharCode(0x2800 + b) : ' ';
+        }
+        rows.push(color(s));
+    }
+    return rows;
+}
+export const dot = {
+    on: C.accent('●'),
+    off: C.faint('○'),
+    live: chalk.hex('#46e0b0')('●'),
+    warn: C.high('●'),
+    crit: C.critical('●'),
+};
+export const statusDot = (on) => (on ? dot.on : dot.off);
+/** "label  value" with the label dim + padded to a column. */
+export function kv(label, value, pad = 7) {
+    return `${C.faint(label.padEnd(pad))} ${value}`;
+}
+/** A hairline rule, optionally with a section label on the left. */
+export function rule(width = 50, label) {
+    if (!label)
+        return C.faint('─'.repeat(width));
+    const tag = ` ${label.toUpperCase()} `;
+    return C.faint('──') + C.info(tag) + C.faint('─'.repeat(Math.max(0, width - tag.length - 2)));
+}
+/** Collapse $HOME → ~ for tidy paths. */
+export function tidyPath(p) {
+    const h = homedir();
+    return p.startsWith(h) ? '~' + p.slice(h.length) : p;
+}
+/** The ops-console brand splash (global header). */
+export function brandHeader(version) {
+    return panel([
+        `${C.accent('▟█▙')}  ${chrome('DRAGON')} ${C.faint('· stack control')}`,
+        `${C.accent('▜█▛')}  ${C.faint('account.ghosts.lk · v' + version)}`,
+    ], { title: chrome('GHOST PROTOCOL') });
+}
+//# sourceMappingURL=ui.js.map

package/dist/utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared utilities for Dragon CLI.
+ *
+ * Output palette intentionally narrow to match the Dragon Console
+ * web UI (one teal/green accent · severity by intensity, not hue).
+ */
+import { type SpawnOptions } from 'child_process';
+export declare function exec(cmd: string, cwd?: string): string;
+export declare function run(cmd: string, args: string[], cwd: string, opts?: SpawnOptions): Promise<number>;
+export declare function fetchJSON<T = any>(url: string, timeoutMs?: number): Promise<T>;
+export declare const C: {
+    accent: import("chalk").ChalkInstance;
+    hot: import("chalk").ChalkInstance;
+    critical: import("chalk").ChalkInstance;
+    high: import("chalk").ChalkInstance;
+    medium: import("chalk").ChalkInstance;
+    low: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    faint: import("chalk").ChalkInstance;
+};
+export declare function label(text: string): string;
+export declare function eyebrow(num: string | number, text: string): string;
+export declare function dim(text: string): string;
+export declare function error(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function success(msg: string): void;
+export declare function info(msg: string): void;
+export declare function table(rows: Record<string, string>[]): void;
+export declare function isInstalled(dir: string): boolean;
+export declare function isRunning(port?: number, host?: string, timeoutMs?: number): Promise<boolean>;
+export declare function readVersion(dir: string): string | null;
+export declare function lastUpdated(dir: string): string | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAMlE,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAUlG;AAED,wBAAsB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,SAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAUlF;AASD,eAAO,MAAM,CAAC;;;;;;;;;CASb,CAAA;AAID,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExC;AAKD,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAiD;AACzF,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAkD;AACzF,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAA+C;AACzF,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAkD;AAEzF,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CAa1D;AAMD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,SAAc,EAAE,SAAS,SAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAS9F;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4BtD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtD"}

package/dist/utils.js

@@ -0,0 +1,155 @@
+/**
+ * Shared utilities for Dragon CLI.
+ *
+ * Output palette intentionally narrow to match the Dragon Console
+ * web UI (one teal/green accent · severity by intensity, not hue).
+ */
+import { execSync, spawn } from 'child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { createConnection } from 'node:net';
+import chalk from 'chalk';
+export function exec(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch (e) {
+        throw new Error(e.stderr?.trim() || e.message);
+    }
+}
+export function run(cmd, args, cwd, opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: 'inherit',
+            ...opts,
+        });
+        child.on('close', code => resolve(code ?? 1));
+        child.on('error', reject);
+    });
+}
+export async function fetchJSON(url, timeoutMs = 5000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        return res.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ─── brand palette: STEALTH SILVER ─────────────────────────────
+// Mirrors account.ghosts.lk's monochrome scheme (near-black canvas,
+// silver/white accent, zinc muted) — the operator-stealth look. The teal
+// Dragon-Console accent was retired here. Severity stays in hue (function
+// over stealth — a CRITICAL must read as red). Truecolor assumed; legacy
+// 16-color terms fall back to the nearest chalk basic colour.
+export const C = {
+    accent: chalk.hex('#c8d0d8'), // stealth silver · primary
+    hot: chalk.hex('#eef3f7'), // bright silver/white · live / running
+    critical: chalk.hex('#ff5a55'), // red    · severity
+    high: chalk.hex('#fb923c'), // orange · severity
+    medium: chalk.hex('#fbbf24'), // amber  · severity
+    low: chalk.hex('#8ab4e8'), // soft blue
+    info: chalk.hex('#9aa4ad'), // zinc grey
+    faint: chalk.hex('#5b6570'), // dim slate
+};
+// ─── output discipline ─────────────────────────────────────────
+export function label(text) {
+    return C.accent.bold(`[ ${text.toUpperCase()} ]`);
+}
+export function eyebrow(num, text) {
+    return C.accent.bold(`[ ${String(num).padStart(2, '0')} // ${text.toUpperCase()} ]`);
+}
+export function dim(text) {
+    return chalk.dim(text);
+}
+// Severity glyphs + hues match the web UI sev pills:
+//   CRITICAL ⚠ red  ·  HIGH ! orange  ·  MEDIUM amber  ·  LOW blue  ·  INFO grey
+// CLI helpers use the matching colour so error/warn/info read at a glance.
+export function error(msg) { console.error(C.critical.bold('  ⚠'), msg); }
+export function warn(msg) { console.warn(C.high('  !'), msg); }
+export function success(msg) { console.log(C.accent('  ✓'), msg); }
+export function info(msg) { console.log(C.info('  ·'), msg); }
+export function table(rows) {
+    if (rows.length === 0)
+        return;
+    const keys = Object.keys(rows[0]);
+    const widths = keys.map(k => Math.max(k.length, ...rows.map(r => (r[k] || '').length)));
+    const header = keys.map((k, i) => k.padEnd(widths[i])).join('  ');
+    const sep = widths.map(w => '─'.repeat(w)).join('──');
+    console.log(chalk.dim(header));
+    console.log(chalk.dim(sep));
+    rows.forEach(row => {
+        console.log(keys.map((k, i) => (row[k] || '').padEnd(widths[i])).join('  '));
+    });
+}
+// ─── module state probes ──────────────────────────────────────
+// Used by `dragon list` + `dragon doctor` so output reflects reality,
+// not "the repo dir exists therefore ✓".
+export function isInstalled(dir) {
+    return existsSync(join(dir, '.git'));
+}
+export function isRunning(port, host = '127.0.0.1', timeoutMs = 200) {
+    return new Promise((resolve) => {
+        if (!port)
+            return resolve(false);
+        const sock = createConnection({ host, port });
+        const done = (ok) => { try {
+            sock.destroy();
+        }
+        catch { } resolve(ok); };
+        sock.once('connect', () => done(true));
+        sock.once('error', () => done(false));
+        setTimeout(() => done(false), timeoutMs);
+    });
+}
+export function readVersion(dir) {
+    const parsers = {
+        'package.json': (raw) => { try {
+            return JSON.parse(raw).version ?? null;
+        }
+        catch {
+            return null;
+        } },
+        'Cargo.toml': (raw) => raw.match(/^version\s*=\s*"([^"]+)"/m)?.[1] ?? null,
+        'pyproject.toml': (raw) => raw.match(/^version\s*=\s*"([^"]+)"/m)?.[1] ?? null,
+    };
+    // Search the repo root + a handful of conventional monorepo layouts so
+    // packages like Wyrm (no root manifest, version in packages/mcp-server)
+    // still report a version on `dragon list`.
+    const candidates = [
+        dir,
+        join(dir, 'packages', 'mcp-server'),
+        join(dir, 'packages', 'core'),
+        join(dir, 'packages', 'cli'),
+        join(dir, 'apps', 'web'),
+        join(dir, 'apps', 'server'),
+    ];
+    for (const c of candidates) {
+        for (const [fname, parse] of Object.entries(parsers)) {
+            const f = join(c, fname);
+            if (!existsSync(f))
+                continue;
+            try {
+                const v = parse(readFileSync(f, 'utf-8'));
+                if (v)
+                    return v;
+            }
+            catch { /* keep trying */ }
+        }
+    }
+    return null;
+}
+export function lastUpdated(dir) {
+    try {
+        return new Date(statSync(dir).mtime).toISOString().slice(0, 10);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/wyrm/mcp.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Deep Wyrm integration — the agent's memory spine, on by default.
+ *
+ * Spawns the Wyrm MCP server (`wyrm-mcp`) over stdio and:
+ *   - exposes a CURATED subset of Wyrm's tools to the brain (recall, remember,
+ *     capture, search, project/global context, quests, skills, entities, truths)
+ *     so the model can read + write long-term memory mid-task;
+ *   - PRIMES each session with the current project's context, folded into the
+ *     system prompt, so Dragon starts already knowing the project.
+ *
+ * Everything is best-effort: if Wyrm isn't reachable the agent still runs (just
+ * without memory). Tool routing in the loop sends any `wyrm_*` call here.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { ToolSpec } from '../brain/types.js';
+export interface WyrmTool {
+    spec: ToolSpec;
+}
+export declare class Wyrm {
+    private client;
+    private transport;
+    private toolNames;
+    connected: boolean;
+    /** Connect + discover tools (bounded by CONNECT_TIMEOUT). Never throws / hangs. */
+    connect(): Promise<boolean>;
+    private exposed;
+    /** Curated Wyrm tool specs to hand the brain (empty if not connected). */
+    toolSpecs(): ToolSpec[];
+    handles(name: string): boolean;
+    /** Invoke a Wyrm tool; returns a string result for the model (bounded). */
+    call(name: string, args: Record<string, unknown>): Promise<string>;
+    /** Best-effort project context for the system prompt. Never throws. */
+    prime(cwd: string): Promise<string | null>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=mcp.d.ts.map

package/dist/wyrm/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/wyrm/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAgCjD,MAAM,WAAW,QAAQ;IAAG,IAAI,EAAE,QAAQ,CAAA;CAAE;AAE5C,qBAAa,IAAI;IACf,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,SAAS,CAAoB;IACrC,SAAS,UAAQ;IAEjB,mFAAmF;IAC7E,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IA0BjC,OAAO,CAAC,OAAO,CAAiB;IAEhC,0EAA0E;IAC1E,SAAS,IAAI,QAAQ,EAAE;IAIvB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B,2EAA2E;IACrE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAWxE,uEAAuE;IACjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAa1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}

package/dist/wyrm/mcp.js

@@ -0,0 +1,137 @@
+/**
+ * Deep Wyrm integration — the agent's memory spine, on by default.
+ *
+ * Spawns the Wyrm MCP server (`wyrm-mcp`) over stdio and:
+ *   - exposes a CURATED subset of Wyrm's tools to the brain (recall, remember,
+ *     capture, search, project/global context, quests, skills, entities, truths)
+ *     so the model can read + write long-term memory mid-task;
+ *   - PRIMES each session with the current project's context, folded into the
+ *     system prompt, so Dragon starts already knowing the project.
+ *
+ * Everything is best-effort: if Wyrm isn't reachable the agent still runs (just
+ * without memory). Tool routing in the loop sends any `wyrm_*` call here.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** High-value Wyrm tools we surface to the model (the full surface is ~116). */
+const EXPOSED = new Set([
+    'wyrm_recall', 'wyrm_remember', 'wyrm_capture', 'wyrm_search',
+    'wyrm_project_context', 'wyrm_global_context', 'wyrm_context_build',
+    'wyrm_all_quests', 'wyrm_quest_add', 'wyrm_quest_complete',
+    'wyrm_skill_search', 'wyrm_skill_get',
+    'wyrm_entity_search', 'wyrm_truth_get', 'wyrm_truth_set', 'wyrm_decided_because',
+]);
+function wyrmBin() {
+    const candidates = [process.env.WYRM_MCP_BIN, join(homedir(), '.npm-global/bin/wyrm-mcp')].filter(Boolean);
+    for (const c of candidates)
+        if (existsSync(c))
+            return c;
+    return 'wyrm-mcp'; // fall back to PATH
+}
+const CONNECT_TIMEOUT = 8_000; // a slow/hanging Wyrm must never freeze the agent
+const CALL_TIMEOUT = 25_000;
+/** Resolve to `null` if the promise doesn't settle in `ms` (running `onTimeout`). */
+function withTimeout(p, ms, onTimeout) {
+    return new Promise((resolve) => {
+        let done = false;
+        const timer = setTimeout(() => { if (!done) {
+            done = true;
+            onTimeout?.();
+            resolve(null);
+        } }, ms);
+        p.then((v) => { if (!done) {
+            done = true;
+            clearTimeout(timer);
+            resolve(v);
+        } }, () => { if (!done) {
+            done = true;
+            clearTimeout(timer);
+            resolve(null);
+        } });
+    });
+}
+export class Wyrm {
+    client = null;
+    transport = null;
+    toolNames = new Set();
+    connected = false;
+    /** Connect + discover tools (bounded by CONNECT_TIMEOUT). Never throws / hangs. */
+    async connect() {
+        try {
+            this.transport = new StdioClientTransport({ command: wyrmBin(), args: [], stderr: 'ignore' });
+            this.client = new Client({ name: 'dragon-cli', version: '3.7.0' }, { capabilities: {} });
+            const ok = await withTimeout((async () => {
+                await this.client.connect(this.transport);
+                const { tools } = await this.client.listTools();
+                this.exposed = tools
+                    .filter((t) => EXPOSED.has(t.name))
+                    .map((t) => ({ name: t.name, description: t.description ?? '', parameters: t.inputSchema ?? { type: 'object', properties: {} } }));
+                this.exposed.forEach((t) => this.toolNames.add(t.name));
+                return true;
+            })(), CONNECT_TIMEOUT, () => { try {
+                void this.transport?.close();
+            }
+            catch { /* ignore */ } });
+            this.connected = ok === true;
+            if (!this.connected) {
+                try {
+                    await this.client?.close();
+                }
+                catch { /* ignore */ }
+                this.client = null;
+            }
+            return this.connected;
+        }
+        catch {
+            this.connected = false;
+            return false;
+        }
+    }
+    exposed = [];
+    /** Curated Wyrm tool specs to hand the brain (empty if not connected). */
+    toolSpecs() {
+        return this.exposed;
+    }
+    handles(name) {
+        return this.toolNames.has(name);
+    }
+    /** Invoke a Wyrm tool; returns a string result for the model (bounded). */
+    async call(name, args) {
+        if (!this.client)
+            return 'error: Wyrm not connected';
+        const res = await withTimeout(this.client.callTool({ name, arguments: args }), CALL_TIMEOUT);
+        if (res === null)
+            return `error: ${name} timed out`;
+        const text = (res.content ?? []).map((c) => (c.type === 'text' ? c.text ?? '' : `[${c.type}]`)).join('\n').trim();
+        return (res.isError ? 'error: ' : '') + (text || '(no result)');
+    }
+    /** Best-effort project context for the system prompt. Never throws. */
+    async prime(cwd) {
+        if (!this.client)
+            return null;
+        for (const [name, args] of [
+            ['wyrm_project_context', { projectPath: cwd }],
+            ['wyrm_project_context', { project: cwd }],
+        ]) {
+            if (!this.toolNames.has(name))
+                continue;
+            const out = await this.call(name, args);
+            if (out && !out.startsWith('error'))
+                return out.slice(0, 4000);
+        }
+        return null;
+    }
+    async close() {
+        try {
+            await this.client?.close();
+        }
+        catch { /* ignore */ }
+        this.connected = false;
+    }
+}
+//# sourceMappingURL=mcp.js.map