wyrm-mcp 7.2.1 → 7.2.2

package/dist/golden.js

@@ -1,355 +1,3 @@
-/**
- * Golden-transcript capture — Wyrm 7.0 BROOD, Phase F1 (T003b).
- *
- * Opt-in (`WYRM_GOLDEN_CAPTURE=1`, default OFF — Article VII) full-fidelity
- * request/response JSONL capture at the single CallTool dispatch choke point
- * (src/index.ts), covering BOTH dispatch families (handlerRegistry + the
- * switch) plus the cache-hit early return and both catch returns. This is the
- * fidelity `tool_call_log` deliberately lacks (its args_summary is truncated +
- * value-stripped by design — frequency/coverage ranking only, NOT replayable).
- * The corpus feeds the T021 alias-spine replay gate.
- *
- * Design spec: specs/wyrm-v7-brood/research/golden-capture-spec.md
- *
- * Contract (the `emitEvent` contract — src/events.ts):
- *  - NEVER throws and never blocks the tool path; entire body try/catch,
- *    warn to stderr only (stdout is the MCP transport).
- *  - Circuit breaker: 5 consecutive write failures disable capture for the
- *    process lifetime with a single warning (no warn-per-call storm on a
- *    full disk).
- *  - Lazy init: dir creation attempted on first capture, not at startup.
- *  - Article III: pure local fs append — no LLM, no network, no new deps.
- *  - Secrets redacted BY KEY (recursive, request AND response, on a deep
- *    clone — the live result object is still on its way to the client and is
- *    never mutated), plus a value-pattern safety net for secrets smuggled
- *    through benign fields. Redacted paths are recorded in `redactions[]` so
- *    replay can wildcard them.
- */
-import { appendFileSync, mkdirSync, existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-/**
- * Failure warnings go DIRECTLY to stderr (the deprecations.ts pattern) — never
- * through the logger. The header contract ("warn to stderr only") must hold by
- * construction on the stdio CallTool path, independent of any logger console
- * configuration. Failure-isolated: never throws.
- */
-function warnStderr(message, err) {
-    try {
-        const detail = err === undefined ? "" : ` (${err instanceof Error ? err.message : String(err)})`;
-        process.stderr.write(`[wyrm] ${message}${detail}\n`);
-    }
-    catch {
-        /* warnings must never break a tool call */
-    }
-}
-// ---------------------------------------------------------------------------
-// Redaction rules (golden-capture-spec.md §3)
-// ---------------------------------------------------------------------------
-/** Rule 1 — substring match on key names (case-insensitive): always redact. */
-const SUBSTRING_REDACT = [
-    "token",
-    "secret",
-    "password",
-    "passwd",
-    "authorization",
-    "passphrase",
-    "bearer",
-    "credential",
-    "apikey",
-    "api_key",
-    // wyrm_activate's `license` arg is a signed bearer-style entitlement
-    // credential; no VALUE_PATTERN recognizes signed-license JSON, so the key
-    // rule must catch it (golden-capture-spec.md §3 amendment).
-    "license",
-];
-/**
- * Rule 3 — per-tool overrides: keys whose ENTIRE value subtree has every value
- * redacted regardless of key names (arbitrary env names can carry secrets that
- * no key rule catches).
- */
-const TOOL_REDACT_ALL_VALUES = {
-    wyrm_mcp_register: new Set(["env"]),
-};
-/**
- * Rule 4 — value-pattern safety net on every string value regardless of key
- * name. Catches secrets smuggled through benign fields (value, notes,
- * response text).
- */
-const VALUE_PATTERNS = [
-    { label: "jwt", re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]*/ },
-    { label: "github-token", re: /\bgh[posu]_[A-Za-z0-9]{16,}\b/ },
-    { label: "npm-token", re: /\bnpm_[A-Za-z0-9]{16,}\b/ },
-    { label: "api-key", re: /\b[sp]k-[A-Za-z0-9_-]{16,}\b/ },
-    { label: "aws-access-key", re: /\bAKIA[0-9A-Z]{16}\b/ },
-    { label: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
-    { label: "pem-private-key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    // Generic bearer credentials smuggled under benign keys (plausible inside
-    // wyrm_call_external proxied args). The {16,} run keeps prose like
-    // "Bearer token authentication" unmatched.
-    { label: "bearer", re: /\bBearer\s+[A-Za-z0-9._~+\/-]{16,}/ },
-];
-/** Operator escape hatch: extra key names (exact, case-insensitive) to redact. */
-function extraRedactKeys() {
-    const raw = process.env.WYRM_GOLDEN_REDACT_EXTRA;
-    if (!raw)
-        return new Set();
-    return new Set(raw
-        .split(",")
-        .map((s) => s.trim().toLowerCase())
-        .filter(Boolean));
-}
-/**
- * Should this key's value be redacted outright?
- *  - Rule 1: substring match against SUBSTRING_REDACT (+ exact extras).
- *  - Rule 2: compound-suffix `*key` (privateKey, ssh_key, access-key,
- *    signingKey) — EXCEPT the exact bare name `key`, which in Wyrm is a
- *    required benign identifier on 6+ core tools (data store, set_global,
- *    references, design tokens — incl. the #3 most-called tool). Redacting it
- *    would make those write transcripts unreplayable; the value-pattern net
- *    backstops the residual risk. Deliberate, documented deviation
- *    (golden-capture-spec.md §6.1).
- */
-function keyIsSecret(key, extras) {
-    const lower = key.toLowerCase();
-    if (extras.has(lower))
-        return true;
-    for (const s of SUBSTRING_REDACT) {
-        if (lower.includes(s))
-            return true;
-    }
-    if (lower !== "key" && lower.endsWith("key"))
-        return true;
-    return false;
-}
-/**
- * Deep-clone-and-redact in one pass. Walks the ORIGINAL (never mutates it) and
- * builds the redacted copy. Cycles and non-serializable leaves degrade to
- * `{"$unserializable": true}` — the record still captures rather than being
- * dropped whole (mirrors emitEvent's payload-stringify isolation).
- */
-function redactWalk(value, path, ctx, redactAll) {
-    // Primitives
-    if (value === null || value === undefined)
-        return value;
-    const t = typeof value;
-    if (t === "string") {
-        if (redactAll) {
-            ctx.redactions.push(path);
-            return "[REDACTED]";
-        }
-        for (const { label, re } of VALUE_PATTERNS) {
-            if (re.test(value)) {
-                ctx.redactions.push(path);
-                return `[REDACTED:${label}]`;
-            }
-        }
-        return value;
-    }
-    if (t === "number" || t === "boolean") {
-        if (redactAll) {
-            ctx.redactions.push(path);
-            return "[REDACTED]";
-        }
-        return value;
-    }
-    if (t === "bigint" || t === "function" || t === "symbol") {
-        return { $unserializable: true };
-    }
-    // Binary views (Buffer, TypedArray, DataView, ArrayBuffer) must NOT fall
-    // through to Object.entries(): a Buffer would serialize as numeric byte
-    // values ({"0":115,"1":101,…} — trivially reconstructible) and the
-    // string-only VALUE_PATTERNS net would never see the content. Degrade like
-    // every other non-serializable leaf (golden-capture-spec.md §3 amendment).
-    if (Buffer.isBuffer(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
-        return { $unserializable: true };
-    }
-    // Objects / arrays
-    const obj = value;
-    if (ctx.seen.has(obj))
-        return { $unserializable: true };
-    ctx.seen.add(obj);
-    try {
-        if (Array.isArray(value)) {
-            return value.map((item, i) => redactWalk(item, `${path}.${i}`, ctx, redactAll));
-        }
-        if (value instanceof Date)
-            return value.toISOString();
-        const out = {};
-        const overrides = TOOL_REDACT_ALL_VALUES[ctx.tool];
-        for (const [k, v] of Object.entries(value)) {
-            const childPath = `${path}.${k}`;
-            if (redactAll) {
-                // Inside a redact-all subtree: every leaf value is redacted.
-                out[k] = redactWalk(v, childPath, ctx, true);
-            }
-            else if (keyIsSecret(k, ctx.extras)) {
-                ctx.redactions.push(childPath);
-                out[k] = "[REDACTED]";
-            }
-            else if (overrides?.has(k)) {
-                out[k] = redactWalk(v, childPath, ctx, true);
-            }
-            else {
-                out[k] = redactWalk(v, childPath, ctx, false);
-            }
-        }
-        return out;
-    }
-    finally {
-        ctx.seen.delete(obj);
-    }
-}
-/**
- * Redact a value tree for a given tool, recording redacted paths into
- * `redactions`. Exported for direct unit testing.
- */
-export function redactForGolden(tool, value, rootPath, redactions) {
-    const ctx = { tool, extras: extraRedactKeys(), redactions, seen: new WeakSet() };
-    return redactWalk(value, rootPath, ctx, false);
-}
-// ---------------------------------------------------------------------------
-// Capture state (per process)
-// ---------------------------------------------------------------------------
-const MAX_CONSECUTIVE_WRITE_FAILURES = 5;
-const state = {
-    seq: 0,
-    writeFailures: 0,
-    disabled: false,
-    warned: false,
-};
-const SESSION_ID = `${process.pid}-${Math.floor(Date.now() / 1000)}`;
-let _version = null;
-/** Lazy wyrm-mcp version (same package.json walk as index.ts; cached). */
-function wyrmVersion() {
-    if (_version)
-        return _version;
-    try {
-        const here = dirname(fileURLToPath(import.meta.url));
-        for (const p of [join(here, "..", "package.json"), join(here, "..", "..", "package.json")]) {
-            if (existsSync(p)) {
-                const v = JSON.parse(readFileSync(p, "utf-8")).version;
-                if (typeof v === "string") {
-                    _version = v;
-                    return v;
-                }
-            }
-        }
-    }
-    catch {
-        /* fall through */
-    }
-    _version = "unknown";
-    return _version;
-}
-/** Flag check — lazy per call (cheap string compare), default OFF. */
-export function isGoldenCaptureEnabled() {
-    const v = process.env.WYRM_GOLDEN_CAPTURE;
-    return v === "1" || v === "true";
-}
-function goldenDir() {
-    const d = process.env.WYRM_GOLDEN_DIR?.trim();
-    return d && d.length > 0 ? d : join(homedir(), ".wyrm", "golden");
-}
-function goldenFilePath(dir) {
-    const now = new Date();
-    const ymd = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")}`;
-    return join(dir, `golden-${ymd}-${process.pid}.jsonl`);
-}
-/**
- * Append one pre-serialized line. Failure feeds the circuit breaker — after
- * MAX_CONSECUTIVE_WRITE_FAILURES consecutive failures, capture is disabled for
- * the rest of the process lifetime (warned once).
- */
-function writeLine(line) {
-    try {
-        const dir = goldenDir();
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-        appendFileSync(goldenFilePath(dir), line, { mode: 0o600 });
-        state.writeFailures = 0;
-    }
-    catch (err) {
-        state.writeFailures++;
-        if (state.writeFailures >= MAX_CONSECUTIVE_WRITE_FAILURES) {
-            state.disabled = true;
-            if (!state.warned) {
-                state.warned = true;
-                warnStderr(`golden: capture disabled for this process after ${state.writeFailures} consecutive write failures`, err);
-            }
-        }
-        else {
-            warnStderr("golden: capture dropped (write failed)", err);
-        }
-    }
-}
-/** Derive outcome from a response when the call site didn't pin one. */
-function deriveOutcome(response) {
-    const r = response;
-    if (r && typeof r === "object" && r.isError) {
-        const text = Array.isArray(r.content) ? r.content[0]?.text : undefined;
-        if (typeof text === "string" && text.startsWith("Unknown tool:"))
-            return "unknown_tool";
-        return "soft_error";
-    }
-    return "ok";
-}
-// ---------------------------------------------------------------------------
-// The capture entry point — called at all four response-producing sites
-// ---------------------------------------------------------------------------
-/**
- * Capture one CallTool round-trip as a JSONL golden record. NEVER throws,
- * never blocks; no-op unless WYRM_GOLDEN_CAPTURE=1 (Article VII: default OFF).
- */
-export function goldenCapture(input) {
-    try {
-        if (state.disabled)
-            return;
-        if (!isGoldenCaptureEnabled())
-            return;
-        const redactions = [];
-        const args = redactForGolden(input.tool, input.args ?? {}, "request.arguments", redactions);
-        const meta = input.meta !== undefined ? redactForGolden(input.tool, input.meta, "request._meta", redactions) : undefined;
-        const response = redactForGolden(input.tool, input.response, "response", redactions);
-        const record = {
-            v: 1,
-            ts: new Date().toISOString(),
-            seq: ++state.seq,
-            session: SESSION_ID,
-            wyrm_version: wyrmVersion(),
-            tool: input.tool,
-            dispatch: input.dispatch,
-            request: {
-                name: input.tool,
-                arguments: args,
-                ...(meta !== undefined ? { _meta: meta } : {}),
-            },
-            response,
-            outcome: input.outcome ?? deriveOutcome(input.response),
-            cached: input.cached === true,
-            ms: input.ms,
-            redactions,
-        };
-        writeLine(JSON.stringify(record) + "\n");
-    }
-    catch (err) {
-        // log-and-drop: the tool result is already on its way to the client; the
-        // golden record is best-effort (the emitEvent contract).
-        warnStderr("golden: capture dropped", err);
-    }
-}
-// ---------------------------------------------------------------------------
-// Test hooks (additive; no production caller)
-// ---------------------------------------------------------------------------
-/** Reset breaker/sequence state between tests. */
-export function __resetGoldenForTests() {
-    state.seq = 0;
-    state.writeFailures = 0;
-    state.disabled = false;
-    state.warned = false;
-}
-/** Read-only view of the capture state for tests. */
-export function __goldenStateForTests() {
-    return { ...state };
-}
-//# sourceMappingURL=golden.js.map
+import{appendFileSync as y,mkdirSync as _,existsSync as g,readFileSync as A}from"fs";import{homedir as S}from"os";import{join as p,dirname as E}from"path";import{fileURLToPath as h}from"url";function b(e,r){try{const t=r===void 0?"":` (${r instanceof Error?r.message:String(r)})`;process.stderr.write(`[wyrm] ${e}${t}
+`)}catch{}}const k=["token","secret","password","passwd","authorization","passphrase","bearer","credential","apikey","api_key","license"],D={wyrm_mcp_register:new Set(["env"])},T=[{label:"jwt",re:/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]*/},{label:"github-token",re:/\bgh[posu]_[A-Za-z0-9]{16,}\b/},{label:"npm-token",re:/\bnpm_[A-Za-z0-9]{16,}\b/},{label:"api-key",re:/\b[sp]k-[A-Za-z0-9_-]{16,}\b/},{label:"aws-access-key",re:/\bAKIA[0-9A-Z]{16}\b/},{label:"slack-token",re:/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/},{label:"pem-private-key",re:/-----BEGIN [A-Z ]*PRIVATE KEY-----/},{label:"bearer",re:/\bBearer\s+[A-Za-z0-9._~+\/-]{16,}/}];function R(){const e=process.env.WYRM_GOLDEN_REDACT_EXTRA;return e?new Set(e.split(",").map(r=>r.trim().toLowerCase()).filter(Boolean)):new Set}function $(e,r){const t=e.toLowerCase();if(r.has(t))return!0;for(const o of k)if(t.includes(o))return!0;return!!(t!=="key"&&t.endsWith("key"))}function u(e,r,t,o){if(e==null)return e;const s=typeof e;if(s==="string"){if(o)return t.redactions.push(r),"[REDACTED]";for(const{label:a,re:m}of T)if(m.test(e))return t.redactions.push(r),`[REDACTED:${a}]`;return e}if(s==="number"||s==="boolean")return o?(t.redactions.push(r),"[REDACTED]"):e;if(s==="bigint"||s==="function"||s==="symbol")return{$unserializable:!0};if(Buffer.isBuffer(e)||ArrayBuffer.isView(e)||e instanceof ArrayBuffer)return{$unserializable:!0};const c=e;if(t.seen.has(c))return{$unserializable:!0};t.seen.add(c);try{if(Array.isArray(e))return e.map((i,f)=>u(i,`${r}.${f}`,t,o));if(e instanceof Date)return e.toISOString();const a={},m=D[t.tool];for(const[i,f]of Object.entries(e)){const l=`${r}.${i}`;o?a[i]=u(f,l,t,!0):$(i,t.extras)?(t.redactions.push(l),a[i]="[REDACTED]"):m?.has(i)?a[i]=u(f,l,t,!0):a[i]=u(f,l,t,!1)}return a}finally{t.seen.delete(c)}}function w(e,r,t,o){const s={tool:e,extras:R(),redactions:o,seen:new WeakSet};return u(r,t,s,!1)}const C=5,n={seq:0,writeFailures:0,disabled:!1,warned:!1},F=`${process.pid}-${Math.floor(Date.now()/1e3)}`;let d=null;function I(){if(d)return d;try{const e=E(h(import.meta.url));for(const r of[p(e,"..","package.json"),p(e,"..","..","package.json")])if(g(r)){const t=JSON.parse(A(r,"utf-8")).version;if(typeof t=="string")return d=t,t}}catch{}return d="unknown",d}function L(){const e=process.env.WYRM_GOLDEN_CAPTURE;return e==="1"||e==="true"}function O(){const e=process.env.WYRM_GOLDEN_DIR?.trim();return e&&e.length>0?e:p(S(),".wyrm","golden")}function z(e){const r=new Date,t=`${r.getUTCFullYear()}${String(r.getUTCMonth()+1).padStart(2,"0")}${String(r.getUTCDate()).padStart(2,"0")}`;return p(e,`golden-${t}-${process.pid}.jsonl`)}function U(e){try{const r=O();_(r,{recursive:!0,mode:448}),y(z(r),e,{mode:384}),n.writeFailures=0}catch(r){n.writeFailures++,n.writeFailures>=C?(n.disabled=!0,n.warned||(n.warned=!0,b(`golden: capture disabled for this process after ${n.writeFailures} consecutive write failures`,r))):b("golden: capture dropped (write failed)",r)}}function N(e){const r=e;if(r&&typeof r=="object"&&r.isError){const t=Array.isArray(r.content)?r.content[0]?.text:void 0;return typeof t=="string"&&t.startsWith("Unknown tool:")?"unknown_tool":"soft_error"}return"ok"}function W(e){try{if(n.disabled||!L())return;const r=[],t=w(e.tool,e.args??{},"request.arguments",r),o=e.meta!==void 0?w(e.tool,e.meta,"request._meta",r):void 0,s=w(e.tool,e.response,"response",r),c={v:1,ts:new Date().toISOString(),seq:++n.seq,session:F,wyrm_version:I(),tool:e.tool,dispatch:e.dispatch,request:{name:e.tool,arguments:t,...o!==void 0?{_meta:o}:{}},response:s,outcome:e.outcome??N(e.response),cached:e.cached===!0,ms:e.ms,redactions:r};U(JSON.stringify(c)+`
+`)}catch(r){b("golden: capture dropped",r)}}function q(){n.seq=0,n.writeFailures=0,n.disabled=!1,n.warned=!1}function M(){return{...n}}export{M as __goldenStateForTests,q as __resetGoldenForTests,W as goldenCapture,L as isGoldenCaptureEnabled,w as redactForGolden};

package/dist/handlers/agent.js

@@ -1,165 +1,4 @@
-/**
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
-export const agentToolSpecs = [
-    {
-        name: "wyrm_agent_init",
-        description: "Bootstrap Wyrm's autonomous agent loop in one call. Starts the wyrm-loop daemon as a detached background process so subsequent ticks happen automatically every interval_seconds. Optionally seeds a first goal in the same call. Idempotent — if already running, returns status without spawning a second instance.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                interval_seconds: { type: "number", description: "Seconds between OODA ticks (default 600 = 10 min, min 10)" },
-                max_steps: { type: "number", description: "Max iterations per goal per tick (default 3, max 20)" },
-                project_path: { type: "string", description: "Scope the daemon to a project root (optional)" },
-                verbose: { type: "boolean", description: "Log every tick to ~/.wyrm/wyrm-loop.log" },
-                seed_goal: {
-                    type: "object",
-                    description: "Optional first goal to set in the same call",
-                    properties: {
-                        title: { type: "string" },
-                        description: { type: "string" },
-                        success_criteria: { type: "string" },
-                        priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-                        deadline: { type: "string" },
-                        max_iterations: { type: "number" },
-                    },
-                    required: ["title"],
-                },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_agent_init"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { agentDaemon, db, goals } = ctx;
-            const a = args;
-            const interval = Math.max(10, Math.min(a.interval_seconds ?? 600, 86400));
-            const r = agentDaemon.start({
-                interval_seconds: interval,
-                max_steps: a.max_steps,
-                project_path: a.project_path,
-                verbose: a.verbose ?? false,
-            });
-            if (!r.ok) {
-                return { content: [{ type: "text", text: `󱅝 Agent init failed: ${r.error}` }], isError: true };
-            }
-            let seedNote = '';
-            if (a.seed_goal) {
-                const proj = a.project_path ? db.getProject(a.project_path) : null;
-                const goal = goals.set({
-                    project_id: proj?.id ?? null,
-                    title: a.seed_goal.title,
-                    description: a.seed_goal.description,
-                    success_criteria: a.seed_goal.success_criteria,
-                    deadline: a.seed_goal.deadline,
-                    priority: a.seed_goal.priority,
-                    max_iterations: a.seed_goal.max_iterations,
-                });
-                seedNote = `\n   Seeded goal #${goal.id}: ${goal.title}`;
-            }
-            const status = r.status;
-            const wasAlready = status.pid != null && status.pid !== r.pid;
-            const text = [
-                `󱅝 Agent ${wasAlready ? 'already running' : 'started'} — pid ${status.pid}`,
-                `   Interval: ${interval}s · Active goals: ${status.active_goals} · Total iterations: ${status.total_iterations}`,
-                `   Log: ${status.log_file}` + seedNote,
-            ].join('\n');
-            return { content: [{ type: "text", text }] };
-        },
-    },
-    {
-        name: "wyrm_agent_status",
-        description: "Inspect the autonomous agent: is the wyrm-loop daemon running, what was the last action, how many active goals + total iterations. Use to confirm bootstrap worked.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                include_log: { type: "boolean", description: "Include last ~40 lines of the daemon log" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_agent_status"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { agentDaemon, goals } = ctx;
-            const a = args;
-            const status = agentDaemon.status();
-            const lines = [];
-            if (status.running) {
-                lines.push(`󱅝 Agent RUNNING — pid ${status.pid}${status.started_at ? ` (since ${status.started_at})` : ''}`);
-                if (status.uptime_seconds != null) {
-                    const m = Math.floor(status.uptime_seconds / 60);
-                    const s = status.uptime_seconds % 60;
-                    lines.push(`   Uptime: ${m}m ${s}s`);
-                }
-            }
-            else {
-                lines.push(`󱅝 Agent NOT RUNNING. Call wyrm_agent_init to start it.`);
-            }
-            lines.push(`   Active goals: ${status.active_goals} · Total iterations: ${status.total_iterations}`);
-            if (status.last_action) {
-                lines.push(`   Last action (${status.last_action.ran_at}): ${status.last_action.summary} [${status.last_action.result_status ?? '?'}]`);
-            }
-            if (a.include_log) {
-                lines.push('');
-                lines.push('=== Recent log ===');
-                lines.push(agentDaemon.recentLog(40));
-            }
-            return { content: [{ type: "text", text: lines.join('\n') }] };
-        },
-    },
-    {
-        name: "wyrm_agent_stop",
-        description: "Stop the autonomous agent daemon (SIGTERM with grace, then SIGKILL). Goals remain in DB and can be resumed by calling wyrm_agent_init again.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                grace_ms: { type: "number", description: "Wait time before SIGKILL (default 3000, max 30000)" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_agent_stop"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { agentDaemon } = ctx;
-            const a = args;
-            const r = await agentDaemon.stop({ grace_ms: a.grace_ms });
-            if (!r.ok) {
-                return { content: [{ type: "text", text: `󱅝 Stop failed: ${r.error}` }], isError: true };
-            }
-            const text = r.was_running
-                ? `󱅝 Agent stopped (was pid ${r.pid}). Goals remain in DB — wyrm_agent_init resumes.`
-                : `󱅝 Agent was not running. (No-op.)`;
-            return { content: [{ type: "text", text }] };
-        },
-    },
-    {
-        name: "wyrm_agent_restart",
-        description: "Stop the daemon and start it again with optional new settings. Useful when changing interval_seconds or max_steps without manually stopping first.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                interval_seconds: { type: "number" },
-                max_steps: { type: "number" },
-                project_path: { type: "string" },
-                verbose: { type: "boolean" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_agent_restart"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { agentDaemon, goals } = ctx;
-            const a = args;
-            const r = await agentDaemon.restart({
-                interval_seconds: a.interval_seconds,
-                max_steps: a.max_steps,
-                project_path: a.project_path,
-                verbose: a.verbose,
-            });
-            if (!r.ok) {
-                return { content: [{ type: "text", text: `󱅝 Restart failed: ${r.error}` }], isError: true };
-            }
-            const s = r.status;
-            return { content: [{ type: "text", text: `󱅝 Agent restarted — pid ${s.pid}. Active goals: ${s.active_goals}.` }] };
-        },
-    },
-];
-//# sourceMappingURL=agent.js.map
+import{TOOL_ANNOTATIONS as l}from"../tool-annotations.js";const y=[{name:"wyrm_agent_init",description:"Bootstrap Wyrm's autonomous agent loop in one call. Starts the wyrm-loop daemon as a detached background process so subsequent ticks happen automatically every interval_seconds. Optionally seeds a first goal in the same call. Idempotent \u2014 if already running, returns status without spawning a second instance.",inputSchema:{type:"object",properties:{interval_seconds:{type:"number",description:"Seconds between OODA ticks (default 600 = 10 min, min 10)"},max_steps:{type:"number",description:"Max iterations per goal per tick (default 3, max 20)"},project_path:{type:"string",description:"Scope the daemon to a project root (optional)"},verbose:{type:"boolean",description:"Log every tick to ~/.wyrm/wyrm-loop.log"},seed_goal:{type:"object",description:"Optional first goal to set in the same call",properties:{title:{type:"string"},description:{type:"string"},success_criteria:{type:"string"},priority:{type:"string",enum:["critical","high","medium","low"]},deadline:{type:"string"},max_iterations:{type:"number"}},required:["title"]}}},annotations:l.wyrm_agent_init,aliases:[],handler:async(s,o)=>{const{agentDaemon:a,db:p,goals:n}=o,t=s,e=Math.max(10,Math.min(t.interval_seconds??600,86400)),i=a.start({interval_seconds:e,max_steps:t.max_steps,project_path:t.project_path,verbose:t.verbose??!1});if(!i.ok)return{content:[{type:"text",text:`\u{F115D} Agent init failed: ${i.error}`}],isError:!0};let c="";if(t.seed_goal){const m=t.project_path?p.getProject(t.project_path):null,d=n.set({project_id:m?.id??null,title:t.seed_goal.title,description:t.seed_goal.description,success_criteria:t.seed_goal.success_criteria,deadline:t.seed_goal.deadline,priority:t.seed_goal.priority,max_iterations:t.seed_goal.max_iterations});c=`
+   Seeded goal #${d.id}: ${d.title}`}const r=i.status;return{content:[{type:"text",text:[`\u{F115D} Agent ${r.pid!=null&&r.pid!==i.pid?"already running":"started"} \u2014 pid ${r.pid}`,`   Interval: ${e}s \xB7 Active goals: ${r.active_goals} \xB7 Total iterations: ${r.total_iterations}`,`   Log: ${r.log_file}`+c].join(`
+`)}]}}},{name:"wyrm_agent_status",description:"Inspect the autonomous agent: is the wyrm-loop daemon running, what was the last action, how many active goals + total iterations. Use to confirm bootstrap worked.",inputSchema:{type:"object",properties:{include_log:{type:"boolean",description:"Include last ~40 lines of the daemon log"}}},annotations:l.wyrm_agent_status,aliases:[],handler:async(s,o)=>{const{agentDaemon:a,goals:p}=o,n=s,t=a.status(),e=[];if(t.running){if(e.push(`\u{F115D} Agent RUNNING \u2014 pid ${t.pid}${t.started_at?` (since ${t.started_at})`:""}`),t.uptime_seconds!=null){const i=Math.floor(t.uptime_seconds/60),c=t.uptime_seconds%60;e.push(`   Uptime: ${i}m ${c}s`)}}else e.push("\u{F115D} Agent NOT RUNNING. Call wyrm_agent_init to start it.");return e.push(`   Active goals: ${t.active_goals} \xB7 Total iterations: ${t.total_iterations}`),t.last_action&&e.push(`   Last action (${t.last_action.ran_at}): ${t.last_action.summary} [${t.last_action.result_status??"?"}]`),n.include_log&&(e.push(""),e.push("=== Recent log ==="),e.push(a.recentLog(40))),{content:[{type:"text",text:e.join(`
+`)}]}}},{name:"wyrm_agent_stop",description:"Stop the autonomous agent daemon (SIGTERM with grace, then SIGKILL). Goals remain in DB and can be resumed by calling wyrm_agent_init again.",inputSchema:{type:"object",properties:{grace_ms:{type:"number",description:"Wait time before SIGKILL (default 3000, max 30000)"}}},annotations:l.wyrm_agent_stop,aliases:[],handler:async(s,o)=>{const{agentDaemon:a}=o,p=s,n=await a.stop({grace_ms:p.grace_ms});return n.ok?{content:[{type:"text",text:n.was_running?`\u{F115D} Agent stopped (was pid ${n.pid}). Goals remain in DB \u2014 wyrm_agent_init resumes.`:"\u{F115D} Agent was not running. (No-op.)"}]}:{content:[{type:"text",text:`\u{F115D} Stop failed: ${n.error}`}],isError:!0}}},{name:"wyrm_agent_restart",description:"Stop the daemon and start it again with optional new settings. Useful when changing interval_seconds or max_steps without manually stopping first.",inputSchema:{type:"object",properties:{interval_seconds:{type:"number"},max_steps:{type:"number"},project_path:{type:"string"},verbose:{type:"boolean"}}},annotations:l.wyrm_agent_restart,aliases:[],handler:async(s,o)=>{const{agentDaemon:a,goals:p}=o,n=s,t=await a.restart({interval_seconds:n.interval_seconds,max_steps:n.max_steps,project_path:n.project_path,verbose:n.verbose});if(!t.ok)return{content:[{type:"text",text:`\u{F115D} Restart failed: ${t.error}`}],isError:!0};const e=t.status;return{content:[{type:"text",text:`\u{F115D} Agent restarted \u2014 pid ${e.pid}. Active goals: ${e.active_goals}.`}]}}}];export{y as agentToolSpecs};

package/dist/handlers/alias-adapters.js

@@ -1,129 +1 @@
-/**
- * v7 F3 (T021) — hand-written argument adapters for the alias spine.
- *
- * The spine itself (src/handlers/aliases.ts) is GENERATED from the live
- * ListTools surface by scripts/gen-alias-spine.mjs; this module is the one
- * hand-authored input it consumes: per-alias ROUTE OVERRIDES that map a 6.x
- * name onto a different (surviving) tool with an argument adapter.
- *
- * Adapters TRANSLATE arguments — they never reimplement handler behavior
- * (spec FR-4: "aliases route to the SAME handler code paths with argument
- * adapters — never reimplementations"). Every override is double-verified:
- *  - tests/alias-spine.test.ts replays adapter output against the TARGET's
- *    advertised inputSchema (the original handler's declared expectations);
- *  - tests/golden-replay.test.ts replays the alias's golden fixtures BOTH
- *    ways on the live wire (direct name vs adapted route) and asserts
- *    equivalent results.
- *
- * Default route for every alias NOT listed here is IDENTITY (the alias's own
- * 6.x dispatcher path) until T022 flips routes to the survivor shims —
- * aliases must be provably equivalent BEFORE anything is hidden.
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-import { SHIM_ROUTES } from './shims.js';
-/**
- * T021 buddy fold — the companion params wyrm_buddy contributed to the
- * well-known `buddy` tool as ADDITIVE optional args. Their presence is what
- * switches `buddy` from the Buddy Protocol v1.0 peer reply onto the SAME
- * companion code path wyrm_buddy runs (runCompanionBuddy in index.ts).
- * `size` is deliberately NOT a discriminator: the peer protocol already
- * carries it, and a bare peer call must stay protocol-identical (spec FR-4:
- * "protocol behavior unchanged when absent").
- */
-export const COMPANION_BUDDY_PARAMS = [
-    'project_path',
-    'persona',
-    'persona_name',
-    'mood',
-    'federate',
-];
-/** True iff any companion-only param is present — the buddy-fold mode switch. */
-export function isCompanionBuddyCall(args) {
-    return COMPANION_BUDDY_PARAMS.some((k) => args[k] !== undefined);
-}
-/**
- * wyrm_buddy → buddy argument adapter. Param names are identical on the
- * grown buddy schema, so the only translation is injecting the resolved
- * project_path when absent — exactly the resolution the original handler
- * performs first (`const cwd = bdPath ?? process.cwd()`), hoisted into the
- * adapter so a BARE wyrm_buddy call still discriminates as companion mode.
- * Same process, same value — equivalence holds byte-for-byte.
- */
-export function adaptWyrmBuddyToBuddy(args) {
-    const out = { ...args };
-    if (out.project_path === undefined)
-        out.project_path = process.cwd();
-    return out;
-}
-/**
- * v7 F3 (T022) — the noun-shim absorptions, INVERTED from the same
- * SHIM_ROUTES table resolveShimCall() dispatches with (src/handlers/shims.ts).
- * One source of truth, two directions:
- *
- *   alias call:  wyrm_quest_add(args)
- *     → spine adapt:        wyrm_quest({ ...args, action: 'add' })
- *     → resolveShimCall:    wyrm_quest_add(args)        // discriminator stripped
- *
- * i.e. every generated override roundtrips to the ORIGINAL dispatcher case
- * with the ORIGINAL args by construction — the same handler code path, never
- * a reimplementation (locked exhaustively by tests/alias-spine.test.ts, which
- * asserts the roundtrip identity for every override on its fixture args).
- *
- * The discriminator is spread LAST so it is authoritative; no absorbed 6.x
- * tool declares its own `action`/`mode`/`source` param (audited against the
- * live schemas at T022 — wyrm_sync_resolve's own `mode` rides through the
- * `action`-discriminated replication route untouched).
- */
-function invertShimRoutes() {
-    const out = {};
-    const claim = (aliasName, override) => {
-        if (out[aliasName] !== undefined) {
-            // fail LOUD at module load — a double absorption would make the
-            // disposition table ambiguous and the roundtrip lock meaningless
-            throw new Error(`alias-adapters: ${aliasName} absorbed by two shims (${out[aliasName].target} and ${override.target})`);
-        }
-        out[aliasName] = override;
-    };
-    for (const [shimName, entry] of Object.entries(SHIM_ROUTES)) {
-        for (const [value, route] of Object.entries(entry.routes)) {
-            if (typeof route === 'string') {
-                if (route === shimName)
-                    continue; // self-route (capture mode=classify) — not an absorption
-                claim(route, {
-                    target: shimName,
-                    adapt: (args) => ({ ...args, [entry.discriminator]: value }),
-                    note: `T022: absorbed by ${shimName} ${entry.discriminator}=${value}; resolveShimCall strips the discriminator back onto the original ${route} dispatcher case — same code path by construction (roundtrip-locked).`,
-                });
-            }
-            else {
-                for (const [subValue, target] of Object.entries(route.routes)) {
-                    claim(target, {
-                        target: shimName,
-                        adapt: (args) => ({ ...args, [entry.discriminator]: value, [route.key]: subValue }),
-                        note: `T022: absorbed by ${shimName} ${entry.discriminator}=${value} ${route.key}=${subValue}; resolveShimCall strips both back onto the original ${target} dispatcher case — same code path by construction (roundtrip-locked).`,
-                    });
-                }
-            }
-        }
-    }
-    return out;
-}
-/**
- * Route overrides keyed by 6.x alias name: the T021 buddy fold plus the T022
- * shim absorptions (generated from SHIM_ROUTES — see invertShimRoutes above).
- * Every key MUST be in the generated alias keyset and every target MUST be a
- * survivor — locked by tests/alias-spine.test.ts.
- */
-export const ALIAS_ROUTE_OVERRIDES = {
-    ...invertShimRoutes(),
-    wyrm_buddy: {
-        target: 'buddy',
-        adapt: adaptWyrmBuddyToBuddy,
-        note: 'T021 buddy fold: companion params (persona/mood/size/federation) merged into the ' +
-            'well-known buddy tool as additive optional args; both names run runCompanionBuddy ' +
-            '(index.ts) — one code path, not a duplicate.',
-    },
-};
-//# sourceMappingURL=alias-adapters.js.map
+import{SHIM_ROUTES as c}from"./shims.js";const p=["project_path","persona","persona_name","mood","federate"];function f(o){return p.some(e=>o[e]!==void 0)}function u(o){const e={...o};return e.project_path===void 0&&(e.project_path=process.cwd()),e}function m(){const o={},e=(t,r)=>{if(o[t]!==void 0)throw new Error(`alias-adapters: ${t} absorbed by two shims (${o[t].target} and ${r.target})`);o[t]=r};for(const[t,r]of Object.entries(c))for(const[a,n]of Object.entries(r.routes))if(typeof n=="string"){if(n===t)continue;e(n,{target:t,adapt:i=>({...i,[r.discriminator]:a}),note:`T022: absorbed by ${t} ${r.discriminator}=${a}; resolveShimCall strips the discriminator back onto the original ${n} dispatcher case \u2014 same code path by construction (roundtrip-locked).`})}else for(const[i,d]of Object.entries(n.routes))e(d,{target:t,adapt:s=>({...s,[r.discriminator]:a,[n.key]:i}),note:`T022: absorbed by ${t} ${r.discriminator}=${a} ${n.key}=${i}; resolveShimCall strips both back onto the original ${d} dispatcher case \u2014 same code path by construction (roundtrip-locked).`});return o}const h={...m(),wyrm_buddy:{target:"buddy",adapt:u,note:"T021 buddy fold: companion params (persona/mood/size/federation) merged into the well-known buddy tool as additive optional args; both names run runCompanionBuddy (index.ts) \u2014 one code path, not a duplicate."}};export{h as ALIAS_ROUTE_OVERRIDES,p as COMPANION_BUDDY_PARAMS,u as adaptWyrmBuddyToBuddy,f as isCompanionBuddyCall};