wyrm-mcp 7.3.2 → 7.3.3

package/dist/golden.js

@@ -1,3 +1,355 @@
-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};
+/**
+ * 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

package/dist/handlers/agent.js

@@ -1,4 +1,165 @@
-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};
+/**
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+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