wyrm-mcp 7.3.2 → 7.3.3

package/dist/autoconfig.js

@@ -1,50 +1,1126 @@
-import{existsSync as u,readFileSync as l,writeFileSync as f,mkdirSync as S,copyFileSync as B,chmodSync as I}from"fs";import{homedir as m,platform as U}from"os";import{join as r,dirname as w,resolve as z}from"path";import{fileURLToPath as F}from"url";import{spawnSync as b}from"child_process";function H(){const e=m(),t=U(),s=t==="darwin"?r(e,"Library","Application Support","Code","User"):t==="win32"?r(e,"AppData","Roaming","Code","User"):r(e,".config","Code","User"),o=t==="darwin"?r(e,"Library","Application Support","Code - Insiders","User"):t==="win32"?r(e,"AppData","Roaming","Code - Insiders","User"):r(e,".config","Code - Insiders","User"),c=t==="darwin"?r(e,"Library","Application Support","Claude"):t==="win32"?r(e,"AppData","Roaming","Claude"):r(e,".config","claude"),n=t==="darwin"?r(e,".cursor"):t==="win32"?r(e,".cursor"):r(e,".cursor"),a=t==="darwin"?r(e,".codeium","windsurf"):t==="win32"?r(e,".codeium","windsurf"):r(e,".codeium","windsurf"),d=t==="darwin"?r(e,".config","zed"):t==="win32"?r(e,"AppData","Roaming","Zed"):r(e,".config","zed"),i=r(e,".continue");return[{id:"vscode-copilot",name:"VS Code (Copilot)",icon:"\u{1F4BB}",configPath:r(s,"settings.json"),configFormat:"vscode",mcpKey:"mcp.servers",detected:!1,configured:!1},{id:"vscode-insiders",name:"VS Code Insiders",icon:"\u{1F7E2}",configPath:r(o,"settings.json"),configFormat:"vscode",mcpKey:"mcp.servers",detected:!1,configured:!1},{id:"claude-desktop",name:"Claude Desktop",icon:"\u{1F916}",configPath:r(c,"claude_desktop_config.json"),configFormat:"mcp-json",mcpKey:"mcpServers",detected:!1,configured:!1},{id:"cursor",name:"Cursor",icon:"\u{1F4D0}",configPath:r(n,"mcp.json"),configFormat:"mcp-json",mcpKey:"mcpServers",detected:!1,configured:!1},{id:"windsurf",name:"Windsurf",icon:"\u{1F3C4}",configPath:r(a,"mcp_config.json"),configFormat:"mcp-json",mcpKey:"mcpServers",detected:!1,configured:!1},{id:"zed",name:"Zed",icon:"\u26A1",configPath:r(d,"settings.json"),configFormat:"zed",mcpKey:"context_servers",detected:!1,configured:!1},{id:"continue",name:"Continue",icon:"\u{1F504}",configPath:r(i,"config.json"),configFormat:"mcp-json",mcpKey:"mcpServers",detected:!1,configured:!1}]}function v(){const e=H();for(const t of e){const s=w(t.configPath);if(t.detected=u(s),t.detected&&u(t.configPath))try{const o=l(t.configPath,"utf-8"),c=O(o);t.configured=q(c,t)}catch{t.configured=!1}t.detected&&(t.version=Y(t))}return e}function Y(e){try{switch(e.id){case"vscode-copilot":case"vscode-insiders":{const t=e.id==="vscode-insiders"?"code-insiders":"code",s=b(t,["--version"],{encoding:"utf-8",timeout:5e3});if(s.stdout)return s.stdout.split(`
-`)[0];break}case"cursor":{const t=b("cursor",["--version"],{encoding:"utf-8",timeout:5e3});if(t.stdout)return t.stdout.split(`
-`)[0];break}}}catch{}}function q(e,t){switch(t.configFormat){case"vscode":return e.mcp?.servers?.wyrm!==void 0;case"mcp-json":return e[t.mcpKey]?.wyrm!==void 0;case"zed":return e[t.mcpKey]?.wyrm!==void 0;default:return!1}}function R(){try{const o=b("which",["wyrm-mcp"],{encoding:"utf-8",timeout:5e3});if(o.stdout?.trim())return o.stdout.trim()}catch{}try{const c=b("npm",["root","-g"],{encoding:"utf-8",timeout:5e3}).stdout?.trim();if(c){const n=r(c,"wyrm-mcp","dist","index.js");if(u(n))return n}}catch{}const e=z(__dirname,"index.js");if(u(e))return e;const t=r(m(),".wyrm","node_modules","wyrm-mcp","dist","index.js");if(u(t))return t;const s=[r(m(),"Git Projects","Wyrm","packages","mcp-server","dist","index.js"),r(m(),"projects","Wyrm","packages","mcp-server","dist","index.js"),r(m(),"dev","Wyrm","packages","mcp-server","dist","index.js")];for(const o of s)if(u(o))return o;return"wyrm-mcp"}function E(){return r(m(),".wyrm","wyrm.db")}function V(e,t){const s=t.serverPath,o=s==="wyrm-mcp",c=s.endsWith(".js");switch(e.configFormat){case"vscode":return{command:o?"npx":"node",args:o?["wyrm-mcp"]:[s],env:{WYRM_DB_PATH:t.dbPath}};case"mcp-json":return{command:o?"npx":"node",args:o?["wyrm-mcp"]:[s],env:{WYRM_DB_PATH:t.dbPath}};case"zed":return{command:o?"npx":"node",args:o?["wyrm-mcp"]:[s],env:{WYRM_DB_PATH:t.dbPath}};default:return{}}}function L(e,t){if(!e.detected)return{client:e,action:"skipped",message:`${e.name} not detected`};try{const s=w(e.configPath);u(s)||S(s,{recursive:!0});let o={},c=!1;if(u(e.configPath))try{const i=l(e.configPath,"utf-8");o=O(i),c=!0}catch{o={}}let n;c&&(n=`${e.configPath}.wyrm-backup`,f(n,l(e.configPath)));const a=V(e,t);switch(e.configFormat){case"vscode":{o.mcp||(o.mcp={});const i=o.mcp;i.servers||(i.servers={});const p=i.servers;p.wyrm=a;break}case"mcp-json":{o[e.mcpKey]||(o[e.mcpKey]={});const i=o[e.mcpKey];i.wyrm=a;break}case"zed":{o[e.mcpKey]||(o[e.mcpKey]={});const i=o[e.mcpKey];i.wyrm=a;break}}f(e.configPath,JSON.stringify(o,null,2)+`
-`,"utf-8");const d=e.configured?"updated":"configured";return e.configured=!0,{client:e,action:d,message:`${e.name} ${d==="configured"?"configured":"updated"} successfully`,backup:n}}catch(s){return{client:e,action:"failed",message:`Failed to configure ${e.name}: ${s}`}}}function G(e){if(!e.detected||!e.configured)return{client:e,action:"skipped",message:`${e.name} not configured`};try{if(!u(e.configPath))return{client:e,action:"skipped",message:`${e.name} config not found`};const t=l(e.configPath,"utf-8"),s=O(t),o=`${e.configPath}.wyrm-backup`;switch(f(o,t),e.configFormat){case"vscode":{const n=s.mcp?.servers;n&&delete n.wyrm;break}case"mcp-json":case"zed":{const c=s[e.mcpKey];c&&delete c.wyrm;break}}return f(e.configPath,JSON.stringify(s,null,2)+`
-`,"utf-8"),e.configured=!1,{client:e,action:"configured",message:`Removed Wyrm from ${e.name}`,backup:o}}catch(t){return{client:e,action:"failed",message:`Failed to remove from ${e.name}: ${t}`}}}function _(){return{id:"claude-code-hooks",name:"Claude Code (auto-memory)",icon:"\u{1FA9D}",configPath:r(m(),".claude","settings.json"),configFormat:"mcp-json",mcpKey:"",detected:!0,configured:!1}}const W=[{script:"wyrm-session-capture.mjs",events:["SessionEnd","PreCompact"]},{script:"wyrm-session-rehydrate.mjs",events:["SessionStart"]},{script:"wyrm-session-prune.mjs",events:["SessionEnd"]},{script:"wyrm-tool-call-trace.mjs",events:["PostToolUse"]},{script:"wyrm-run-auto.mjs",events:["SessionStart",{event:"PreToolUse",matcher:"Task"},"SessionEnd"]}];function Q(){const e=r(m(),".claude");if(!u(e))return null;const t=_();try{const s=r(e,"hooks");u(s)||S(s,{recursive:!0});const o=w(F(import.meta.url)),c=r(o,"..","scripts","hooks"),n=t.configPath;let a={};if(u(n))try{a=JSON.parse(l(n,"utf-8"))}catch{a={}}const d=a.hooks??{};let i=!1;const p=[];for(const h of W){const k=r(c,h.script);if(!u(k)){p.push(h.script);continue}const j=r(s,h.script);B(k,j);try{I(j,493)}catch{}const x=`node ${j}`;for(const y of h.events){const C=typeof y=="string"?y:y.event,K=typeof y=="string"?void 0:y.matcher,$=Array.isArray(d[C])?d[C]:[];if(!$.some(P=>Array.isArray(P.hooks)&&P.hooks.some(J=>J.command===x))){const P=K?{matcher:K,hooks:[{type:"command",command:x,timeout:30}]}:{hooks:[{type:"command",command:x,timeout:30}]};$.push(P),i=!0}d[C]=$}}a.hooks=d,f(n,JSON.stringify(a,null,2)+`
-`,"utf-8"),t.configured=!0;const g=p.length?` (missing from package: ${p.join(", ")})`:"";return{client:t,action:i?"configured":"skipped",message:(i?"auto-memory hooks installed":"already installed")+g}}catch(s){return{client:t,action:"failed",message:s instanceof Error?s.message:String(s)}}}function ie(){const e=r(m(),".claude");if(!u(e))return null;const t=_();try{const s=w(F(import.meta.url)),o=`node ${r(s,"wyrm-statusline.js")}`,c=t.configPath;let n={};if(u(c))try{n=JSON.parse(l(c,"utf-8"))}catch{n={}}const a=n.statusLine;if(a?.command&&!/wyrm-statusline/.test(a.command))return{client:t,action:"skipped",message:`a non-Wyrm statusLine is already set (${a.command}); not overwriting`};const d=a?.command===o;return n.statusLine={type:"command",command:o,padding:0},f(c,JSON.stringify(n,null,2)+`
-`,"utf-8"),{client:t,action:d?"skipped":"configured",message:d?"buddy statusline already installed":"Wyrm buddy statusline installed \u2014 persistent in the Claude Code TUI"}}catch(s){return{client:t,action:"failed",message:s instanceof Error?s.message:String(s)}}}function ae(){const e=r(m(),".claude","settings.json");if(!u(e))return null;const t=_();try{const s=JSON.parse(l(e,"utf-8")),o=s.statusLine;return o?.command&&/wyrm-statusline/.test(o.command)?(delete s.statusLine,f(e,JSON.stringify(s,null,2)+`
-`,"utf-8"),{client:t,action:"configured",message:"Wyrm statusline removed"}):{client:t,action:"skipped",message:"no Wyrm statusline set"}}catch(s){return{client:t,action:"failed",message:s instanceof Error?s.message:String(s)}}}function Z(){const e=r(m(),".claude","settings.json");if(!u(e))return null;const t=_();try{const s=JSON.parse(l(e,"utf-8")),o=r(m(),".claude","hooks"),c=new Set(W.map(d=>`node ${r(o,d.script)}`)),n=new Set(W.flatMap(d=>d.events.map(i=>typeof i=="string"?i:i.event))),a=s.hooks;if(a){for(const d of n)Array.isArray(a[d])&&(a[d]=a[d].map(i=>({...i,hooks:Array.isArray(i.hooks)?i.hooks.filter(p=>!c.has(p.command??"")):i.hooks})).filter(i=>!Array.isArray(i.hooks)||i.hooks.length>0),a[d].length===0&&delete a[d]);Object.keys(a).length===0&&delete s.hooks}return f(e,JSON.stringify(s,null,2)+`
-`,"utf-8"),{client:t,action:"configured",message:"auto-memory hooks removed"}}catch(s){return{client:t,action:"failed",message:s instanceof Error?s.message:String(s)}}}function X(e){const t={serverPath:e?.serverPath||R(),dbPath:e?.dbPath||E(),httpPort:e?.httpPort},s=r(m(),".wyrm");u(s)||S(s,{recursive:!0}),M(t);const o=v(),c=[];for(const a of o)c.push(L(a,t));const n=Q();return n&&c.push(n),c}function de(){const e=v(),t=[];for(const o of e)t.push(G(o));const s=Z();return s&&t.push(s),t}function ee(e,t){const s={serverPath:t?.serverPath||R(),dbPath:t?.dbPath||E(),httpPort:t?.httpPort};M(s);const o=v(),c=[];for(const n of o)e.includes(n.id)&&c.push(L(n,s));return c}function M(e){const t=r(m(),".wyrm","wyrm-config.json"),s=v().filter(c=>c.configured).map(c=>c.id),o={version:"3.0.0",serverPath:e.serverPath,dbPath:e.dbPath,httpPort:e.httpPort,configuredClients:s,lastSetup:new Date().toISOString(),autoUpdate:!0};f(t,JSON.stringify(o,null,2)+`
-`,"utf-8")}function N(){const e=r(m(),".wyrm","wyrm-config.json");if(!u(e))return null;try{return JSON.parse(l(e,"utf-8"))}catch{return null}}function ue(){const e=N();return e?ee(e.configuredClients,{serverPath:e.serverPath,dbPath:e.dbPath,httpPort:e.httpPort}):X()}const T="<!-- wyrm:start -->",A="<!-- wyrm:end -->",D=`${T}
-## Wyrm Memory + Agent (auto-managed \u2014 do not edit this section)
+/**
+ * Wyrm Auto-Configure - Universal AI Client Detection & Setup
+ *
+ * Automatically detects installed AI clients (VS Code Copilot, Claude Desktop,
+ * Cursor, Windsurf, Zed, etc.) and configures Wyrm's MCP server in each.
+ * Handles provider switching seamlessly — change your AI, Wyrm follows.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ * @module autoconfig
+ * @version 3.0.0
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+// ==================== CLIENT DEFINITIONS ====================
+function getConfigPaths() {
+    const home = homedir();
+    const os = platform();
+    // Base config directories per OS
+    const vscodeBase = os === 'darwin'
+        ? join(home, 'Library', 'Application Support', 'Code', 'User')
+        : os === 'win32'
+            ? join(home, 'AppData', 'Roaming', 'Code', 'User')
+            : join(home, '.config', 'Code', 'User');
+    const vscodeInsidersBase = os === 'darwin'
+        ? join(home, 'Library', 'Application Support', 'Code - Insiders', 'User')
+        : os === 'win32'
+            ? join(home, 'AppData', 'Roaming', 'Code - Insiders', 'User')
+            : join(home, '.config', 'Code - Insiders', 'User');
+    const claudeBase = os === 'darwin'
+        ? join(home, 'Library', 'Application Support', 'Claude')
+        : os === 'win32'
+            ? join(home, 'AppData', 'Roaming', 'Claude')
+            : join(home, '.config', 'claude');
+    const cursorBase = os === 'darwin'
+        ? join(home, '.cursor')
+        : os === 'win32'
+            ? join(home, '.cursor')
+            : join(home, '.cursor');
+    const windsurfBase = os === 'darwin'
+        ? join(home, '.codeium', 'windsurf')
+        : os === 'win32'
+            ? join(home, '.codeium', 'windsurf')
+            : join(home, '.codeium', 'windsurf');
+    const zedBase = os === 'darwin'
+        ? join(home, '.config', 'zed')
+        : os === 'win32'
+            ? join(home, 'AppData', 'Roaming', 'Zed')
+            : join(home, '.config', 'zed');
+    const continueBase = join(home, '.continue');
+    return [
+        {
+            id: 'vscode-copilot',
+            name: 'VS Code (Copilot)',
+            icon: '💻',
+            configPath: join(vscodeBase, 'settings.json'),
+            configFormat: 'vscode',
+            mcpKey: 'mcp.servers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'vscode-insiders',
+            name: 'VS Code Insiders',
+            icon: '🟢',
+            configPath: join(vscodeInsidersBase, 'settings.json'),
+            configFormat: 'vscode',
+            mcpKey: 'mcp.servers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'claude-desktop',
+            name: 'Claude Desktop',
+            icon: '🤖',
+            configPath: join(claudeBase, 'claude_desktop_config.json'),
+            configFormat: 'mcp-json',
+            mcpKey: 'mcpServers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'cursor',
+            name: 'Cursor',
+            icon: '📐',
+            configPath: join(cursorBase, 'mcp.json'),
+            configFormat: 'mcp-json',
+            mcpKey: 'mcpServers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'windsurf',
+            name: 'Windsurf',
+            icon: '🏄',
+            configPath: join(windsurfBase, 'mcp_config.json'),
+            configFormat: 'mcp-json',
+            mcpKey: 'mcpServers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'zed',
+            name: 'Zed',
+            icon: '⚡',
+            configPath: join(zedBase, 'settings.json'),
+            configFormat: 'zed',
+            mcpKey: 'context_servers',
+            detected: false,
+            configured: false,
+        },
+        {
+            id: 'continue',
+            name: 'Continue',
+            icon: '🔄',
+            configPath: join(continueBase, 'config.json'),
+            configFormat: 'mcp-json',
+            mcpKey: 'mcpServers',
+            detected: false,
+            configured: false,
+        },
+    ];
+}
+// ==================== DETECTION ====================
+/**
+ * Detect which AI clients are installed by checking for their config directories
+ */
+export function detectClients() {
+    const clients = getConfigPaths();
+    for (const client of clients) {
+        // Check if config directory exists (the client is installed)
+        const configDir = dirname(client.configPath);
+        client.detected = existsSync(configDir);
+        // Check if Wyrm is already configured
+        if (client.detected && existsSync(client.configPath)) {
+            try {
+                const content = readFileSync(client.configPath, 'utf-8');
+                const config = parseJsonWithComments(content);
+                client.configured = hasWyrmConfig(config, client);
+            }
+            catch {
+                client.configured = false;
+            }
+        }
+        // Try to detect version
+        if (client.detected) {
+            client.version = detectClientVersion(client);
+        }
+    }
+    return clients;
+}
+/**
+ * Detect the version of an AI client
+ */
+function detectClientVersion(client) {
+    try {
+        switch (client.id) {
+            case 'vscode-copilot':
+            case 'vscode-insiders': {
+                const cmd = client.id === 'vscode-insiders' ? 'code-insiders' : 'code';
+                const result = spawnSync(cmd, ['--version'], { encoding: 'utf-8', timeout: 5000 });
+                if (result.stdout)
+                    return result.stdout.split('\n')[0];
+                break;
+            }
+            case 'cursor': {
+                const result = spawnSync('cursor', ['--version'], { encoding: 'utf-8', timeout: 5000 });
+                if (result.stdout)
+                    return result.stdout.split('\n')[0];
+                break;
+            }
+        }
+    }
+    catch {
+        // Version detection is optional
+    }
+    return undefined;
+}
+/**
+ * Check if Wyrm is already configured in a client's config
+ */
+function hasWyrmConfig(config, client) {
+    switch (client.configFormat) {
+        case 'vscode': {
+            const mcp = config['mcp'];
+            const servers = mcp?.['servers'];
+            return servers?.['wyrm'] !== undefined;
+        }
+        case 'mcp-json': {
+            const servers = config[client.mcpKey];
+            return servers?.['wyrm'] !== undefined;
+        }
+        case 'zed': {
+            const servers = config[client.mcpKey];
+            return servers?.['wyrm'] !== undefined;
+        }
+        default:
+            return false;
+    }
+}
+// ==================== CONFIGURATION ====================
+/**
+ * Auto-detect Wyrm server path
+ */
+export function findWyrmServerPath() {
+    // 1. Check if wyrm-mcp binary is in PATH
+    try {
+        const result = spawnSync('which', ['wyrm-mcp'], { encoding: 'utf-8', timeout: 5000 });
+        if (result.stdout?.trim()) {
+            return result.stdout.trim();
+        }
+    }
+    catch { }
+    // 2. Check common npm global install locations
+    try {
+        const result = spawnSync('npm', ['root', '-g'], { encoding: 'utf-8', timeout: 5000 });
+        const globalDir = result.stdout?.trim();
+        if (globalDir) {
+            const globalPath = join(globalDir, 'wyrm-mcp', 'dist', 'index.js');
+            if (existsSync(globalPath))
+                return globalPath;
+        }
+    }
+    catch { }
+    // 3. Check local development path (relative to this file)
+    const devPath = resolve(__dirname, 'index.js');
+    if (existsSync(devPath))
+        return devPath;
+    // 4. Check ~/.wyrm/node_modules
+    const wyrmModulesPath = join(homedir(), '.wyrm', 'node_modules', 'wyrm-mcp', 'dist', 'index.js');
+    if (existsSync(wyrmModulesPath))
+        return wyrmModulesPath;
+    // 5. Check common project locations
+    const projectLocations = [
+        join(homedir(), 'Git Projects', 'Wyrm', 'packages', 'mcp-server', 'dist', 'index.js'),
+        join(homedir(), 'projects', 'Wyrm', 'packages', 'mcp-server', 'dist', 'index.js'),
+        join(homedir(), 'dev', 'Wyrm', 'packages', 'mcp-server', 'dist', 'index.js'),
+    ];
+    for (const loc of projectLocations) {
+        if (existsSync(loc))
+            return loc;
+    }
+    // 6. Fallback to npx
+    return 'wyrm-mcp';
+}
+/**
+ * Get the default Wyrm database path
+ */
+export function getDefaultDbPath() {
+    return join(homedir(), '.wyrm', 'wyrm.db');
+}
+/**
+ * Build the Wyrm MCP config object for a specific client format
+ */
+function buildWyrmMcpConfig(client, wyrmConfig) {
+    const serverPath = wyrmConfig.serverPath;
+    const isNpx = serverPath === 'wyrm-mcp';
+    const isJsFile = serverPath.endsWith('.js');
+    switch (client.configFormat) {
+        case 'vscode':
+            return {
+                command: isNpx ? 'npx' : 'node',
+                args: isNpx ? ['wyrm-mcp'] : [serverPath],
+                env: {
+                    WYRM_DB_PATH: wyrmConfig.dbPath,
+                },
+            };
+        case 'mcp-json':
+            return {
+                command: isNpx ? 'npx' : 'node',
+                args: isNpx ? ['wyrm-mcp'] : [serverPath],
+                env: {
+                    WYRM_DB_PATH: wyrmConfig.dbPath,
+                },
+            };
+        case 'zed':
+            return {
+                command: isNpx ? 'npx' : 'node',
+                args: isNpx ? ['wyrm-mcp'] : [serverPath],
+                env: {
+                    WYRM_DB_PATH: wyrmConfig.dbPath,
+                },
+            };
+        default:
+            return {};
+    }
+}
+/**
+ * Configure Wyrm in a single AI client
+ */
+export function configureClient(client, wyrmConfig) {
+    if (!client.detected) {
+        return {
+            client,
+            action: 'skipped',
+            message: `${client.name} not detected`,
+        };
+    }
+    try {
+        // Ensure config directory exists
+        const configDir = dirname(client.configPath);
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        // Read existing config or create new
+        let config = {};
+        let existed = false;
+        if (existsSync(client.configPath)) {
+            try {
+                const content = readFileSync(client.configPath, 'utf-8');
+                config = parseJsonWithComments(content);
+                existed = true;
+            }
+            catch {
+                // If config exists but is invalid, start fresh
+                config = {};
+            }
+        }
+        // Create backup before modifying
+        let backupPath;
+        if (existed) {
+            backupPath = `${client.configPath}.wyrm-backup`;
+            writeFileSync(backupPath, readFileSync(client.configPath));
+        }
+        // Build Wyrm MCP entry
+        const wyrmEntry = buildWyrmMcpConfig(client, wyrmConfig);
+        // Inject into config based on format
+        switch (client.configFormat) {
+            case 'vscode': {
+                // VS Code: { "mcp": { "servers": { "wyrm": {...} } } }
+                if (!config['mcp'])
+                    config['mcp'] = {};
+                const mcp = config['mcp'];
+                if (!mcp['servers'])
+                    mcp['servers'] = {};
+                const servers = mcp['servers'];
+                servers['wyrm'] = wyrmEntry;
+                break;
+            }
+            case 'mcp-json': {
+                // MCP JSON: { "mcpServers": { "wyrm": {...} } }
+                if (!config[client.mcpKey])
+                    config[client.mcpKey] = {};
+                const servers = config[client.mcpKey];
+                servers['wyrm'] = wyrmEntry;
+                break;
+            }
+            case 'zed': {
+                // Zed: { "context_servers": { "wyrm": {...} } }
+                if (!config[client.mcpKey])
+                    config[client.mcpKey] = {};
+                const servers = config[client.mcpKey];
+                servers['wyrm'] = wyrmEntry;
+                break;
+            }
+        }
+        // Write config back
+        writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        const action = client.configured ? 'updated' : 'configured';
+        client.configured = true;
+        return {
+            client,
+            action,
+            message: `${client.name} ${action === 'configured' ? 'configured' : 'updated'} successfully`,
+            backup: backupPath,
+        };
+    }
+    catch (error) {
+        return {
+            client,
+            action: 'failed',
+            message: `Failed to configure ${client.name}: ${error}`,
+        };
+    }
+}
+/**
+ * Remove Wyrm from a single AI client
+ */
+export function removeFromClient(client) {
+    if (!client.detected || !client.configured) {
+        return {
+            client,
+            action: 'skipped',
+            message: `${client.name} not configured`,
+        };
+    }
+    try {
+        if (!existsSync(client.configPath)) {
+            return { client, action: 'skipped', message: `${client.name} config not found` };
+        }
+        const content = readFileSync(client.configPath, 'utf-8');
+        const config = parseJsonWithComments(content);
+        // Create backup
+        const backupPath = `${client.configPath}.wyrm-backup`;
+        writeFileSync(backupPath, content);
+        // Remove Wyrm entry
+        switch (client.configFormat) {
+            case 'vscode': {
+                const mcp = config['mcp'];
+                const servers = mcp?.['servers'];
+                if (servers)
+                    delete servers['wyrm'];
+                break;
+            }
+            case 'mcp-json':
+            case 'zed': {
+                const servers = config[client.mcpKey];
+                if (servers)
+                    delete servers['wyrm'];
+                break;
+            }
+        }
+        writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        client.configured = false;
+        return {
+            client,
+            action: 'configured',
+            message: `Removed Wyrm from ${client.name}`,
+            backup: backupPath,
+        };
+    }
+    catch (error) {
+        return {
+            client,
+            action: 'failed',
+            message: `Failed to remove from ${client.name}: ${error}`,
+        };
+    }
+}
+// ==================== ORCHESTRATION ====================
+// ==================== CLAUDE CODE CLI HOOKS ====================
+/** Synthetic "client" so hook install/removal renders in the setup summary. */
+function claudeHooksClient() {
+    return {
+        id: 'claude-code-hooks',
+        name: 'Claude Code (auto-memory)',
+        icon: '🪝',
+        configPath: join(homedir(), '.claude', 'settings.json'),
+        configFormat: 'mcp-json',
+        mcpKey: '',
+        detected: true,
+        configured: false,
+    };
+}
+const CLAUDE_HOOK_SPECS = [
+    { script: 'wyrm-session-capture.mjs', events: ['SessionEnd', 'PreCompact'] },
+    { script: 'wyrm-session-rehydrate.mjs', events: ['SessionStart'] },
+    { script: 'wyrm-session-prune.mjs', events: ['SessionEnd'] },
+    { script: 'wyrm-tool-call-trace.mjs', events: ['PostToolUse'] },
+    { script: 'wyrm-run-auto.mjs', events: ['SessionStart', { event: 'PreToolUse', matcher: 'Task' }, 'SessionEnd'] },
+];
+/**
+ * Install Wyrm's Claude Code CLI hooks so every session is auto-remembered
+ * (capture), auto-restored (rehydrate), and optionally tidied (prune). Ships
+ * the hook scripts next to the user's other hooks and merges the hook entries
+ * into ~/.claude/settings.json WITHOUT clobbering any hooks already there.
+ * Idempotent. No-op (returns null) when the Claude Code CLI isn't present.
+ */
+export function installClaudeCodeHooks() {
+    const claudeDir = join(homedir(), '.claude');
+    if (!existsSync(claudeDir))
+        return null; // Claude Code CLI not installed here
+    const client = claudeHooksClient();
+    try {
+        const hooksDir = join(claudeDir, 'hooks');
+        if (!existsSync(hooksDir))
+            mkdirSync(hooksDir, { recursive: true });
+        // Hook scripts live next to dist/ (one level below the package root).
+        const here = dirname(fileURLToPath(import.meta.url));
+        const scriptsDir = join(here, '..', 'scripts', 'hooks');
+        const settingsPath = client.configPath;
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            }
+            catch {
+                settings = {};
+            }
+        }
+        const hooks = (settings.hooks ?? {});
+        let added = false;
+        const missing = [];
+        for (const spec of CLAUDE_HOOK_SPECS) {
+            const src = join(scriptsDir, spec.script);
+            if (!existsSync(src)) {
+                missing.push(spec.script);
+                continue;
+            } // skip, don't abort the rest
+            const dest = join(hooksDir, spec.script);
+            copyFileSync(src, dest);
+            try {
+                chmodSync(dest, 0o755);
+            }
+            catch { /* non-fatal */ }
+            const cmd = `node ${dest}`;
+            for (const ev of spec.events) {
+                const event = typeof ev === 'string' ? ev : ev.event;
+                const matcher = typeof ev === 'string' ? undefined : ev.matcher;
+                const groups = Array.isArray(hooks[event]) ? hooks[event] : [];
+                // Idempotent on the command anywhere under this event (a re-run never
+                // duplicates), and the new group carries the matcher when one is set.
+                const present = groups.some((g) => Array.isArray(g.hooks) && g.hooks.some((h) => h.command === cmd));
+                if (!present) {
+                    const group = matcher
+                        ? { matcher, hooks: [{ type: 'command', command: cmd, timeout: 30 }] }
+                        : { hooks: [{ type: 'command', command: cmd, timeout: 30 }] };
+                    groups.push(group);
+                    added = true;
+                }
+                hooks[event] = groups;
+            }
+        }
+        settings.hooks = hooks;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        client.configured = true;
+        const note = missing.length ? ` (missing from package: ${missing.join(', ')})` : '';
+        return { client, action: added ? 'configured' : 'skipped', message: (added ? 'auto-memory hooks installed' : 'already installed') + note };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Install Wyrm's buddy statusline into Claude Code (`statusLine` in settings.json)
+ * so the dragon + live memory (project · open quests · blocked failures · truths)
+ * is visible in the TUI AT ALL TIMES — not just when a tool is called. Won't
+ * clobber a non-Wyrm statusline the user already configured.
+ */
+export function installClaudeStatusline() {
+    const claudeDir = join(homedir(), '.claude');
+    if (!existsSync(claudeDir))
+        return null;
+    const client = claudeHooksClient();
+    try {
+        const here = dirname(fileURLToPath(import.meta.url)); // dist/
+        const cmd = `node ${join(here, 'wyrm-statusline.js')}`;
+        const settingsPath = client.configPath;
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            }
+            catch {
+                settings = {};
+            }
+        }
+        const existing = settings.statusLine;
+        if (existing?.command && !/wyrm-statusline/.test(existing.command)) {
+            return { client, action: 'skipped', message: `a non-Wyrm statusLine is already set (${existing.command}); not overwriting` };
+        }
+        const already = existing?.command === cmd;
+        settings.statusLine = { type: 'command', command: cmd, padding: 0 };
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        return { client, action: already ? 'skipped' : 'configured', message: already ? 'buddy statusline already installed' : 'Wyrm buddy statusline installed — persistent in the Claude Code TUI' };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** Remove the Wyrm statusline from settings.json (leaves any non-Wyrm one). */
+export function removeClaudeStatusline() {
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    if (!existsSync(settingsPath))
+        return null;
+    const client = claudeHooksClient();
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const sl = settings.statusLine;
+        if (sl?.command && /wyrm-statusline/.test(sl.command)) {
+            delete settings.statusLine;
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+            return { client, action: 'configured', message: 'Wyrm statusline removed' };
+        }
+        return { client, action: 'skipped', message: 'no Wyrm statusline set' };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** Remove all Wyrm hooks from ~/.claude/settings.json (leaves other hooks). */
+export function removeClaudeCodeHooks() {
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    if (!existsSync(settingsPath))
+        return null;
+    const client = claudeHooksClient();
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const hooksDir = join(homedir(), '.claude', 'hooks');
+        const ourCmds = new Set(CLAUDE_HOOK_SPECS.map((s) => `node ${join(hooksDir, s.script)}`));
+        const ourEvents = new Set(CLAUDE_HOOK_SPECS.flatMap((s) => s.events.map((ev) => (typeof ev === 'string' ? ev : ev.event))));
+        const hooks = settings.hooks;
+        if (hooks) {
+            for (const event of ourEvents) {
+                if (!Array.isArray(hooks[event]))
+                    continue;
+                hooks[event] = hooks[event]
+                    .map((g) => ({ ...g, hooks: Array.isArray(g.hooks) ? g.hooks.filter((h) => !ourCmds.has(h.command ?? '')) : g.hooks }))
+                    .filter((g) => !Array.isArray(g.hooks) || g.hooks.length > 0);
+                if (hooks[event].length === 0)
+                    delete hooks[event];
+            }
+            if (Object.keys(hooks).length === 0)
+                delete settings.hooks;
+        }
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        return { client, action: 'configured', message: 'auto-memory hooks removed' };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+// ==================== WYRM-GUARD FAILURE-FIREWALL HOOKS ====================
+//
+// Pure-TS port of the scripts/hooks/install.sh strip/merge logic for the
+// wyrm-guard half — the deterministic PreToolUse failure gate shipped as the
+// npm bin `wyrm-guard` (package.json bin → dist/wyrm-guard.js). install.sh
+// remains the repo-checkout tool (it also manages wyrm-push.py, which the npm
+// `files` array does NOT ship); THIS installer is what npm-global users get
+// from `wyrm setup` / `wyrm guard`, with no jq or shell dependency.
+//
+// install.sh semantics preserved:
+//   · strip-then-add — every prior entry whose command matches the guard
+//     pattern is stripped before the fresh entries are added, so a re-run
+//     never duplicates and entries survive a moved install / renamed bin;
+//   · the same two PreToolUse matchers ('Bash' and
+//     'Edit|Write|MultiEdit|NotebookEdit'), each { type:'command', timeout:1 };
+//   · groups/events OUR strip emptied are dropped (as is a hooks object our
+//     removal emptied) — but pre-existing empty user groups/events are NOT
+//     ours to prune and survive byte-identical;
+//   · unrelated hooks/settings are never touched (and unlike install.sh, a
+//     no-op uninstall does not even rewrite the file).
+// Deliberate divergences: the strip sweeps EVERY hook event for our pattern
+// (install.sh listed only two specific event types), wyrm-push.py entries are
+// left alone (they are install.sh's to manage — the guard installer only owns
+// what npm distributes), and an unparseable settings.json — or a hooks /
+// hooks.PreToolUse shape we cannot faithfully merge into — is REFUSED rather
+// than clobbered.
+/** A hook command is OURS iff it matches this (the install.sh `ours` test —
+ * pattern match, so entries survive a moved install / changed bin path). */
+const GUARD_COMMAND_PATTERN = /wyrm-guard/;
+/** The PreToolUse matchers install.sh wires for the guard. */
+const GUARD_MATCHERS = ['Bash', 'Edit|Write|MultiEdit|NotebookEdit'];
+function guardSettingsPath(options) {
+    return options.settingsPath
+        ?? process.env.CLAUDE_SETTINGS
+        ?? join(homedir(), '.claude', 'settings.json');
+}
+/** Synthetic "client" so guard install/removal renders in the setup summary. */
+function guardClient(settingsPath) {
+    return {
+        id: 'claude-code-guard',
+        name: 'Claude Code (failure firewall)',
+        icon: '🛡️',
+        configPath: settingsPath,
+        configFormat: 'mcp-json',
+        mcpKey: '',
+        detected: true,
+        configured: false,
+    };
+}
+/**
+ * Shell-quote a path for the PreToolUse hook command, which Claude Code runs
+ * THROUGH A SHELL on every tool call. POSIX single-quoting makes $, backtick,
+ * backslash and double-quote inert — double-quoting does NOT, so a path
+ * containing a command substitution would EXECUTE on every tool call (crucible
+ * HIGH 2026-07-03). cmd.exe (Windows) does not honor single quotes, so there
+ * we wrap in double quotes and escape embedded double-quotes.
+ */
+export function quoteHookPath(p) {
+    if (platform() === 'win32')
+        return `"${p.replace(/"/g, '""')}"`;
+    return `'${p.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Resolve the wyrm-guard hook command for THIS running install. Never a
+ * repo-checkout guess:
+ *  1. dist sibling — 'wyrm-guard.js' next to this module (autoconfig ships in
+ *     the same dist/ for npm-global installs and built checkouts alike),
+ *     invoked `node '<abs path>'` (shell-quoted via quoteHookPath: install
+ *     paths may contain spaces AND shell metacharacters; works without an
+ *     executable bit or shebang support);
+ *  2. else the package.json bin name 'wyrm-guard' resolved on PATH
+ *     (which/where — the same probe install.sh uses), shell-quoted the same way.
+ */
+export function resolveWyrmGuardCommand() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const sibling = join(here, 'wyrm-guard.js');
+    if (existsSync(sibling))
+        return `node ${quoteHookPath(sibling)}`;
+    try {
+        const probe = platform() === 'win32' ? 'where' : 'which';
+        const result = spawnSync(probe, ['wyrm-guard'], { encoding: 'utf-8', timeout: 5000 });
+        const found = result.stdout?.trim().split('\n')[0]?.trim();
+        if (found)
+            return quoteHookPath(found);
+    }
+    catch { /* PATH probe is best-effort */ }
+    return null;
+}
+/**
+ * Strip every hook entry whose command matches GUARD_COMMAND_PATTERN from
+ * every event group (the install.sh strip_existing filter, in TS). Only OUR
+ * entries go; unrelated groups and shapes we don't understand are preserved
+ * exactly as parsed. Groups/events are pruned ONLY when OUR removal emptied
+ * them — a group or event array that was ALREADY empty is user config and
+ * survives byte-identical (dropping it would break the uninstall round-trip).
+ * Returns true when anything was removed.
+ */
+function stripWyrmGuardEntries(settings) {
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks))
+        return false;
+    let removed = false;
+    for (const event of Object.keys(hooks)) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue; // unknown shape — never touch it
+        let eventTouched = false;
+        const pruned = [];
+        for (const g of groups) {
+            const group = g;
+            if (!group || typeof group !== 'object' || !Array.isArray(group.hooks)) {
+                pruned.push(g); // unknown shape — never touch it
+                continue;
+            }
+            const kept = group.hooks.filter((h) => !GUARD_COMMAND_PATTERN.test(h?.command ?? ''));
+            if (kept.length === group.hooks.length) {
+                pruned.push(g); // untouched (incl. pre-existing empty groups) — keep the exact object
+                continue;
+            }
+            removed = true;
+            eventTouched = true;
+            if (kept.length > 0)
+                pruned.push({ ...group, hooks: kept });
+            // else: OUR strip emptied this group — drop it (the install.sh prune)
+        }
+        if (!eventTouched)
+            continue; // nothing of ours here — leave the event exactly as parsed
+        if (pruned.length === 0)
+            delete hooks[event]; // OUR removal emptied the event
+        else
+            hooks[event] = pruned;
+    }
+    if (removed && Object.keys(hooks).length === 0)
+        delete settings.hooks;
+    return removed;
+}
+/**
+ * Install the wyrm-guard failure-firewall hooks into Claude Code's
+ * settings.json — the zero-config path (`wyrm setup` runs this) and the
+ * explicit one (`wyrm guard`). Idempotent strip-then-add: a re-run never
+ * duplicates, and a byte-identical result skips the write entirely. No-op
+ * (returns null) when the Claude Code CLI isn't present and no explicit
+ * target was given.
+ */
+export function installWyrmGuardHooks(options = {}) {
+    const explicitTarget = Boolean(options.settingsPath ?? process.env.CLAUDE_SETTINGS);
+    if (!explicitTarget && !existsSync(join(homedir(), '.claude')))
+        return null;
+    const settingsPath = guardSettingsPath(options);
+    const client = guardClient(settingsPath);
+    try {
+        const command = options.guardCommand ?? resolveWyrmGuardCommand();
+        if (!command) {
+            return {
+                client,
+                action: 'skipped',
+                message: 'wyrm-guard bin not found (npm i -g wyrm-mcp, or build dist/) — firewall hooks not installed',
+            };
+        }
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                    throw new Error('not an object');
+                settings = parsed;
+            }
+            catch {
+                // install.sh (jq under set -e) aborted here too — never clobber a
+                // file we cannot faithfully merge into.
+                return { client, action: 'failed', message: `${settingsPath} is not valid JSON — refusing to overwrite it (fix or remove the file, then re-run)` };
+            }
+        }
+        // Shape guard — the same never-clobber stance as the invalid-JSON refusal.
+        // A hooks value that is not a plain object (array/string/null/…) or a
+        // PreToolUse that is not an array cannot be faithfully merged into:
+        // proceeding would either discard user data or silently install nothing
+        // while reporting success. install.sh (jq under set -e) aborted on these
+        // shapes too.
+        const rawHooks = settings.hooks;
+        if (rawHooks !== undefined && (typeof rawHooks !== 'object' || rawHooks === null || Array.isArray(rawHooks))) {
+            return { client, action: 'failed', message: `${settingsPath} "hooks" has an unexpected shape (not a plain object) — refusing to modify (fix the file, then re-run)` };
+        }
+        const rawPreToolUse = rawHooks?.['PreToolUse'];
+        if (rawPreToolUse !== undefined && !Array.isArray(rawPreToolUse)) {
+            return { client, action: 'failed', message: `${settingsPath} hooks.PreToolUse has an unexpected shape (not an array) — refusing to modify (fix the file, then re-run)` };
+        }
+        const before = JSON.stringify(settings);
+        stripWyrmGuardEntries(settings);
+        const hooks = (settings.hooks ?? {});
+        const groups = (Array.isArray(hooks['PreToolUse']) ? hooks['PreToolUse'] : []);
+        for (const matcher of GUARD_MATCHERS) {
+            // The exact install.sh entry shape: one group per matcher, 1s timeout
+            // (the guard's wyrm-push ~200ms budget discipline, with headroom).
+            groups.push({ matcher, hooks: [{ type: 'command', command, timeout: 1 }] });
+        }
+        hooks['PreToolUse'] = groups;
+        settings.hooks = hooks;
+        const changed = JSON.stringify(settings) !== before;
+        if (changed)
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        client.configured = true;
+        return {
+            client,
+            action: changed ? 'configured' : 'skipped',
+            message: changed
+                ? 'failure-firewall hooks installed (PreToolUse: Bash + Edit|Write|MultiEdit|NotebookEdit)'
+                : 'failure-firewall hooks already installed',
+        };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Remove ONLY the wyrm-guard hook entries (the install.sh --uninstall filter
+ * for the guard). Unrelated hooks/settings survive; when nothing of ours is
+ * present the file is not rewritten at all (bytes untouched).
+ */
+export function removeWyrmGuardHooks(options = {}) {
+    const settingsPath = guardSettingsPath(options);
+    if (!existsSync(settingsPath))
+        return null;
+    const client = guardClient(settingsPath);
+    try {
+        let settings;
+        try {
+            const parsed = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                throw new Error('not an object');
+            settings = parsed;
+        }
+        catch {
+            return { client, action: 'failed', message: `${settingsPath} is not valid JSON — not touching it` };
+        }
+        const removed = stripWyrmGuardEntries(settings);
+        if (!removed)
+            return { client, action: 'skipped', message: 'no wyrm-guard hooks installed' };
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        return { client, action: 'configured', message: 'failure-firewall hooks removed' };
+    }
+    catch (err) {
+        return { client, action: 'failed', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** Whether guard hooks are currently present, and the commands they run. */
+export function wyrmGuardHookStatus(options = {}) {
+    const settingsPath = guardSettingsPath(options);
+    const commands = [];
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const hooks = (settings.hooks ?? {});
+        for (const groups of Object.values(hooks)) {
+            if (!Array.isArray(groups))
+                continue;
+            for (const g of groups) {
+                for (const h of g?.hooks ?? []) {
+                    const cmd = h?.command;
+                    if (cmd && GUARD_COMMAND_PATTERN.test(cmd))
+                        commands.push(cmd);
+                }
+            }
+        }
+    }
+    catch { /* missing/invalid settings → not installed */ }
+    return { settingsPath, installed: commands.length > 0, commands };
+}
+/**
+ * Auto-configure Wyrm in ALL detected AI clients
+ */
+export function autoConfigureAll(wyrmConfig) {
+    const config = {
+        serverPath: wyrmConfig?.serverPath || findWyrmServerPath(),
+        dbPath: wyrmConfig?.dbPath || getDefaultDbPath(),
+        httpPort: wyrmConfig?.httpPort,
+    };
+    // Ensure .wyrm directory exists
+    const wyrmDir = join(homedir(), '.wyrm');
+    if (!existsSync(wyrmDir)) {
+        mkdirSync(wyrmDir, { recursive: true });
+    }
+    // Save Wyrm's own config for future reference
+    saveWyrmMeta(config);
+    const clients = detectClients();
+    const results = [];
+    for (const client of clients) {
+        results.push(configureClient(client, config));
+    }
+    // Install Claude Code CLI auto-capture hooks (no-op if the CLI isn't present).
+    const hookResult = installClaudeCodeHooks();
+    if (hookResult)
+        results.push(hookResult);
+    // Zero-config failure firewall: the wyrm-guard PreToolUse hooks (no-op if
+    // the CLI isn't present) — npm-global users get the gate without install.sh.
+    const guardResult = installWyrmGuardHooks();
+    if (guardResult)
+        results.push(guardResult);
+    return results;
+}
+/**
+ * Remove Wyrm from ALL AI clients
+ */
+export function removeFromAll() {
+    const clients = detectClients();
+    const results = [];
+    for (const client of clients) {
+        results.push(removeFromClient(client));
+    }
+    const hookResult = removeClaudeCodeHooks();
+    if (hookResult)
+        results.push(hookResult);
+    const guardResult = removeWyrmGuardHooks();
+    if (guardResult)
+        results.push(guardResult);
+    return results;
+}
+/**
+ * Configure Wyrm in specific clients only
+ */
+export function configureSpecific(clientIds, wyrmConfig) {
+    const config = {
+        serverPath: wyrmConfig?.serverPath || findWyrmServerPath(),
+        dbPath: wyrmConfig?.dbPath || getDefaultDbPath(),
+        httpPort: wyrmConfig?.httpPort,
+    };
+    saveWyrmMeta(config);
+    const clients = detectClients();
+    const results = [];
+    for (const client of clients) {
+        if (clientIds.includes(client.id)) {
+            results.push(configureClient(client, config));
+        }
+    }
+    return results;
+}
+/**
+ * Save Wyrm's meta configuration for auto-updates
+ */
+function saveWyrmMeta(config) {
+    const metaPath = join(homedir(), '.wyrm', 'wyrm-config.json');
+    const clients = detectClients().filter(c => c.configured).map(c => c.id);
+    const meta = {
+        version: '3.0.0',
+        serverPath: config.serverPath,
+        dbPath: config.dbPath,
+        httpPort: config.httpPort,
+        configuredClients: clients,
+        lastSetup: new Date().toISOString(),
+        autoUpdate: true,
+    };
+    writeFileSync(metaPath, JSON.stringify(meta, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Load Wyrm's meta configuration
+ */
+export function loadWyrmMeta() {
+    const metaPath = join(homedir(), '.wyrm', 'wyrm-config.json');
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(metaPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Re-configure all previously configured clients (for use after updates)
+ */
+export function reconfAll() {
+    const meta = loadWyrmMeta();
+    if (!meta) {
+        return autoConfigureAll();
+    }
+    return configureSpecific(meta.configuredClients, {
+        serverPath: meta.serverPath,
+        dbPath: meta.dbPath,
+        httpPort: meta.httpPort,
+    });
+}
+// ==================== SYSTEM PROMPT INJECTION ====================
+const WYRM_MARKER_START = '<!-- wyrm:start -->';
+const WYRM_MARKER_END = '<!-- wyrm:end -->';
+export const WYRM_INJECT_BLOCK = `${WYRM_MARKER_START}
+## Wyrm Memory + Agent (auto-managed — do not edit this section)
 
-**Session start** \u2014 call \`wyrm_session_prime\` first to load project context (ground truths, open quests, recent sessions, scaffolds) before responding.
+**Session start** — call \`wyrm_session_prime\` first to load project context (ground truths, open quests, recent sessions, scaffolds) before responding.
 
-**Set goals declaratively** \u2014 when the operator describes a multi-step or recurring objective ("ship v2", "audit auth weekly", "keep dependencies updated"), call \`wyrm_goal_set\` with a clear \`success_criteria\`. Goals persist across sessions and the agent loop will pursue them.
+**Set goals declaratively** — when the operator describes a multi-step or recurring objective ("ship v2", "audit auth weekly", "keep dependencies updated"), call \`wyrm_goal_set\` with a clear \`success_criteria\`. Goals persist across sessions and the agent loop will pursue them.
 
-**Bootstrap the autonomous agent** \u2014 if the operator wants ongoing autonomous work, call \`wyrm_agent_init\` once. This starts the \`wyrm-loop\` background daemon that runs OODA iterations on active goals every \`interval_seconds\` (default 10 min). The same call can seed the first goal via \`seed_goal\`. Verify with \`wyrm_agent_status\`; stop with \`wyrm_agent_stop\`.
+**Bootstrap the autonomous agent** — if the operator wants ongoing autonomous work, call \`wyrm_agent_init\` once. This starts the \`wyrm-loop\` background daemon that runs OODA iterations on active goals every \`interval_seconds\` (default 10 min). The same call can seed the first goal via \`seed_goal\`. Verify with \`wyrm_agent_status\`; stop with \`wyrm_agent_stop\`.
 
-**Counter-pattern check** \u2014 before proposing a fix in an area with prior failures, call \`wyrm_failure_check\` first. Wyrm blocks repeated identical mistakes.
+**Counter-pattern check** — before proposing a fix in an area with prior failures, call \`wyrm_failure_check\` first. Wyrm blocks repeated identical mistakes.
 
-**Record what failed** \u2014 when a fix doesn't work, call \`wyrm_failure_record\` so future sessions don't repeat it.
+**Record what failed** — when a fix doesn't work, call \`wyrm_failure_record\` so future sessions don't repeat it.
 
-**Cite memory in answers** \u2014 when surfacing memory, name the source (e.g., "per truth tech_stack.database = PostgreSQL 15" or "session #142 noted X"). Tagged citations help the operator audit trust.
+**Cite memory in answers** — when surfacing memory, name the source (e.g., "per truth tech_stack.database = PostgreSQL 15" or "session #142 noted X"). Tagged citations help the operator audit trust.
 
-**Attribute Wyrm visibly** \u2014 when you used Wyrm to answer something (loaded a truth, blocked a failure, cited a quest, primed from a past session), say so in plain English. Example: _"Wyrm reminded me that you decided on PostgreSQL last week, so I'm building this for Postgres"_. Operators often don't realise Wyrm is contributing \u2014 naming the contribution makes the value visible. Do NOT silently absorb Wyrm data and present it as your own knowledge.
+**Attribute Wyrm visibly** — when you used Wyrm to answer something (loaded a truth, blocked a failure, cited a quest, primed from a past session), say so in plain English. Example: _"Wyrm reminded me that you decided on PostgreSQL last week, so I'm building this for Postgres"_. Operators often don't realise Wyrm is contributing — naming the contribution makes the value visible. Do NOT silently absorb Wyrm data and present it as your own knowledge.
 
-**Explain Wyrm on request** \u2014 if the operator asks "what does Wyrm do?", "what is Wyrm?", "is Wyrm even working?", or seems confused about Wyrm's role, call \`wyrm_intro\` for a plain-English explanation. For "what has Wyrm done for me?" call \`wyrm_digest\`. These tools speak to humans, not to you.
+**Explain Wyrm on request** — if the operator asks "what does Wyrm do?", "what is Wyrm?", "is Wyrm even working?", or seems confused about Wyrm's role, call \`wyrm_intro\` for a plain-English explanation. For "what has Wyrm done for me?" call \`wyrm_digest\`. These tools speak to humans, not to you.
 
-**Know what Wyrm can do** \u2014 call \`wyrm_capabilities\` once per session to get the full feature inventory (counter-patterns, ground truths, scaffolds, agent loop, outbound MCP, federation, audit chain, \u2026). Reach for the right tool the first time instead of re-discovering the surface mid-conversation.
+**Know what Wyrm can do** — call \`wyrm_capabilities\` once per session to get the full feature inventory (counter-patterns, ground truths, scaffolds, agent loop, outbound MCP, federation, audit chain, …). Reach for the right tool the first time instead of re-discovering the surface mid-conversation.
 
-**Keep wyrm-mcp current** \u2014 \`wyrm_check_update\` returns whether a newer version is on npm (cached 24h). When one is, surface it to the operator and offer \`wyrm_self_update\` (with \`confirm:true\`) to upgrade.
+**Keep wyrm-mcp current** — \`wyrm_check_update\` returns whether a newer version is on npm (cached 24h). When one is, surface it to the operator and offer \`wyrm_self_update\` (with \`confirm:true\`) to upgrade.
 
-**Buddy companion** \u2014 call \`wyrm_buddy\` for warm, data-grounded check-ins. At session start (after \`wyrm_session_prime\`) for long-running work, and when the operator completes a quest or hits a milestone. The buddy speaks in a chosen persona but every claim sources a real DB row \u2014 speak it verbatim, never invent additional encouragement. Auto-federates with other registered MCPs that expose \`*_buddy\` tools.
-${A}`;function me(e,t){const s={injected:[],skipped:[],errors:[]},o=(n,a)=>{try{const d=w(n);if(u(d)||S(d,{recursive:!0}),u(n)){const i=l(n,"utf-8"),p=i.indexOf(T),g=i.indexOf(A);if(p!==-1&&g!==-1&&g>p){const h=i.slice(0,p),k=i.slice(g+A.length);f(n,`${h}${D}${k}`,"utf-8")}else{const h=i.endsWith(`
-`)?`
-`:`
-
-`;f(n,`${i}${h}${D}
-`,"utf-8")}}else f(n,`${D}
-`,"utf-8");s.injected.push(a)}catch(d){s.errors.push(`${a}: ${d}`)}},c=t.length===0?["copilot","cursor"]:t;for(const n of c){const a=n.toLowerCase();if(a==="copilot"||a==="vscode-copilot"){const d=r(e,".github","copilot-instructions.md");o(d,".github/copilot-instructions.md")}else if(a==="cursor"){const d=r(e,".cursor","rules");o(d,".cursor/rules")}else s.skipped.push(n)}return s}function O(e){let t=e.replace(/\/\/.*$/gm,"");return t=t.replace(/\/\*[\s\S]*?\*\//g,""),t=t.replace(/,\s*([\]}])/g,"$1"),JSON.parse(t)}function fe(){const e=v(),t=e.filter(n=>n.detected),s=e.filter(n=>n.configured);let o=`\u{F115D} Wyrm Auto-Configure Status
-
-`;o+=`  Detected:   ${t.length}/${e.length} AI clients
-`,o+=`  Configured: ${s.length}/${t.length} clients
-
-`;for(const n of e){const a=n.detected?n.configured?"  \u25CF":"  \u25D0":"  \u25CB",d=n.version?` (${n.version})`:"",i=n.detected?n.configured?"configured \u2713":"detected \u2014 not configured":"not found";o+=`${a} ${n.icon} ${n.name}${d}: ${i}
-`}const c=N();return c&&(o+=`
-  Server: ${c.serverPath}
-`,o+=`  DB:     ${c.dbPath}
-`,o+=`  Last:   ${new Date(c.lastSetup).toLocaleString()}
-`),o}export{D as WYRM_INJECT_BLOCK,X as autoConfigureAll,L as configureClient,ee as configureSpecific,v as detectClients,R as findWyrmServerPath,E as getDefaultDbPath,fe as getStatusSummary,me as injectSystemPrompt,Q as installClaudeCodeHooks,ie as installClaudeStatusline,N as loadWyrmMeta,ue as reconfAll,Z as removeClaudeCodeHooks,ae as removeClaudeStatusline,de as removeFromAll,G as removeFromClient};
+**Buddy companion** — call \`wyrm_buddy\` for warm, data-grounded check-ins. At session start (after \`wyrm_session_prime\`) for long-running work, and when the operator completes a quest or hits a milestone. The buddy speaks in a chosen persona but every claim sources a real DB row — speak it verbatim, never invent additional encouragement. Auto-federates with other registered MCPs that expose \`*_buddy\` tools.
+${WYRM_MARKER_END}`;
+/**
+ * Inject Wyrm's session-prime instruction block into AI client instruction files.
+ * Supports copilot (.github/copilot-instructions.md) and cursor (.cursor/rules).
+ * Uses marker comments to manage the block idempotently (safe to call multiple times).
+ */
+export function injectSystemPrompt(projectPath, clients) {
+    const result = { injected: [], skipped: [], errors: [] };
+    const writeWithMarker = (filePath, label) => {
+        try {
+            const dir = dirname(filePath);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            if (existsSync(filePath)) {
+                const existing = readFileSync(filePath, 'utf-8');
+                const startIdx = existing.indexOf(WYRM_MARKER_START);
+                const endIdx = existing.indexOf(WYRM_MARKER_END);
+                if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+                    // Replace existing block
+                    const before = existing.slice(0, startIdx);
+                    const after = existing.slice(endIdx + WYRM_MARKER_END.length);
+                    writeFileSync(filePath, `${before}${WYRM_INJECT_BLOCK}${after}`, 'utf-8');
+                }
+                else {
+                    // Append block (ensure newline separation)
+                    const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+                    writeFileSync(filePath, `${existing}${sep}${WYRM_INJECT_BLOCK}\n`, 'utf-8');
+                }
+            }
+            else {
+                writeFileSync(filePath, `${WYRM_INJECT_BLOCK}\n`, 'utf-8');
+            }
+            result.injected.push(label);
+        }
+        catch (e) {
+            result.errors.push(`${label}: ${e}`);
+        }
+    };
+    const allClients = clients.length === 0
+        ? ['copilot', 'cursor']
+        : clients;
+    for (const client of allClients) {
+        const lc = client.toLowerCase();
+        if (lc === 'copilot' || lc === 'vscode-copilot') {
+            const filePath = join(projectPath, '.github', 'copilot-instructions.md');
+            writeWithMarker(filePath, '.github/copilot-instructions.md');
+        }
+        else if (lc === 'cursor') {
+            const filePath = join(projectPath, '.cursor', 'rules');
+            writeWithMarker(filePath, '.cursor/rules');
+        }
+        else {
+            result.skipped.push(client);
+        }
+    }
+    return result;
+}
+// ==================== UTILITIES ====================
+/**
+ * Parse JSON with comments (JSONC) - handles VS Code settings files
+ */
+function parseJsonWithComments(text) {
+    // Strip single-line comments
+    let cleaned = text.replace(/\/\/.*$/gm, '');
+    // Strip multi-line comments
+    cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Handle trailing commas (common in VS Code settings)
+    cleaned = cleaned.replace(/,\s*([\]}])/g, '$1');
+    return JSON.parse(cleaned);
+}
+/**
+ * Get a friendly status summary of all AI clients
+ */
+export function getStatusSummary() {
+    const clients = detectClients();
+    const detected = clients.filter(c => c.detected);
+    const configured = clients.filter(c => c.configured);
+    let summary = `󱅝 Wyrm Auto-Configure Status\n\n`;
+    summary += `  Detected:   ${detected.length}/${clients.length} AI clients\n`;
+    summary += `  Configured: ${configured.length}/${detected.length} clients\n\n`;
+    for (const client of clients) {
+        const status = !client.detected
+            ? '  ○' // Not installed
+            : client.configured
+                ? '  ●' // Configured
+                : '  ◐'; // Installed but not configured
+        const versionStr = client.version ? ` (${client.version})` : '';
+        const statusLabel = !client.detected
+            ? 'not found'
+            : client.configured
+                ? 'configured ✓'
+                : 'detected — not configured';
+        summary += `${status} ${client.icon} ${client.name}${versionStr}: ${statusLabel}\n`;
+    }
+    const meta = loadWyrmMeta();
+    if (meta) {
+        summary += `\n  Server: ${meta.serverPath}\n`;
+        summary += `  DB:     ${meta.dbPath}\n`;
+        summary += `  Last:   ${new Date(meta.lastSetup).toLocaleString()}\n`;
+    }
+    return summary;
+}
+//# sourceMappingURL=autoconfig.js.map