ghost-dragon 4.2.1

package/dist/agent/loop.js

@@ -0,0 +1,135 @@
+/**
+ * The agent loop — Dragon's engine. Runs the model↔tool cycle entirely
+ * client-side so tools touch THIS machine:
+ *
+ *   user → brain.turn(tools) → [tool calls?] → execute locally → feed back → repeat
+ *                                  └ no calls → final answer, done
+ *
+ * Tools come from three sources, routed by name: local coding tools (read/edit/
+ * bash/grep…), the curated Wyrm memory tools (`wyrm_*` → MCP), and the optional
+ * hosted Dragon portal (`portal_ask`). Wyrm is wired by default and the system
+ * prompt tells the model to use it as long-term memory.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { getLocalTool, localToolSpecs } from './tools.js';
+const MAX_STEPS = 60; // hard stop against a runaway tool loop
+export function buildSystemPrompt(opts) {
+    const lines = [
+        'You are Dragon — Ghost Protocol\'s terminal coding agent (the `dragon` CLI). You operate like a senior engineer pair: precise, autonomous, and concise.',
+        `Working directory: ${opts.cwd}. Platform: ${process.platform}. Reasoning brain: ${opts.brainId}.`,
+        '',
+        'TOOLS — you have real local tools (read_file, write_file, edit_file, list_dir, glob, grep, bash). Use them to DO the work, not describe it. Explore before you edit (grep/glob/read). Prefer edit_file over rewriting whole files. After code changes, build/test with bash to verify. Keep going until the task is genuinely done.',
+        'Be surgical: match the surrounding code style, make the smallest change that works, and never invent file paths — find them.',
+    ];
+    lines.push('', 'STACK — you ARE the `dragon` operator console for the Ghost Protocol stack (scale · wyrm · pentest · keep · net). stack_status shows what is installed/running; stack_pentest runs a PhantomDragon web scan (authorized targets only) and stack_keep runs a DragonKeep system scan — both return STRUCTURED findings; stack_run drives any other dragon subcommand. You are a coding agent AND an operator — reach for the stack when the task is ops, not code.');
+    if (opts.skills) {
+        lines.push('', `SKILLS — you have ${opts.skills} reusable expert playbooks (design, security, infra, brand, project-specific). Before solving a non-trivial task from scratch, call skill_search for a relevant one and skill_read it, then apply its guidance. This institutional knowledge is your edge — reach for it first.`);
+    }
+    if (opts.wyrm) {
+        lines.push('', 'MEMORY (Wyrm) — you have persistent cross-session memory via the wyrm_* tools, and you should use it proactively:', '• Before non-trivial work, recall context with wyrm_recall / wyrm_search / wyrm_project_context.', '• Capture durable decisions, lessons, and gotchas with wyrm_remember / wyrm_capture so future sessions inherit them.', '• Track multi-step work as quests (wyrm_quest_add / wyrm_quest_complete). Record decisions with wyrm_decided_because.', '• Reach for an existing skill via wyrm_skill_search before solving something from scratch.', 'Read memory freely without asking. This is what makes you better than a stateless assistant.');
+    }
+    if (opts.portal) {
+        lines.push('', 'PORTAL — use portal_ask for the operator\'s Ghost Protocol account/licenses/catalog/services questions (it reaches the hosted account.ghosts.lk assistant). Not for coding.');
+    }
+    lines.push('', 'STYLE — terse, operator-grade, GitHub-flavored markdown. No filler, no emoji. Reference code as `path:line`. State what you did, not what you\'re "about to" do.');
+    if (opts.primed) {
+        lines.push('', '── Project context recalled from Wyrm (treat as background, verify before relying on specifics) ──', opts.primed);
+    }
+    return lines.join('\n');
+}
+/** Build the full tool surface handed to the brain this session. */
+export function buildToolSpecs(deps) {
+    return [
+        ...localToolSpecs(),
+        ...(deps.skills?.toolSpecs() ?? []),
+        ...(deps.stack?.specs ?? []),
+        ...(deps.mcp?.toolSpecs() ?? []),
+        ...(deps.task ? [deps.task.spec] : []),
+        ...(deps.wyrm?.toolSpecs() ?? []),
+        ...(deps.portal ? [deps.portal.spec] : []),
+    ];
+}
+async function dispatch(call, deps) {
+    const { name, arguments: args } = call;
+    if (deps.skills?.handles(name))
+        return deps.skills.call(name, args);
+    if (deps.stack?.handles(name))
+        return deps.stack.call(name, args, deps.toolCtx);
+    if (deps.mcp?.handles(name))
+        return deps.mcp.call(name, args);
+    if (deps.task && name === deps.task.spec.name)
+        return deps.task.call(args);
+    if (deps.wyrm?.handles(name))
+        return deps.wyrm.call(name, args);
+    if (deps.portal && name === deps.portal.spec.name)
+        return deps.portal.call(args);
+    const tool = getLocalTool(name);
+    if (!tool)
+        return `error: unknown tool "${name}"`;
+    try {
+        return await tool.run(args, deps.toolCtx);
+    }
+    catch (e) {
+        return `error running ${name}: ${String(e instanceof Error ? e.message : e)}`;
+    }
+}
+function toolSummary(call, deps) {
+    const local = getLocalTool(call.name);
+    if (local)
+        return local.summary(call.arguments);
+    if (deps.skills?.handles(call.name))
+        return `${call.name}: ${String(call.arguments.query ?? call.arguments.name ?? '')}`;
+    if (deps.stack?.handles(call.name)) {
+        if (call.name === 'stack_pentest')
+            return `pentest: ${String(call.arguments.url ?? '')}`;
+        if (call.name === 'stack_keep')
+            return `keep: ${String(call.arguments.scan_type ?? 'quick')}`;
+        if (call.name === 'stack_status')
+            return 'stack_status';
+        return `stack: ${String(call.arguments.command ?? '')}`;
+    }
+    if (call.name === deps.task?.spec.name)
+        return `task: ${String(call.arguments.task ?? '').slice(0, 60)}`;
+    if (deps.mcp?.handles(call.name))
+        return call.name;
+    if (deps.wyrm?.handles(call.name))
+        return `${call.name}`;
+    if (call.name === deps.portal?.spec.name)
+        return `portal: ${String(call.arguments.question ?? '').slice(0, 60)}`;
+    return call.name;
+}
+/**
+ * Run one user message to completion (through any number of tool steps).
+ * Mutates deps.messages so the conversation persists across calls.
+ */
+export async function runAgent(deps, userText, render, signal) {
+    const tools = buildToolSpecs(deps);
+    deps.messages.push({ role: 'user', content: userText });
+    for (let step = 0; step < MAX_STEPS; step++) {
+        let started = false;
+        const turn = await deps.brain.turn({
+            system: deps.system,
+            messages: deps.messages,
+            tools,
+            signal,
+            onDelta: (d) => { if (!started) {
+                render.onAssistantStart();
+                started = true;
+            } render.onDelta(d); },
+        });
+        deps.messages.push({ role: 'assistant', content: turn.text, toolCalls: turn.toolCalls.length ? turn.toolCalls : undefined });
+        if (!turn.toolCalls.length)
+            return; // settled — final answer streamed
+        for (const call of turn.toolCalls) {
+            const summary = toolSummary(call, deps);
+            render.onToolStart(summary);
+            const result = await dispatch(call, deps);
+            const ok = !result.startsWith('error');
+            render.onToolEnd(summary, result.split('\n')[0]?.slice(0, 120) ?? '', ok);
+            deps.messages.push({ role: 'tool', content: result, toolCallId: call.id, toolName: call.name });
+        }
+    }
+    render.onDelta(`\n[stopped after ${MAX_STEPS} tool steps]`);
+}
+//# sourceMappingURL=loop.js.map

package/dist/agent/mcp.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MCP hub — connect ANY Model Context Protocol server (configured via `dragon mcp
+ * add`) and expose its tools to the agent. Dragon inherits the entire MCP ecosystem
+ * without forking: filesystem, GitHub, Postgres, Playwright, your own servers…
+ *
+ * Tools are namespaced `<server>__<tool>` to avoid collisions with built-in tools and
+ * across servers. Everything is bounded (connect + call timeouts) and best-effort — an
+ * unreachable server never blocks the agent.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { ToolSpec } from '../brain/types.js';
+export interface McpServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare class McpHub {
+    private clients;
+    private specs;
+    private route;
+    connected: boolean;
+    /** Connect every configured server (bounded). Never throws. */
+    connect(servers: Record<string, McpServerConfig>): Promise<void>;
+    get serverCount(): number;
+    toolSpecs(): ToolSpec[];
+    handles(name: string): boolean;
+    call(name: string, args: Record<string, unknown>): Promise<string>;
+    close(): Promise<void>;
+}
+/** Build + connect the hub from config (null if no servers configured). */
+export declare function loadMcpHub(servers?: Record<string, McpServerConfig>): Promise<McpHub | null>;
+//# sourceMappingURL=mcp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/agent/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD,MAAM,WAAW,eAAe;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;AAanG,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,KAAK,CAAsD;IACnE,SAAS,UAAQ;IAEjB,+DAA+D;IACzD,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BtE,IAAI,WAAW,IAAI,MAAM,CAA6B;IACtD,SAAS,IAAI,QAAQ,EAAE;IACvB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAExB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAWlE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B;AAED,2EAA2E;AAC3E,wBAAsB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAKlG"}

package/dist/agent/mcp.js

@@ -0,0 +1,107 @@
+/**
+ * MCP hub — connect ANY Model Context Protocol server (configured via `dragon mcp
+ * add`) and expose its tools to the agent. Dragon inherits the entire MCP ecosystem
+ * without forking: filesystem, GitHub, Postgres, Playwright, your own servers…
+ *
+ * Tools are namespaced `<server>__<tool>` to avoid collisions with built-in tools and
+ * across servers. Everything is bounded (connect + call timeouts) and best-effort — an
+ * unreachable server never blocks the agent.
+ *
+ * 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';
+const CONNECT_TIMEOUT = 8_000;
+const CALL_TIMEOUT = 30_000;
+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 McpHub {
+    clients = new Map();
+    specs = [];
+    route = new Map();
+    connected = false;
+    /** Connect every configured server (bounded). Never throws. */
+    async connect(servers) {
+        for (const [name, cfg] of Object.entries(servers ?? {})) {
+            let transport = null;
+            try {
+                transport = new StdioClientTransport({ command: cfg.command, args: cfg.args ?? [], env: { ...process.env, ...(cfg.env ?? {}) }, stderr: 'ignore' });
+                const client = new Client({ name: 'dragon-cli', version: '3.6.0' }, { capabilities: {} });
+                const t = transport;
+                const ok = await withTimeout((async () => {
+                    await client.connect(t);
+                    const { tools } = await client.listTools();
+                    for (const tool of tools) {
+                        const ns = `${name}__${tool.name}`;
+                        this.specs.push({ name: ns, description: `[${name}] ${tool.description ?? ''}`.slice(0, 1024), parameters: tool.inputSchema ?? { type: 'object', properties: {} } });
+                        this.route.set(ns, { server: name, tool: tool.name });
+                    }
+                    return true;
+                })(), CONNECT_TIMEOUT, () => { try {
+                    void transport?.close();
+                }
+                catch { /* ignore */ } });
+                if (ok)
+                    this.clients.set(name, client);
+                else
+                    try {
+                        await client.close();
+                    }
+                    catch { /* ignore */ }
+            }
+            catch { /* skip this server */ }
+        }
+        this.connected = this.clients.size > 0;
+    }
+    get serverCount() { return this.clients.size; }
+    toolSpecs() { return this.specs; }
+    handles(name) { return this.route.has(name); }
+    async call(name, args) {
+        const r = this.route.get(name);
+        if (!r)
+            return 'error: unknown MCP tool';
+        const client = this.clients.get(r.server);
+        if (!client)
+            return `error: MCP server "${r.server}" not connected`;
+        const res = await withTimeout(client.callTool({ name: r.tool, 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)');
+    }
+    async close() {
+        for (const c of this.clients.values()) {
+            try {
+                await c.close();
+            }
+            catch { /* ignore */ }
+        }
+        this.connected = false;
+    }
+}
+/** Build + connect the hub from config (null if no servers configured). */
+export async function loadMcpHub(servers) {
+    if (!servers || !Object.keys(servers).length)
+        return null;
+    const hub = new McpHub();
+    await hub.connect(servers);
+    return hub.serverCount ? hub : null;
+}
+//# sourceMappingURL=mcp.js.map

package/dist/agent/session.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Session persistence — save the conversation on exit (so `dragon chat --resume`
+ * picks up where you left off) and export a clean markdown transcript (`/save`).
+ * Stored under ~/.dragon/sessions, 0600 (may contain code/context).
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { BrainMessage } from '../brain/types.js';
+export declare function saveSession(messages: BrainMessage[], meta: {
+    cwd: string;
+    brain: string;
+}): void;
+export declare function loadLastSession(): BrainMessage[] | null;
+/** Export the conversation as markdown (tool results omitted as noise). Returns the path. */
+export declare function exportMarkdown(messages: BrainMessage[], file?: string): string;
+//# sourceMappingURL=session.d.ts.map

package/dist/agent/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/agent/session.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAKrD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOhG;AAED,wBAAgB,eAAe,IAAI,YAAY,EAAE,GAAG,IAAI,CAMvD;AAED,6FAA6F;AAC7F,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAa9E"}

package/dist/agent/session.js

@@ -0,0 +1,55 @@
+/**
+ * Session persistence — save the conversation on exit (so `dragon chat --resume`
+ * picks up where you left off) and export a clean markdown transcript (`/save`).
+ * Stored under ~/.dragon/sessions, 0600 (may contain code/context).
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { mkdirSync, writeFileSync, readFileSync, existsSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DIR = join(homedir(), '.dragon', 'sessions');
+const LAST = join(DIR, 'last.json');
+export function saveSession(messages, meta) {
+    try {
+        if (!messages.length)
+            return;
+        mkdirSync(DIR, { recursive: true, mode: 0o700 });
+        writeFileSync(LAST, JSON.stringify({ ts: new Date().toISOString(), ...meta, messages }), { mode: 0o600 });
+        chmodSync(LAST, 0o600);
+    }
+    catch { /* never break exit over a save */ }
+}
+export function loadLastSession() {
+    try {
+        if (!existsSync(LAST))
+            return null;
+        const o = JSON.parse(readFileSync(LAST, 'utf-8'));
+        return Array.isArray(o.messages) && o.messages.length ? o.messages : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Export the conversation as markdown (tool results omitted as noise). Returns the path. */
+export function exportMarkdown(messages, file) {
+    const md = [`# Dragon session — ${new Date().toISOString()}`, ''];
+    for (const m of messages) {
+        if (m.role === 'user')
+            md.push(`## You\n\n${m.content}\n`);
+        else if (m.role === 'assistant' && m.content)
+            md.push(`## Dragon\n\n${m.content}\n`);
+        else if (m.role === 'assistant' && m.toolCalls?.length)
+            md.push(`_ran: ${m.toolCalls.map((t) => t.name).join(', ')}_\n`);
+    }
+    const out = md.join('\n');
+    if (file) {
+        writeFileSync(file, out);
+        return file;
+    }
+    mkdirSync(DIR, { recursive: true, mode: 0o700 });
+    const f = join(DIR, `transcript-${new Date().toISOString().replace(/[:.]/g, '-')}.md`);
+    writeFileSync(f, out);
+    return f;
+}
+//# sourceMappingURL=session.js.map

package/dist/agent/skills.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Skills-as-tools — the moat. Ghost Protocol's skill library (200+ reusable expert
+ * playbooks under ~/.copilot/skills) becomes live agent capability: the agent can
+ * `skill_search` for a relevant playbook and `skill_read` it to apply its guidance
+ * mid-task, instead of solving everything from cold.
+ *
+ * A dedicated, READ-ONLY library reader — deliberately separate from the cwd-confined
+ * file tools (the skill dir lives outside any project cwd, but it's our own curated,
+ * non-secret content, so reading it is safe + intentional).
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { ToolSpec } from '../brain/types.js';
+export interface SkillMeta {
+    name: string;
+    description: string;
+    path: string;
+}
+/** Minimal YAML frontmatter parse (name + description, inline or folded) — no dep. */
+export declare function parseFrontmatter(text: string): {
+    name?: string;
+    description?: string;
+};
+export declare class SkillLibrary {
+    private index;
+    load(): void;
+    get count(): number;
+    search(query: string, limit?: number): SkillMeta[];
+    read(name: string): string | null;
+    toolSpecs(): ToolSpec[];
+    handles(name: string): boolean;
+    call(name: string, args: Record<string, unknown>): string;
+}
+/** Build + load the library (empty + harmless if no skill dirs exist). */
+export declare function loadSkillLibrary(): SkillLibrary;
+//# sourceMappingURL=skills.d.ts.map

package/dist/agent/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/agent/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAKjD,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAE9E,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAwBtF;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAkB;IAE/B,IAAI,IAAI,IAAI;IAmBZ,IAAI,KAAK,IAAI,MAAM,CAA6B;IAEhD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,SAAS,EAAE;IAgB7C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAUjC,SAAS,IAAI,QAAQ,EAAE;IAgBvB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAE9B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;CAY1D;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,IAAI,YAAY,CAI/C"}

package/dist/agent/skills.js

@@ -0,0 +1,153 @@
+/**
+ * Skills-as-tools — the moat. Ghost Protocol's skill library (200+ reusable expert
+ * playbooks under ~/.copilot/skills) becomes live agent capability: the agent can
+ * `skill_search` for a relevant playbook and `skill_read` it to apply its guidance
+ * mid-task, instead of solving everything from cold.
+ *
+ * A dedicated, READ-ONLY library reader — deliberately separate from the cwd-confined
+ * file tools (the skill dir lives outside any project cwd, but it's our own curated,
+ * non-secret content, so reading it is safe + intentional).
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const SKILL_DIRS = [process.env.DRAGON_SKILLS_DIR, join(homedir(), '.copilot/skills'), join(homedir(), '.claude/skills')].filter(Boolean);
+const MAX_SKILL_CHARS = 14_000;
+/** Minimal YAML frontmatter parse (name + description, inline or folded) — no dep. */
+export function parseFrontmatter(text) {
+    const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return {};
+    const lines = m[1].split(/\r?\n/);
+    let name;
+    let description;
+    const unquote = (s) => s.replace(/^["']|["']$/g, '').trim();
+    for (let i = 0; i < lines.length; i++) {
+        let mm;
+        if ((mm = lines[i].match(/^name:\s*(.+)$/)))
+            name = unquote(mm[1]);
+        else if ((mm = lines[i].match(/^description:\s*(.*)$/))) {
+            let d = mm[1].trim();
+            if (d === '' || d === '>' || d === '|' || d === '>-' || d === '|-') {
+                const cont = [];
+                for (let j = i + 1; j < lines.length; j++) {
+                    if (/^\s+\S/.test(lines[j]))
+                        cont.push(lines[j].trim());
+                    else
+                        break;
+                }
+                d = cont.join(' ');
+            }
+            description = unquote(d);
+        }
+    }
+    return { name, description };
+}
+export class SkillLibrary {
+    index = [];
+    load() {
+        const seen = new Set();
+        for (const dir of SKILL_DIRS) {
+            if (!existsSync(dir))
+                continue;
+            let entries;
+            try {
+                entries = readdirSync(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                const skillFile = join(dir, entry, 'SKILL.md');
+                if (!existsSync(skillFile))
+                    continue;
+                let fm;
+                try {
+                    fm = parseFrontmatter(readFileSync(skillFile, 'utf-8'));
+                }
+                catch {
+                    continue;
+                }
+                const name = fm.name || entry;
+                if (seen.has(name))
+                    continue; // first dir wins (~/.copilot is canonical)
+                seen.add(name);
+                this.index.push({ name, description: fm.description ?? '', path: skillFile });
+            }
+        }
+    }
+    get count() { return this.index.length; }
+    search(query, limit = 8) {
+        const terms = query.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
+        if (!terms.length)
+            return [];
+        const scored = this.index.map((s) => {
+            const name = s.name.toLowerCase();
+            const desc = s.description.toLowerCase();
+            let score = 0;
+            for (const t of terms) {
+                if (name.includes(t))
+                    score += 5;
+                if (desc.includes(t))
+                    score += 1;
+            }
+            return { s, score };
+        }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+        return scored.slice(0, limit).map((x) => x.s);
+    }
+    read(name) {
+        const want = name.toLowerCase().trim();
+        const hit = this.index.find((s) => s.name.toLowerCase() === want) ?? this.index.find((s) => s.name.toLowerCase().includes(want));
+        if (!hit)
+            return null;
+        try {
+            const body = readFileSync(hit.path, 'utf-8');
+            return body.length > MAX_SKILL_CHARS ? body.slice(0, MAX_SKILL_CHARS) + '\n… [truncated]' : body;
+        }
+        catch {
+            return null;
+        }
+    }
+    toolSpecs() {
+        if (!this.count)
+            return [];
+        return [
+            {
+                name: 'skill_search',
+                description: `Search Ghost Protocol's library of ${this.count} reusable expert skills (playbooks for design, security, infra, brand, specific projects). Use BEFORE solving a non-trivial task from scratch — there's likely a skill for it. Returns matching skill names + summaries; then skill_read one.`,
+                parameters: { type: 'object', properties: { query: { type: 'string', description: 'what you need help with, e.g. "harden a cli" or "premium dark web design"' } }, required: ['query'] },
+            },
+            {
+                name: 'skill_read',
+                description: 'Read the full content of a named skill (from skill_search) and apply its guidance to the task.',
+                parameters: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+            },
+        ];
+    }
+    handles(name) { return name === 'skill_search' || name === 'skill_read'; }
+    call(name, args) {
+        if (name === 'skill_search') {
+            const hits = this.search(String(args.query ?? ''));
+            if (!hits.length)
+                return 'no matching skills';
+            return hits.map((s) => `• ${s.name} — ${s.description.slice(0, 180)}`).join('\n');
+        }
+        if (name === 'skill_read') {
+            const body = this.read(String(args.name ?? ''));
+            return body ?? `no skill named "${args.name}" (use skill_search first)`;
+        }
+        return 'error: unknown skill tool';
+    }
+}
+/** Build + load the library (empty + harmless if no skill dirs exist). */
+export function loadSkillLibrary() {
+    const lib = new SkillLibrary();
+    try {
+        lib.load();
+    }
+    catch { /* never block the agent over skills */ }
+    return lib;
+}
+//# sourceMappingURL=skills.js.map

package/dist/agent/stack.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Stack-fused tools — the agent IS the operator console. It can read the live Ghost
+ * Protocol stack state and drive `dragon` subcommands (scale/wyrm/pentest/keep/net…)
+ * as first-class tools, not just guess at bash.
+ *
+ * Safety: read-only verbs run freely; everything else (pentest, deploy, install…) is
+ * `dangerous` → always prompts + shows the full command (never covered by --auto).
+ * Interactive/recursive/long-lived verbs (chat/ask/login/serve/up) are refused.
+ * Each invocation is a fresh subprocess of THIS CLI, time-bounded + output-capped.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { ToolSpec } from '../brain/types.js';
+import type { ToolContext } from './tools.js';
+export interface StackTools {
+    specs: ToolSpec[];
+    handles(name: string): boolean;
+    call(name: string, args: Record<string, unknown>, ctx: ToolContext): Promise<string>;
+}
+export declare function makeStackTools(): StackTools;
+//# sourceMappingURL=stack.d.ts.map

package/dist/agent/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/agent/stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAyC7C,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAC9B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACrF;AAED,wBAAgB,cAAc,IAAI,UAAU,CA8C3C"}