wyrm-mcp 7.3.2 → 7.3.3

package/dist/wyrm-loop.js

@@ -1,6 +1,62 @@
 #!/usr/bin/env node
-import{WyrmDB as m}from"./database.js";import{Goals as f}from"./goals.js";import{AgentLoop as d}from"./agent-loop.js";import{OutboundMcpClient as h}from"./mcp-client.js";function g(e){const t={interval:600,once:!1,maxSteps:3,verbose:process.env.WYRM_LOOP_LOG==="1"};for(let s=0;s<e.length;s++){const o=e[s];o==="--interval"?t.interval=Math.max(10,parseInt(e[++s],10)||600):o==="--once"?t.once=!0:o==="--goal"?t.goalId=parseInt(e[++s],10):o==="--max-steps"?t.maxSteps=Math.max(1,Math.min(20,parseInt(e[++s],10)||3)):o==="--project"?t.projectPath=e[++s]:o==="--verbose"||o==="-v"?t.verbose=!0:(o==="--help"||o==="-h")&&(console.log(w),process.exit(0))}return t}const w=`
-wyrm-loop \u2014 autonomous OODA scheduler
+/**
+ * wyrm-loop — the autonomous scheduler.
+ *
+ * Long-lived daemon. Wakes up every N seconds, picks the highest-priority
+ * active goal that hasn't hit its iteration cap, runs ONE OODA iteration
+ * via AgentLoop, logs to agent_actions + goal_iterations, and goes back
+ * to sleep. Stops a goal once it completes / blocks / errors.
+ *
+ * Usage:
+ *   wyrm-loop                     # default 10-minute interval, loop forever
+ *   wyrm-loop --interval 60       # 60-second interval
+ *   wyrm-loop --once              # one iteration, then exit (cron-friendly)
+ *   wyrm-loop --goal 42           # only this goal
+ *   wyrm-loop --max-steps 3       # max iterations per goal per tick
+ *   wyrm-loop --project /path     # scope to project
+ *
+ * Environment:
+ *   WYRM_DB_PATH              path to wyrm.db (default ~/.wyrm/wyrm.db)
+ *   WYRM_OLLAMA_URL           default http://localhost:11434
+ *   OPENAI_API_KEY            optional fallback
+ *   WYRM_LOOP_LOG             '1' to log every tick to stderr
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ */
+import { WyrmDB } from './database.js';
+import { Goals } from './goals.js';
+import { AgentLoop } from './agent-loop.js';
+import { OutboundMcpClient } from './mcp-client.js';
+function parseArgs(argv) {
+    const out = {
+        interval: 600,
+        once: false,
+        maxSteps: 3,
+        verbose: process.env.WYRM_LOOP_LOG === '1',
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--interval')
+            out.interval = Math.max(10, parseInt(argv[++i], 10) || 600);
+        else if (a === '--once')
+            out.once = true;
+        else if (a === '--goal')
+            out.goalId = parseInt(argv[++i], 10);
+        else if (a === '--max-steps')
+            out.maxSteps = Math.max(1, Math.min(20, parseInt(argv[++i], 10) || 3));
+        else if (a === '--project')
+            out.projectPath = argv[++i];
+        else if (a === '--verbose' || a === '-v')
+            out.verbose = true;
+        else if (a === '--help' || a === '-h') {
+            console.log(USAGE);
+            process.exit(0);
+        }
+    }
+    return out;
+}
+const USAGE = `
+wyrm-loop — autonomous OODA scheduler
 
   wyrm-loop [options]
 
@@ -12,4 +68,95 @@ Options
   --project PATH        Scope to a project root
   --verbose, -v         Log every tick to stderr
   --help, -h            Show this help
-`;function i(e,t){e.verbose&&console.error(`[wyrm-loop ${new Date().toISOString()}] ${t}`)}async function v(e,t,s,o){let r=e.goalId;if(!r){let l;if(e.projectPath){const u=t.getProject(e.projectPath);if(!u)return i(e,`project '${e.projectPath}' not registered \u2014 idle`),!1;l=u.id}const p=s.nextToPursue(l);if(!p)return i(e,"no active goals \u2014 idle"),!1;r=p.id}const c=s.get(r);if(!c||c.status!=="active")return i(e,`goal #${r} not active \u2014 skipping`),!1;i(e,`pursuing goal #${r}: ${c.title.slice(0,80)}`);const n=await o.pursue(r,{max_steps:e.maxSteps});if(n.length===0)return i(e,`goal #${r} returned no iterations`),!1;const a=n[n.length-1];return i(e,`goal #${r} ran ${n.length} iteration(s); last outcome=${a.outcome} (${a.latency_ms}ms, model=${a.model}${a.degraded?" DEGRADED":""})`),!0}async function x(){const e=g(process.argv.slice(2)),t=new m(process.env.WYRM_DB_PATH),s=new f(t.getDatabase()),o=new h(t.getDatabase()),r=async()=>({ok:!1,error:"wyrm-loop does not enable internal tool dispatch in this build \u2014 use the wyrm-mcp server for full agent runs"}),c=new d(t.getDatabase(),o,r);let n=!1;const a=()=>{n||(n=!0,i(e,"shutting down\u2026"),o.shutdown().finally(()=>{try{t.close()}catch{}process.exit(0)}))};for(process.on("SIGINT",a),process.on("SIGTERM",a),e.verbose&&console.error(`wyrm-loop starting \xB7 interval=${e.interval}s \xB7 once=${e.once} \xB7 max-steps=${e.maxSteps}`);!n;){try{await v(e,t,s,c)}catch(l){console.error(`wyrm-loop tick error: ${l.message}`)}if(e.once){a();return}await new Promise(l=>{setTimeout(l,e.interval*1e3)})}}x().catch(e=>{console.error(`wyrm-loop fatal: ${e.message}`),process.exit(1)});
+`;
+function log(args, msg) {
+    if (args.verbose)
+        console.error(`[wyrm-loop ${new Date().toISOString()}] ${msg}`);
+}
+/** Run a single tick. Returns true if work was done, false on idle. */
+async function tick(args, db, goals, agent) {
+    let goalId = args.goalId;
+    if (!goalId) {
+        let projectId;
+        if (args.projectPath) {
+            const p = db.getProject(args.projectPath);
+            if (!p) {
+                log(args, `project '${args.projectPath}' not registered — idle`);
+                return false;
+            }
+            projectId = p.id;
+        }
+        const next = goals.nextToPursue(projectId);
+        if (!next) {
+            log(args, 'no active goals — idle');
+            return false;
+        }
+        goalId = next.id;
+    }
+    const goal = goals.get(goalId);
+    if (!goal || goal.status !== 'active') {
+        log(args, `goal #${goalId} not active — skipping`);
+        return false;
+    }
+    log(args, `pursuing goal #${goalId}: ${goal.title.slice(0, 80)}`);
+    const results = await agent.pursue(goalId, { max_steps: args.maxSteps });
+    if (results.length === 0) {
+        log(args, `goal #${goalId} returned no iterations`);
+        return false;
+    }
+    const last = results[results.length - 1];
+    log(args, `goal #${goalId} ran ${results.length} iteration(s); last outcome=${last.outcome} (${last.latency_ms}ms, model=${last.model}${last.degraded ? ' DEGRADED' : ''})`);
+    return true;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const db = new WyrmDB(process.env.WYRM_DB_PATH);
+    const goals = new Goals(db.getDatabase());
+    const mcp = new OutboundMcpClient(db.getDatabase());
+    // Minimal dispatcher for wyrm-loop — reads only, since this is the
+    // autonomous path and we want safe defaults. Goals can still call
+    // write tools via the standard MCP path (wyrm-mcp server), but loop
+    // ticks stick to a conservative subset.
+    const dispatcher = async () => {
+        return { ok: false, error: 'wyrm-loop does not enable internal tool dispatch in this build — use the wyrm-mcp server for full agent runs' };
+    };
+    const agent = new AgentLoop(db.getDatabase(), mcp, dispatcher);
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        log(args, 'shutting down…');
+        mcp.shutdown().finally(() => {
+            try {
+                db.close();
+            }
+            catch { /* best-effort */ }
+            process.exit(0);
+        });
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    if (args.verbose) {
+        console.error(`wyrm-loop starting · interval=${args.interval}s · once=${args.once} · max-steps=${args.maxSteps}`);
+    }
+    // Loop
+    while (!stopped) {
+        try {
+            await tick(args, db, goals, agent);
+        }
+        catch (err) {
+            console.error(`wyrm-loop tick error: ${err.message}`);
+        }
+        if (args.once) {
+            stop();
+            return;
+        }
+        await new Promise(r => { setTimeout(r, args.interval * 1000); });
+    }
+}
+main().catch(err => {
+    console.error(`wyrm-loop fatal: ${err.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=wyrm-loop.js.map

package/dist/wyrm-manifest.json

@@ -1,6 +1,6 @@
 {
   "contract": "wyrm-cloud-memory-v1",
-  "version": "7.3.2",
+  "version": "7.3.3",
   "generatedBy": "scripts/gen-tool-manifest.mjs (from the dist/ registry modules — never hand-edited)",
   "tiers": {
     "core": [

package/dist/wyrm-statusline-daemon.js

@@ -1,2 +1,12 @@
 #!/usr/bin/env node
-import{runDaemon as m}from"./statusline.js";m();
+/**
+ * wyrm-statusline-daemon — long-lived process serving statusline queries.
+ *
+ * Auto-spawned by the wyrm-statusline binary on first call. Listens on
+ * ~/.wyrm/statusline.sock. Idle-times-out after 5 minutes of no requests.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ */
+import { runDaemon } from './statusline.js';
+runDaemon();
+//# sourceMappingURL=wyrm-statusline-daemon.js.map

package/dist/wyrm-statusline.js

@@ -1,5 +1,57 @@
 #!/usr/bin/env node
-import{queryDaemon as i}from"./statusline.js";function c(s){let o=process.cwd(),n,e=!1;for(let t=2;t<s.length;t++){const r=s[t];r==="--cwd"?o=s[++t]:r==="--session"?n=Number(s[++t]):r==="--json"&&(e=!0)}return{cwd:o,sessionId:n,json:e}}async function p(){const{cwd:s,sessionId:o,json:n}=c(process.argv);try{const e=await i({cwd:s,sessionId:o,privateMode:process.env.WYRM_STATUSLINE_PRIVATE==="1",showSavings:process.env.WYRM_STATUSLINE_SHOW_SAVINGS==="1"});n?process.stdout.write(`${JSON.stringify(e.raw)}
-`):process.stdout.write(`${e.text}
-`)}catch{process.stdout.write(`\u{F115D} Wyrm
-`)}}p();
+/**
+ * wyrm-statusline — print a single statusline string and exit.
+ *
+ * Designed to be invoked from a client's statusline hook every few seconds.
+ * Spawns the wyrm-statusline-daemon if not already running (detached, idle-
+ * times out after 5min). Per-call latency target: ≤ 50ms warm.
+ *
+ * Usage:
+ *   wyrm-statusline                  # default, uses $PWD
+ *   wyrm-statusline --cwd /path      # explicit cwd
+ *   wyrm-statusline --session 142    # explicit session id
+ *   wyrm-statusline --json           # emit raw JSON instead of formatted text
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ */
+import { queryDaemon } from './statusline.js';
+function parseArgs(argv) {
+    let cwd = process.cwd();
+    let sessionId;
+    let json = false;
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--cwd')
+            cwd = argv[++i];
+        else if (a === '--session')
+            sessionId = Number(argv[++i]);
+        else if (a === '--json')
+            json = true;
+    }
+    return { cwd, sessionId, json };
+}
+async function main() {
+    const { cwd, sessionId, json } = parseArgs(process.argv);
+    try {
+        // Forward the binary's per-call env so each invocation can toggle
+        // privacy / savings without daemon restart.
+        const resp = await queryDaemon({
+            cwd,
+            sessionId,
+            privateMode: process.env.WYRM_STATUSLINE_PRIVATE === '1',
+            showSavings: process.env.WYRM_STATUSLINE_SHOW_SAVINGS === '1',
+        });
+        if (json) {
+            process.stdout.write(`${JSON.stringify(resp.raw)}\n`);
+        }
+        else {
+            process.stdout.write(`${resp.text}\n`);
+        }
+    }
+    catch (e) {
+        // Statusline must never crash a client's status bar — always print SOMETHING.
+        process.stdout.write(`󱅝 Wyrm\n`);
+    }
+}
+main();
+//# sourceMappingURL=wyrm-statusline.js.map

package/dist/wyrm-ui.js

@@ -1,10 +1,78 @@
 #!/usr/bin/env node
-import{spawn as s}from"child_process";const n=parseInt(process.env.WYRM_HTTP_PORT??"3333",10)||3333,i="127.0.0.1",o=`http://${i}:${n}`;async function a(){try{return(await fetch(`${o}/health`,{signal:AbortSignal.timeout(1500)})).ok}catch{return!1}}function u(r){switch(process.platform){case"darwin":return["open",[r]];case"win32":return["cmd",["/c","start",'""',r]];default:return["xdg-open",[r]]}}function p(r){const[t,c]=u(r);try{s(t,c,{detached:!0,stdio:"ignore"}).unref(),process.stdout.write(`\u{F115D} Opened ${r}
-`)}catch(e){process.stderr.write(`[wyrm-ui] could not launch browser via ${t}: ${e.message}
-`),process.stdout.write(`Open this URL manually: ${r}
-`)}}async function d(){const r=`${o}/ui`;if(await a()){p(r);return}process.stderr.write(`[wyrm-ui] starting \`wyrm serve --ui\` detached on :${n}
-`);try{s("wyrm",["serve","--ui"],{detached:!0,stdio:"ignore"}).unref(),process.stdout.write(`\u{F115D} Launching the Wyrm dashboard at ${r}
-`)}catch(t){process.stderr.write(`[wyrm-ui] could not start the server: ${t.message}
-`),process.stdout.write(`Run it manually: wyrm serve --ui
-`),process.exit(1)}}d().catch(r=>{process.stderr.write(`[wyrm-ui] fatal: ${r.message}
-`),process.exit(1)});
+/**
+ * 󱅝 wyrm-ui — open the Wyrm web dashboard in the operator's default browser.
+ *
+ * 1. Probes localhost:WYRM_HTTP_PORT (default 3333) for /health.
+ * 2. If a server is already up, opens the browser at /ui.
+ * 3. If nothing is running, delegates to `wyrm serve --ui` — the canonical
+ *    http-fast dashboard (silver-dragon logo + /dragon-mark.svg + live data
+ *    endpoints) with localhost dev-auth — which starts the server AND opens the
+ *    browser itself. (Before 6.8.1 this spawned `wyrm-http`, a *different*
+ *    server whose static /ui never carried the brand mark — the two-dashboard
+ *    split. Both bind :3333, so converging the launcher fixes the inconsistency.)
+ *
+ * Cross-OS shell-out: `xdg-open` (Linux/Termux), `open` (macOS), `start` (Win).
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { spawn } from 'child_process';
+const PORT = parseInt(process.env.WYRM_HTTP_PORT ?? '3333', 10) || 3333;
+const HOST = '127.0.0.1';
+const URL_BASE = `http://${HOST}:${PORT}`;
+async function isHttpUp() {
+    try {
+        const r = await fetch(`${URL_BASE}/health`, { signal: AbortSignal.timeout(1500) });
+        return r.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function platformOpenCmd(target) {
+    switch (process.platform) {
+        case 'darwin': return ['open', [target]];
+        case 'win32': return ['cmd', ['/c', 'start', '""', target]];
+        default: return ['xdg-open', [target]]; // linux / freebsd / termux
+    }
+}
+function openBrowser(target) {
+    const [cmd, argv] = platformOpenCmd(target);
+    try {
+        const proc = spawn(cmd, argv, { detached: true, stdio: 'ignore' });
+        proc.unref();
+        process.stdout.write(`󱅝 Opened ${target}\n`);
+    }
+    catch (e) {
+        process.stderr.write(`[wyrm-ui] could not launch browser via ${cmd}: ${e.message}\n`);
+        process.stdout.write(`Open this URL manually: ${target}\n`);
+    }
+}
+async function main() {
+    const target = `${URL_BASE}/ui`;
+    // Already running → just open the dashboard at /ui (exact path; http-fast's
+    // /ui route is an exact match, not a static-dir prefix).
+    if (await isHttpUp()) {
+        openBrowser(target);
+        return;
+    }
+    // Nothing up → `wyrm serve --ui` starts the http-fast dashboard (with the
+    // silver dragon), enables localhost dev-auth so the browser can load /ui,
+    // and opens the browser itself. Don't double-open here.
+    process.stderr.write(`[wyrm-ui] starting \`wyrm serve --ui\` detached on :${PORT}\n`);
+    try {
+        const proc = spawn('wyrm', ['serve', '--ui'], { detached: true, stdio: 'ignore' });
+        proc.unref();
+        process.stdout.write(`󱅝 Launching the Wyrm dashboard at ${target}\n`);
+    }
+    catch (e) {
+        process.stderr.write(`[wyrm-ui] could not start the server: ${e.message}\n`);
+        process.stdout.write(`Run it manually: wyrm serve --ui\n`);
+        process.exit(1);
+    }
+}
+main().catch((e) => {
+    process.stderr.write(`[wyrm-ui] fatal: ${e.message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=wyrm-ui.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyrm-mcp",
-  "version": "7.3.2",
+  "version": "7.3.3",
   "description": "Local-first persistent memory for AI agents over MCP. Ground truths, negative learning (recorded failures block repeats), decision causality, hybrid recall, live memory streams, run-attributed fleet memory — a structured SQLite memory on your machine, no cloud or LLM required. Claude / Copilot / Cursor / Windsurf / Codex.",
   "type": "module",
   "main": "dist/index.js",