@pathmode/mcp-server 1.4.0 → 1.4.1

package/dist/index.js

@@ -11512,24 +11512,6 @@ class PathmodeClient {
         });
         return res.json();
     }
-    // --- Signal operations ---
-    async listSignals(filters = {}) {
-        const params = new URLSearchParams();
-        for (const [key, val] of Object.entries(filters)) {
-            if (val !== undefined && val !== null)
-                params.set(key, String(val));
-        }
-        const qs = params.toString();
-        const res = await this.fetch(`/signals${qs ? `?${qs}` : ''}`);
-        return res.json();
-    }
-    async dismissSignal(signalId) {
-        const res = await this.fetch('/signals', {
-            method: 'PATCH',
-            body: JSON.stringify({ signalId }),
-        });
-        return res.json();
-    }
 }
 exports.PathmodeClient = PathmodeClient;
 
@@ -11948,6 +11930,259 @@ function extractEdgeCases(body) {
 }
 
 
+/***/ }),
+
+/***/ 8294:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * Pathmode MCP Setup Command
+ *
+ * Auto-detects AI tools (Claude Code, Claude Desktop, Cursor, Windsurf)
+ * and configures the MCP server with a single command.
+ *
+ * Usage:
+ *   npx @pathmode/mcp-server setup pm_live_xxxxx
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getSetupArgs = getSetupArgs;
+exports.isSetupCommand = isSetupCommand;
+exports.runSetup = runSetup;
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+const os_1 = __importDefault(__nccwpck_require__(857));
+function claudeDesktopPaths() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return [path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')];
+    }
+    if (platform === 'win32') {
+        return [path_1.default.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json')];
+    }
+    // Linux
+    return [path_1.default.join(os_1.default.homedir(), '.config', 'Claude', 'claude_desktop_config.json')];
+}
+function claudeCodePaths() {
+    return [path_1.default.join(os_1.default.homedir(), '.claude', 'settings.json')];
+}
+function cursorPaths() {
+    return [path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json')];
+}
+function windsurfPaths() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return [path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'mcp_config.json')];
+    }
+    if (platform === 'win32') {
+        return [path_1.default.join(process.env.APPDATA || '', 'Codeium', 'windsurf', 'mcp_config.json')];
+    }
+    return [path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'mcp_config.json')];
+}
+const TOOLS = [
+    { name: 'Claude Code', paths: claudeCodePaths, configKey: 'mcpServers' },
+    { name: 'Claude Desktop', paths: claudeDesktopPaths, configKey: 'mcpServers' },
+    { name: 'Cursor', paths: cursorPaths, configKey: 'mcpServers' },
+    { name: 'Windsurf', paths: windsurfPaths, configKey: 'mcpServers' },
+];
+// ─── Helpers ──────────────────────────────────────────────────
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+function log(msg) { console.log(msg); }
+function success(msg) { console.log(`  ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`  ${YELLOW}!${RESET} ${msg}`); }
+function fail(msg) { console.log(`  ${RED}✗${RESET} ${msg}`); }
+function getMcpServerBlock(apiKey) {
+    return {
+        command: 'npx',
+        args: ['@pathmode/mcp-server'],
+        env: { PATHMODE_API_KEY: apiKey },
+    };
+}
+function readJsonFile(filePath) {
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return { ok: false, reason: 'not_found' };
+    }
+    try {
+        return { ok: true, data: JSON.parse(raw) };
+    }
+    catch {
+        return { ok: false, reason: 'parse_error', raw };
+    }
+}
+function writeJsonSafe(filePath, data) {
+    try {
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+        return true;
+    }
+    catch (err) {
+        fail(`Could not write ${filePath}: ${err.message}`);
+        return false;
+    }
+}
+function shortenPath(p) {
+    const home = os_1.default.homedir();
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+function getSetupArgs(argv = process.argv) {
+    const setupIndex = argv.findIndex(arg => arg === 'setup');
+    return setupIndex === -1 ? [] : argv.slice(setupIndex + 1);
+}
+function isSetupCommand(argv = process.argv) {
+    return argv.includes('setup');
+}
+// ─── Main ─────────────────────────────────────────────────────
+async function runSetup() {
+    const args = getSetupArgs();
+    const apiKey = args.find(a => a.startsWith('pm_live_') || a.startsWith('pm_test_'));
+    log('');
+    log(`${BOLD}Pathmode MCP Setup${RESET}`);
+    log(`${DIM}──────────────────${RESET}`);
+    log('');
+    if (!apiKey) {
+        log(`Usage: npx @pathmode/mcp-server setup ${DIM}<api-key>${RESET}`);
+        log('');
+        log(`Get your API key from ${CYAN}https://pathmode.io${RESET} → Settings → API Keys`);
+        log('');
+        process.exit(1);
+    }
+    // ─── Step 1: Validate key ─────────────────────────────────
+    process.stdout.write(`  Validating API key...`);
+    let workspaceName = '';
+    let workspaceId = '';
+    const apiUrl = args.includes('--staging')
+        ? 'https://staging.pathmode.io'
+        : 'https://pathmode.io';
+    try {
+        const res = await fetch(`${apiUrl}/api/v1/workspace`, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!res.ok) {
+            if (res.status === 401 || res.status === 403) {
+                log(` ${RED}✗${RESET}`);
+                log('');
+                fail('Invalid or expired API key.');
+                log(`  Get a new key from ${CYAN}${apiUrl}${RESET} → Settings → API Keys`);
+                log('');
+                process.exit(1);
+            }
+            throw new Error(`HTTP ${res.status}`);
+        }
+        const workspace = await res.json();
+        workspaceName = workspace.name;
+        workspaceId = workspace.id;
+        log(` ${GREEN}✓${RESET}`);
+        success(`Connected to "${BOLD}${workspaceName}${RESET}"`);
+    }
+    catch (err) {
+        log(` ${RED}✗${RESET}`);
+        log('');
+        if (err.cause?.code === 'ENOTFOUND' || err.cause?.code === 'ECONNREFUSED') {
+            fail('Could not reach pathmode.io. Check your internet connection.');
+        }
+        else {
+            fail(`Connection failed: ${err.message}`);
+        }
+        log('');
+        process.exit(1);
+    }
+    log('');
+    // ─── Step 2: Detect & configure tools ─────────────────────
+    let configured = 0;
+    for (const tool of TOOLS) {
+        const possiblePaths = tool.paths();
+        // Find existing config, or use first path to create
+        const existingPath = possiblePaths.find(p => fs_1.default.existsSync(p));
+        const configPath = existingPath || possiblePaths[0];
+        // Only configure if the tool's config dir exists (tool is installed)
+        // Exception: Claude Code — always configure since ~/.claude/ may not exist yet
+        const configDir = path_1.default.dirname(configPath);
+        const toolInstalled = tool.name === 'Claude Code' || fs_1.default.existsSync(configDir);
+        if (!toolInstalled) {
+            continue;
+        }
+        let config = {};
+        if (existingPath) {
+            const result = readJsonFile(configPath);
+            if (result.ok) {
+                config = result.data;
+            }
+            else if (result.reason === 'parse_error') {
+                // Back up the corrupt file instead of silently overwriting
+                const backupPath = configPath + '.backup';
+                try {
+                    fs_1.default.writeFileSync(backupPath, result.raw, 'utf-8');
+                }
+                catch { /* best effort */ }
+                warn(`${tool.name}: ${DIM}${shortenPath(configPath)}${RESET} is not valid JSON — backed up to ${DIM}${shortenPath(backupPath)}${RESET}`);
+                continue;
+            }
+        }
+        // Deep merge: preserve other mcpServers, only set/overwrite "pathmode"
+        if (!config[tool.configKey]) {
+            config[tool.configKey] = {};
+        }
+        config[tool.configKey].pathmode = getMcpServerBlock(apiKey);
+        if (writeJsonSafe(configPath, config)) {
+            success(`${tool.name} → ${DIM}${shortenPath(configPath)}${RESET}`);
+            configured++;
+        }
+    }
+    // ─── Step 3: Save ~/.pathmode/config.json ─────────────────
+    const pathmodeConfigDir = path_1.default.join(os_1.default.homedir(), '.pathmode');
+    const pathmodeConfigFile = path_1.default.join(pathmodeConfigDir, 'config.json');
+    const pathmodeConfig = {
+        apiKey,
+        apiUrl,
+        workspaceId,
+    };
+    if (writeJsonSafe(pathmodeConfigFile, pathmodeConfig)) {
+        success(`Config saved → ${DIM}${shortenPath(pathmodeConfigFile)}${RESET}`);
+    }
+    log('');
+    // ─── Step 4: Summary ──────────────────────────────────────
+    if (configured === 0) {
+        log(`${YELLOW}No supported tools detected.${RESET} Add manually:`);
+        log('');
+        log(`  ${DIM}// .claude/settings.json, ~/.cursor/mcp.json, or claude_desktop_config.json${RESET}`);
+        log(`  ${CYAN}{${RESET}`);
+        log(`  ${CYAN}  "mcpServers": {${RESET}`);
+        log(`  ${CYAN}    "pathmode": {${RESET}`);
+        log(`  ${CYAN}      "command": "npx",${RESET}`);
+        log(`  ${CYAN}      "args": ["@pathmode/mcp-server"],${RESET}`);
+        log(`  ${CYAN}      "env": { "PATHMODE_API_KEY": "${apiKey}" }${RESET}`);
+        log(`  ${CYAN}    }${RESET}`);
+        log(`  ${CYAN}  }${RESET}`);
+        log(`  ${CYAN}}${RESET}`);
+        log('');
+    }
+    else {
+        log(`${GREEN}Done!${RESET} Restart your tools to activate Pathmode.`);
+        log('');
+    }
+}
+
+
 /***/ }),
 
 /***/ 9896:
@@ -39746,8 +39981,9 @@ var exports = __webpack_exports__;
  * Connects Claude Code, Cursor, and other AI agents to your Intent Layer.
  *
  * Usage:
- *   npx @pathmode/mcp-server            # Cloud mode (uses ~/.pathmode/config.json)
- *   npx @pathmode/mcp-server --local     # Local mode (reads intent.md from cwd)
+ *   npx @pathmode/mcp-server                    # Cloud mode (uses ~/.pathmode/config.json)
+ *   npx @pathmode/mcp-server --local             # Local mode (reads intent.md from cwd)
+ *   npx @pathmode/mcp-server setup pm_live_xxx   # Auto-configure your tools
  *
  * The Intent Compiler (compile-intent prompt, intent_save, intent_export tools)
  * works without an API key — zero-config intent spec building in Claude Code.
@@ -39771,921 +40007,883 @@ const fs_1 = __nccwpck_require__(9896);
 const api_client_1 = __nccwpck_require__(7475);
 const local_reader_1 = __nccwpck_require__(3518);
 const intent_compiler_1 = __nccwpck_require__(6488);
-const isLocalMode = process.argv.includes('--local');
-let client = null;
-if (!isLocalMode) {
-    const config = (0, api_client_1.loadConfig)();
-    console.error(`[pathmode-mcp] API key present: ${!!config?.apiKey}, prefix: ${config?.apiKey?.substring(0, 16) || 'none'}, url: ${config?.apiUrl || 'none'}`);
-    if (config) {
-        client = new api_client_1.PathmodeClient(config);
-    }
-    // No exit — Intent Compiler tools work without an API key
-}
-// ============================================================
-// Server Setup
-// ============================================================
-const server = new mcp_js_1.McpServer({
-    name: 'pathmode',
-    version: '1.3.0',
-});
-// Annotation presets
-const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
-const WRITE_OP = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
-// ============================================================
-// Tools — Read Operations
-// ============================================================
-server.registerTool('get_current_intent', {
-    title: 'Get Current Intent',
-    description: 'Get the currently active intent (first approved, or most recently updated). Returns the full IntentSpec with objective, outcomes, constraints, and edge cases.',
-    inputSchema: { status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified') },
-    annotations: READ_ONLY,
-}, async ({ status }) => {
-    if (isLocalMode) {
-        const intents = (0, local_reader_1.readLocalIntents)();
-        const filtered = status ? intents.filter(i => i.status === status) : intents;
-        const current = filtered[0];
-        if (!current) {
-            return { content: [{ type: 'text', text: 'No intents found locally.' }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(current, null, 2) }] };
-    }
-    const intents = await client.listIntents(status || 'approved');
-    if (intents.length === 0) {
-        const allIntents = await client.listIntents();
-        if (allIntents.length === 0) {
-            return { content: [{ type: 'text', text: 'No intents found in workspace.' }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(allIntents[0], null, 2) }] };
-    }
-    return { content: [{ type: 'text', text: JSON.stringify(intents[0], null, 2) }] };
-});
-server.registerTool('list_intents', {
-    title: 'List Intents',
-    description: 'List all intents in the workspace. Returns an array of IntentSpecs with their status, objectives, and metadata.',
-    inputSchema: { status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified') },
-    annotations: READ_ONLY,
-}, async ({ status }) => {
-    if (isLocalMode) {
-        const intents = (0, local_reader_1.readLocalIntents)();
-        const filtered = status ? intents.filter(i => i.status === status) : intents;
+const setup_1 = __nccwpck_require__(8294);
+// ─── Subcommand routing ───────────────────────────────────────
+// `setup` uses stdout for human-readable output and must run
+// before StdioServerTransport claims stdout for JSON-RPC.
+// We call startMcpServer() only when NOT in setup mode.
+if ((0, setup_1.isSetupCommand)()) {
+    (0, setup_1.runSetup)().then(() => process.exit(0)).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+else {
+    startMcpServer();
+}
+function startMcpServer() {
+    // ─── MCP Server ───────────────────────────────────────────────
+    const isLocalMode = process.argv.includes('--local');
+    let client = null;
+    if (!isLocalMode) {
+        const config = (0, api_client_1.loadConfig)();
+        console.error(`[pathmode-mcp] API key present: ${!!config?.apiKey}, prefix: ${config?.apiKey?.substring(0, 16) || 'none'}, url: ${config?.apiUrl || 'none'}`);
+        if (config) {
+            client = new api_client_1.PathmodeClient(config);
+        }
+        // No exit — Intent Compiler tools work without an API key
+    }
+    // ============================================================
+    // Server Setup
+    // ============================================================
+    const server = new mcp_js_1.McpServer({
+        name: 'pathmode',
+        version: '1.3.0',
+    });
+    // Annotation presets
+    const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+    const WRITE_OP = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
+    // ============================================================
+    // Tools — Read Operations
+    // ============================================================
+    server.registerTool('get_current_intent', {
+        title: 'Get Current Intent',
+        description: 'Get the currently active intent (first approved, or most recently updated). Returns the full IntentSpec with objective, outcomes, constraints, and edge cases.',
+        inputSchema: { status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified') },
+        annotations: READ_ONLY,
+    }, async ({ status }) => {
+        if (isLocalMode) {
+            const intents = (0, local_reader_1.readLocalIntents)();
+            const filtered = status ? intents.filter(i => i.status === status) : intents;
+            const current = filtered[0];
+            if (!current) {
+                return { content: [{ type: 'text', text: 'No intents found locally.' }] };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(current, null, 2) }] };
+        }
+        const intents = await client.listIntents(status || 'approved');
+        if (intents.length === 0) {
+            const allIntents = await client.listIntents();
+            if (allIntents.length === 0) {
+                return { content: [{ type: 'text', text: 'No intents found in workspace.' }] };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(allIntents[0], null, 2) }] };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(intents[0], null, 2) }] };
+    });
+    server.registerTool('list_intents', {
+        title: 'List Intents',
+        description: 'List all intents in the workspace. Returns an array of IntentSpecs with their status, objectives, and metadata.',
+        inputSchema: { status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified') },
+        annotations: READ_ONLY,
+    }, async ({ status }) => {
+        if (isLocalMode) {
+            const intents = (0, local_reader_1.readLocalIntents)();
+            const filtered = status ? intents.filter(i => i.status === status) : intents;
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ intents: filtered, count: filtered.length }, null, 2)
+                    }]
+            };
+        }
+        const intents = await client.listIntents(status);
         return {
             content: [{
                     type: 'text',
-                    text: JSON.stringify({ intents: filtered, count: filtered.length }, null, 2)
+                    text: JSON.stringify({ intents, count: intents.length }, null, 2)
                 }]
         };
-    }
-    const intents = await client.listIntents(status);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({ intents, count: intents.length }, null, 2)
-            }]
-    };
-});
-server.registerTool('get_intent', {
-    title: 'Get Intent',
-    description: 'Get a single intent by ID with full details including objective, outcomes, constraints, edge cases, and relations.',
-    inputSchema: { intentId: zod_1.z.string().describe('The intent ID to fetch') },
-    annotations: READ_ONLY,
-}, async ({ intentId }) => {
-    if (isLocalMode) {
-        const intents = (0, local_reader_1.readLocalIntents)();
-        const intent = intents.find(i => i.id === intentId);
-        if (!intent) {
-            return { content: [{ type: 'text', text: `No intent found with ID "${intentId}" locally.` }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
-    }
-    try {
+    });
+    server.registerTool('get_intent', {
+        title: 'Get Intent',
+        description: 'Get a single intent by ID with full details including objective, outcomes, constraints, edge cases, and relations.',
+        inputSchema: { intentId: zod_1.z.string().describe('The intent ID to fetch') },
+        annotations: READ_ONLY,
+    }, async ({ intentId }) => {
+        if (isLocalMode) {
+            const intents = (0, local_reader_1.readLocalIntents)();
+            const intent = intents.find(i => i.id === intentId);
+            if (!intent) {
+                return { content: [{ type: 'text', text: `No intent found with ID "${intentId}" locally.` }] };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
+        }
+        try {
+            const intent = await client.getIntent(intentId);
+            return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Failed to fetch intent: ${e.message}` }] };
+        }
+    });
+    server.registerTool('get_intent_relations', {
+        title: 'Get Intent Relations',
+        description: 'Get the dependency graph for a specific intent. Shows what it depends on, enables, or blocks.',
+        inputSchema: { intentId: zod_1.z.string().describe('The intent ID to get relations for') },
+        annotations: READ_ONLY,
+    }, async ({ intentId }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Relations are not available in local mode.' }] };
+        }
         const intent = await client.getIntent(intentId);
-        return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Failed to fetch intent: ${e.message}` }] };
-    }
-});
-server.registerTool('get_intent_relations', {
-    title: 'Get Intent Relations',
-    description: 'Get the dependency graph for a specific intent. Shows what it depends on, enables, or blocks.',
-    inputSchema: { intentId: zod_1.z.string().describe('The intent ID to get relations for') },
-    annotations: READ_ONLY,
-}, async ({ intentId }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Relations are not available in local mode.' }] };
-    }
-    const intent = await client.getIntent(intentId);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
-                    intentId: intent.id,
-                    title: intent.title,
-                    relations: intent.relations,
-                }, null, 2)
-            }]
-    };
-});
-server.registerTool('search_intents', {
-    title: 'Search Intents',
-    description: 'Search intents by keyword. Searches across user goals, objectives, outcomes, and constraints.',
-    inputSchema: {
-        query: zod_1.z.string().describe('Search keyword or phrase'),
-        status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified'),
-    },
-    annotations: READ_ONLY,
-}, async ({ query, status }) => {
-    if (isLocalMode) {
-        const intents = (0, local_reader_1.readLocalIntents)();
-        const q = query.toLowerCase();
-        const matches = intents.filter(i => {
-            const text = [i.title, i.objective, ...i.outcomes, ...i.constraints].join(' ').toLowerCase();
-            return text.includes(q) && (!status || i.status === status);
-        });
-        return { content: [{ type: 'text', text: JSON.stringify({ results: matches, count: matches.length, query }, null, 2) }] };
-    }
-    try {
-        const intents = await client.listIntents(status);
-        const q = query.toLowerCase();
-        const matches = intents.filter(i => {
-            const text = [i.title, i.objective, ...(i.outcomes || []), ...(i.constraints || [])].join(' ').toLowerCase();
-            return text.includes(q);
-        });
-        const results = matches.map(i => ({
-            id: i.id,
-            title: i.title,
-            objective: i.objective,
-            status: i.status,
-            stageName: i.stageName,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length, query }, null, 2) }] };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Search failed: ${e.message}` }] };
-    }
-});
-server.registerTool('analyze_intent_graph', {
-    title: 'Analyze Intent Graph',
-    description: 'Analyze the intent dependency graph for risks and strategic insights. Returns critical path, cycles, bottlenecks, orphans, status mismatches, and stalled intents.',
-    inputSchema: {
-        analysis: zod_1.z.enum(['full', 'critical-path', 'risks', 'status']).optional()
-            .describe('Type of analysis: full (default), critical-path, risks, or status distribution'),
-    },
-    annotations: READ_ONLY,
-}, async ({ analysis }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Graph analysis requires cloud mode.' }] };
-    }
-    try {
-        const intents = await client.listIntents();
-        if (intents.length === 0) {
-            return { content: [{ type: 'text', text: 'No intents found in workspace.' }] };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        intentId: intent.id,
+                        title: intent.title,
+                        relations: intent.relations,
+                    }, null, 2)
+                }]
+        };
+    });
+    server.registerTool('search_intents', {
+        title: 'Search Intents',
+        description: 'Search intents by keyword. Searches across user goals, objectives, outcomes, and constraints.',
+        inputSchema: {
+            query: zod_1.z.string().describe('Search keyword or phrase'),
+            status: zod_1.z.string().optional().describe('Filter by status: draft, validated, approved, shipped, verified'),
+        },
+        annotations: READ_ONLY,
+    }, async ({ query, status }) => {
+        if (isLocalMode) {
+            const intents = (0, local_reader_1.readLocalIntents)();
+            const q = query.toLowerCase();
+            const matches = intents.filter(i => {
+                const text = [i.title, i.objective, ...i.outcomes, ...i.constraints].join(' ').toLowerCase();
+                return text.includes(q) && (!status || i.status === status);
+            });
+            return { content: [{ type: 'text', text: JSON.stringify({ results: matches, count: matches.length, query }, null, 2) }] };
         }
-        const specMap = new Map(intents.map(i => [i.id, i]));
-        const type = analysis || 'full';
-        if (type === 'status') {
-            const dist = { draft: 0, validated: 0, approved: 0, shipped: 0, verified: 0 };
-            for (const i of intents)
-                dist[i.status] = (dist[i.status] || 0) + 1;
-            return { content: [{ type: 'text', text: JSON.stringify({ statusDistribution: dist, total: intents.length }, null, 2) }] };
-        }
-        // Build dependency graph
-        const specIds = new Set(intents.map(i => i.id));
-        const forward = new Map();
-        const reverse = new Map();
-        for (const id of specIds) {
-            forward.set(id, new Set());
-            reverse.set(id, new Set());
-        }
-        for (const intent of intents) {
-            for (const rel of intent.relations || []) {
-                if (rel.type === 'depends_on' && specIds.has(rel.targetId)) {
-                    forward.get(intent.id).add(rel.targetId);
-                    reverse.get(rel.targetId).add(intent.id);
-                }
-            }
-        }
-        // Detect cycles
-        const WHITE = 0, GRAY = 1, BLACK = 2;
-        const color = new Map();
-        const parent = new Map();
-        const cycles = [];
-        for (const id of forward.keys())
-            color.set(id, WHITE);
-        for (const startId of forward.keys()) {
-            if (color.get(startId) !== WHITE)
-                continue;
-            const stack = [startId];
-            parent.set(startId, null);
-            while (stack.length > 0) {
-                const id = stack[stack.length - 1];
-                if (color.get(id) === WHITE) {
-                    color.set(id, GRAY);
-                    for (const dep of forward.get(id) || new Set()) {
-                        if (color.get(dep) === WHITE) {
-                            parent.set(dep, id);
-                            stack.push(dep);
-                        }
-                        else if (color.get(dep) === GRAY) {
-                            const cycle = [dep];
-                            let cur = id;
-                            while (cur !== dep) {
-                                cycle.push(cur);
-                                cur = parent.get(cur);
+        try {
+            const intents = await client.listIntents(status);
+            const q = query.toLowerCase();
+            const matches = intents.filter(i => {
+                const text = [i.title, i.objective, ...(i.outcomes || []), ...(i.constraints || [])].join(' ').toLowerCase();
+                return text.includes(q);
+            });
+            const results = matches.map(i => ({
+                id: i.id,
+                title: i.title,
+                objective: i.objective,
+                status: i.status,
+                stageName: i.stageName,
+            }));
+            return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length, query }, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Search failed: ${e.message}` }] };
+        }
+    });
+    server.registerTool('analyze_intent_graph', {
+        title: 'Analyze Intent Graph',
+        description: 'Analyze the intent dependency graph for risks and strategic insights. Returns critical path, cycles, bottlenecks, orphans, status mismatches, and stalled intents.',
+        inputSchema: {
+            analysis: zod_1.z.enum(['full', 'critical-path', 'risks', 'status']).optional()
+                .describe('Type of analysis: full (default), critical-path, risks, or status distribution'),
+        },
+        annotations: READ_ONLY,
+    }, async ({ analysis }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Graph analysis requires cloud mode.' }] };
+        }
+        try {
+            const intents = await client.listIntents();
+            if (intents.length === 0) {
+                return { content: [{ type: 'text', text: 'No intents found in workspace.' }] };
+            }
+            const specMap = new Map(intents.map(i => [i.id, i]));
+            const type = analysis || 'full';
+            if (type === 'status') {
+                const dist = { draft: 0, validated: 0, approved: 0, shipped: 0, verified: 0 };
+                for (const i of intents)
+                    dist[i.status] = (dist[i.status] || 0) + 1;
+                return { content: [{ type: 'text', text: JSON.stringify({ statusDistribution: dist, total: intents.length }, null, 2) }] };
+            }
+            // Build dependency graph
+            const specIds = new Set(intents.map(i => i.id));
+            const forward = new Map();
+            const reverse = new Map();
+            for (const id of specIds) {
+                forward.set(id, new Set());
+                reverse.set(id, new Set());
+            }
+            for (const intent of intents) {
+                for (const rel of intent.relations || []) {
+                    if (rel.type === 'depends_on' && specIds.has(rel.targetId)) {
+                        forward.get(intent.id).add(rel.targetId);
+                        reverse.get(rel.targetId).add(intent.id);
+                    }
+                }
+            }
+            // Detect cycles
+            const WHITE = 0, GRAY = 1, BLACK = 2;
+            const color = new Map();
+            const parent = new Map();
+            const cycles = [];
+            for (const id of forward.keys())
+                color.set(id, WHITE);
+            for (const startId of forward.keys()) {
+                if (color.get(startId) !== WHITE)
+                    continue;
+                const stack = [startId];
+                parent.set(startId, null);
+                while (stack.length > 0) {
+                    const id = stack[stack.length - 1];
+                    if (color.get(id) === WHITE) {
+                        color.set(id, GRAY);
+                        for (const dep of forward.get(id) || new Set()) {
+                            if (color.get(dep) === WHITE) {
+                                parent.set(dep, id);
+                                stack.push(dep);
+                            }
+                            else if (color.get(dep) === GRAY) {
+                                const cycle = [dep];
+                                let cur = id;
+                                while (cur !== dep) {
+                                    cycle.push(cur);
+                                    cur = parent.get(cur);
+                                }
+                                cycle.push(dep);
+                                cycle.reverse();
+                                cycles.push(cycle);
                             }
-                            cycle.push(dep);
-                            cycle.reverse();
-                            cycles.push(cycle);
                         }
                     }
+                    else {
+                        color.set(id, BLACK);
+                        stack.pop();
+                    }
                 }
-                else {
-                    color.set(id, BLACK);
-                    stack.pop();
+            }
+            // Critical path (longest path via topo sort)
+            let criticalPath = [];
+            if (cycles.length === 0) {
+                const topoInDegree = new Map();
+                for (const id of specIds)
+                    topoInDegree.set(id, (forward.get(id) || new Set()).size);
+                const queue = [];
+                for (const [id, deg] of topoInDegree) {
+                    if (deg === 0)
+                        queue.push(id);
+                }
+                const dist = new Map();
+                const prev = new Map();
+                for (const id of specIds) {
+                    dist.set(id, 1);
+                    prev.set(id, null);
+                }
+                while (queue.length > 0) {
+                    const id = queue.shift();
+                    for (const dep of reverse.get(id) || new Set()) {
+                        const newDist = dist.get(id) + 1;
+                        if (newDist > dist.get(dep)) {
+                            dist.set(dep, newDist);
+                            prev.set(dep, id);
+                        }
+                        topoInDegree.set(dep, topoInDegree.get(dep) - 1);
+                        if (topoInDegree.get(dep) === 0)
+                            queue.push(dep);
+                    }
+                }
+                let maxDist = 0, endNode = null;
+                for (const [id, d] of dist) {
+                    if (d > maxDist) {
+                        maxDist = d;
+                        endNode = id;
+                    }
+                }
+                if (endNode) {
+                    let cur = endNode;
+                    while (cur) {
+                        criticalPath.push(cur);
+                        cur = prev.get(cur) || null;
+                    }
+                    criticalPath.reverse();
                 }
             }
-        }
-        // Critical path (longest path via topo sort)
-        let criticalPath = [];
-        if (cycles.length === 0) {
-            const topoInDegree = new Map();
-            for (const id of specIds)
-                topoInDegree.set(id, (forward.get(id) || new Set()).size);
-            const queue = [];
-            for (const [id, deg] of topoInDegree) {
-                if (deg === 0)
-                    queue.push(id);
+            // Bottlenecks
+            const bottlenecks = [];
+            for (const [id, dependents] of reverse) {
+                if (dependents.size >= 3) {
+                    const spec = specMap.get(id);
+                    bottlenecks.push({ id, title: spec?.title || 'Untitled', dependentCount: dependents.size, status: spec?.status || 'unknown' });
+                }
             }
-            const dist = new Map();
-            const prev = new Map();
-            for (const id of specIds) {
-                dist.set(id, 1);
-                prev.set(id, null);
-            }
-            while (queue.length > 0) {
-                const id = queue.shift();
-                for (const dep of reverse.get(id) || new Set()) {
-                    const newDist = dist.get(id) + 1;
-                    if (newDist > dist.get(dep)) {
-                        dist.set(dep, newDist);
-                        prev.set(dep, id);
-                    }
-                    topoInDegree.set(dep, topoInDegree.get(dep) - 1);
-                    if (topoInDegree.get(dep) === 0)
-                        queue.push(dep);
-                }
-            }
-            let maxDist = 0, endNode = null;
-            for (const [id, d] of dist) {
-                if (d > maxDist) {
-                    maxDist = d;
-                    endNode = id;
-                }
-            }
-            if (endNode) {
-                let cur = endNode;
-                while (cur) {
-                    criticalPath.push(cur);
-                    cur = prev.get(cur) || null;
-                }
-                criticalPath.reverse();
-            }
-        }
-        // Bottlenecks
-        const bottlenecks = [];
-        for (const [id, dependents] of reverse) {
-            if (dependents.size >= 3) {
-                const spec = specMap.get(id);
-                bottlenecks.push({ id, title: spec?.title || 'Untitled', dependentCount: dependents.size, status: spec?.status || 'unknown' });
-            }
-        }
-        // Orphans
-        const orphans = [];
-        for (const intent of intents) {
-            const hasRelations = intent.relations && intent.relations.length > 0;
-            const isTargeted = intents.some(i => i.relations?.some(r => r.targetId === intent.id));
-            if (!hasRelations && !isTargeted)
-                orphans.push(intent.id);
-        }
-        // Status distribution
-        const statusDist = { draft: 0, validated: 0, approved: 0, shipped: 0, verified: 0 };
-        for (const i of intents)
-            statusDist[i.status] = (statusDist[i.status] || 0) + 1;
-        if (type === 'critical-path') {
-            const pathDetails = criticalPath.map(id => {
-                const s = specMap.get(id);
-                return { id, title: s?.title || 'Untitled', status: s?.status || 'unknown' };
-            });
-            return { content: [{ type: 'text', text: JSON.stringify({ criticalPath: pathDetails, length: criticalPath.length }, null, 2) }] };
-        }
-        if (type === 'risks') {
-            const risks = [];
-            for (const cycle of cycles) {
-                const names = cycle.slice(0, -1).map(id => specMap.get(id)?.title || 'Untitled');
-                risks.push({ type: 'cycle', severity: 'critical', message: `Circular dependency: ${names.join(' \u2192 ')}` });
-            }
-            for (const b of bottlenecks) {
-                const isDraft = b.status === 'draft' || b.status === 'validated';
-                risks.push({ type: 'bottleneck', severity: isDraft ? 'critical' : 'warning', message: `"${b.title}" blocks ${b.dependentCount} intents${isDraft ? ` and is still ${b.status}` : ''}` });
-            }
-            return { content: [{ type: 'text', text: JSON.stringify({ risks }, null, 2) }] };
-        }
-        // Full analysis
-        const result = {
-            summary: { total: intents.length, statusDistribution: statusDist },
-            criticalPath: criticalPath.map(id => {
-                const s = specMap.get(id);
-                return { id, title: s?.title || 'Untitled', status: s?.status || 'unknown' };
-            }),
-            cycles: cycles.map(c => c.slice(0, -1).map(id => ({ id, title: specMap.get(id)?.title || 'Untitled' }))),
-            bottlenecks,
-            orphanCount: orphans.length,
+            // Orphans
+            const orphans = [];
+            for (const intent of intents) {
+                const hasRelations = intent.relations && intent.relations.length > 0;
+                const isTargeted = intents.some(i => i.relations?.some(r => r.targetId === intent.id));
+                if (!hasRelations && !isTargeted)
+                    orphans.push(intent.id);
+            }
+            // Status distribution
+            const statusDist = { draft: 0, validated: 0, approved: 0, shipped: 0, verified: 0 };
+            for (const i of intents)
+                statusDist[i.status] = (statusDist[i.status] || 0) + 1;
+            if (type === 'critical-path') {
+                const pathDetails = criticalPath.map(id => {
+                    const s = specMap.get(id);
+                    return { id, title: s?.title || 'Untitled', status: s?.status || 'unknown' };
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ criticalPath: pathDetails, length: criticalPath.length }, null, 2) }] };
+            }
+            if (type === 'risks') {
+                const risks = [];
+                for (const cycle of cycles) {
+                    const names = cycle.slice(0, -1).map(id => specMap.get(id)?.title || 'Untitled');
+                    risks.push({ type: 'cycle', severity: 'critical', message: `Circular dependency: ${names.join(' \u2192 ')}` });
+                }
+                for (const b of bottlenecks) {
+                    const isDraft = b.status === 'draft' || b.status === 'validated';
+                    risks.push({ type: 'bottleneck', severity: isDraft ? 'critical' : 'warning', message: `"${b.title}" blocks ${b.dependentCount} intents${isDraft ? ` and is still ${b.status}` : ''}` });
+                }
+                return { content: [{ type: 'text', text: JSON.stringify({ risks }, null, 2) }] };
+            }
+            // Full analysis
+            const result = {
+                summary: { total: intents.length, statusDistribution: statusDist },
+                criticalPath: criticalPath.map(id => {
+                    const s = specMap.get(id);
+                    return { id, title: s?.title || 'Untitled', status: s?.status || 'unknown' };
+                }),
+                cycles: cycles.map(c => c.slice(0, -1).map(id => ({ id, title: specMap.get(id)?.title || 'Untitled' }))),
+                bottlenecks,
+                orphanCount: orphans.length,
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Graph analysis failed: ${e.message}` }] };
+        }
+    });
+    server.registerTool('export_context', {
+        title: 'Export Context',
+        description: 'Export workspace context as a formatted file. Use "claude-md" for CLAUDE.md (full workspace context), "cursorrules" for Cursor AI rules, or "intent-md" for a single intent specification file.',
+        inputSchema: {
+            format: zod_1.z.enum(['claude-md', 'cursorrules', 'intent-md']).describe('Export format'),
+            intentId: zod_1.z.string().optional().describe('Intent ID (optional, for cursorrules and intent-md)'),
+        },
+        annotations: READ_ONLY,
+    }, async ({ format, intentId }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Export requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
+        }
+        try {
+            const content = await client.exportContext(format, intentId);
+            return { content: [{ type: 'text', text: content }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Export failed: ${e.message}` }] };
+        }
+    });
+    server.registerTool('get_agent_prompt', {
+        title: 'Get Agent Prompt',
+        description: 'Get a formatted execution prompt for a specific intent. This is the full structured prompt including objective, outcomes, constraints, edge cases, and verification steps.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to generate a prompt for'),
+            mode: zod_1.z.enum(['draft', 'execute']).optional().describe('draft = critique the spec, execute = implement it'),
+        },
+        annotations: READ_ONLY,
+    }, async ({ intentId, mode }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Agent prompts require cloud mode for full context generation.' }] };
+        }
+        const result = await client.getIntentPrompt(intentId, 'claude-code', mode || 'execute');
+        return {
+            content: [{
+                    type: 'text',
+                    text: result.prompt
+                }]
         };
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Graph analysis failed: ${e.message}` }] };
-    }
-});
-server.registerTool('export_context', {
-    title: 'Export Context',
-    description: 'Export workspace context as a formatted file. Use "claude-md" for CLAUDE.md (full workspace context), "cursorrules" for Cursor AI rules, or "intent-md" for a single intent specification file.',
-    inputSchema: {
-        format: zod_1.z.enum(['claude-md', 'cursorrules', 'intent-md']).describe('Export format'),
-        intentId: zod_1.z.string().optional().describe('Intent ID (optional, for cursorrules and intent-md)'),
-    },
-    annotations: READ_ONLY,
-}, async ({ format, intentId }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Export requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
-    }
-    try {
-        const content = await client.exportContext(format, intentId);
-        return { content: [{ type: 'text', text: content }] };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Export failed: ${e.message}` }] };
-    }
-});
-server.registerTool('get_agent_prompt', {
-    title: 'Get Agent Prompt',
-    description: 'Get a formatted execution prompt for a specific intent. This is the full structured prompt including objective, outcomes, constraints, edge cases, and verification steps.',
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to generate a prompt for'),
-        mode: zod_1.z.enum(['draft', 'execute']).optional().describe('draft = critique the spec, execute = implement it'),
-    },
-    annotations: READ_ONLY,
-}, async ({ intentId, mode }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Agent prompts require cloud mode for full context generation.' }] };
-    }
-    const result = await client.getIntentPrompt(intentId, 'claude-code', mode || 'execute');
-    return {
-        content: [{
-                type: 'text',
-                text: result.prompt
-            }]
-    };
-});
-server.registerTool('get_workspace', {
-    title: 'Get Workspace',
-    description: 'Get workspace details including strategy (vision, non-negotiables, architecture principles) and constitution rules.',
-    annotations: READ_ONLY,
-}, async () => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Workspace details are not available in local mode.' }] };
-    }
-    const workspace = await client.getWorkspace();
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(workspace, null, 2)
-            }]
-    };
-});
-server.registerTool('get_constitution', {
-    title: 'Get Constitution',
-    description: 'Get the workspace constitution rules. These are mandatory constraints that all implementations must respect.',
-    annotations: READ_ONLY,
-}, async () => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Constitution rules are not available in local mode.' }] };
-    }
-    const result = await client.getConstitution();
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(result, null, 2)
-            }]
-    };
-});
-server.registerTool('list_signals', {
-    title: 'List Signals',
-    description: 'Query active signals (stale intents, loose evidence, evidence matches, verification failures). Signals surface things that need attention. By default returns only active (non-dismissed) signals.',
-    inputSchema: {
-        productId: zod_1.z.string().optional().describe('Filter by product ID'),
-        type: zod_1.z.enum(['evidence_match', 'evidence_freshness', 'loose_evidence', 'stale_intent', 'alignment_drift', 'verification_failed']).optional().describe('Filter by signal type'),
-        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Filter by severity'),
-        dismissed: zod_1.z.enum(['true', 'false', 'all']).optional().describe('Filter by dismissed status (default: false = active only)'),
-        limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
-    },
-    annotations: READ_ONLY,
-}, async (filters) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Signals require cloud mode.' }] };
-    }
-    try {
-        const result = await client.listSignals(filters);
-        if (result.signals.length === 0) {
-            return { content: [{ type: 'text', text: 'No signals found matching the filters. All clear!' }] };
+    });
+    server.registerTool('get_workspace', {
+        title: 'Get Workspace',
+        description: 'Get workspace details including strategy (vision, non-negotiables, architecture principles) and constitution rules.',
+        annotations: READ_ONLY,
+    }, async () => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Workspace details are not available in local mode.' }] };
         }
+        const workspace = await client.getWorkspace();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(workspace, null, 2)
+                }]
+        };
+    });
+    server.registerTool('get_constitution', {
+        title: 'Get Constitution',
+        description: 'Get the workspace constitution rules. These are mandatory constraints that all implementations must respect.',
+        annotations: READ_ONLY,
+    }, async () => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Constitution rules are not available in local mode.' }] };
+        }
+        const result = await client.getConstitution();
         return {
             content: [{
                     type: 'text',
                     text: JSON.stringify(result, null, 2)
                 }]
         };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Failed to fetch signals: ${e.message}` }] };
-    }
-});
-// ============================================================
-// Tools — Write Operations
-// ============================================================
-server.registerTool('update_intent_status', {
-    title: 'Update Intent Status',
-    description: 'Update the status of an intent. Use this to mark an intent as shipped after implementation, or verified after testing. For shipped/verified transitions, the response includes a verification checklist of outcomes, constitution rules, and health metrics that should be confirmed.',
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to update'),
-        status: zod_1.z.enum(['draft', 'validated', 'approved', 'shipped', 'verified']).describe('The new status'),
-    },
-    annotations: { ...WRITE_OP, idempotentHint: true },
-}, async ({ intentId, status }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Status updates are not available in local mode. Use cloud mode.' }] };
-    }
-    const result = await client.updateIntentStatus(intentId, status);
-    let responseText = `Intent ${intentId} status updated to "${status}".`;
-    // Surface verification checklist for shipped/verified transitions
-    if (result.verificationChecklist && result.verificationChecklist.length > 0) {
-        responseText += `\n\nVerification Checklist (${result.verificationChecklistCount} items to verify):`;
-        for (const item of result.verificationChecklist) {
-            responseText += `\n  [ ] [${item.category}] ${item.text}`;
+    });
+    // ============================================================
+    // Tools — Write Operations
+    // ============================================================
+    server.registerTool('update_intent_status', {
+        title: 'Update Intent Status',
+        description: 'Update the status of an intent. Use this to mark an intent as shipped after implementation, or verified after testing. For shipped/verified transitions, the response includes a verification checklist of outcomes, constitution rules, and health metrics that should be confirmed.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to update'),
+            status: zod_1.z.enum(['draft', 'validated', 'approved', 'shipped', 'verified']).describe('The new status'),
+        },
+        annotations: { ...WRITE_OP, idempotentHint: true },
+    }, async ({ intentId, status }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Status updates are not available in local mode. Use cloud mode.' }] };
         }
-        responseText += `\n\nThese items should be verified. Use log_implementation_note to record verification results.`;
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: responseText
-            }]
-    };
-});
-server.registerTool('log_implementation_note', {
-    title: 'Log Implementation Note',
-    description: 'Record a technical decision or implementation note for an intent. Use this to document why you chose a specific approach.',
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to attach the note to'),
-        note: zod_1.z.string().describe('The implementation note or technical decision'),
-    },
-    annotations: WRITE_OP,
-}, async ({ intentId, note }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Notes are not available in local mode. Use cloud mode.' }] };
-    }
-    const result = await client.logNote(intentId, note, 'mcp');
-    return {
-        content: [{
-                type: 'text',
-                text: `Note logged for intent ${intentId}: "${note}"`
-            }]
-    };
-});
-server.registerTool('create_intent', {
-    title: 'Create Intent',
-    description: 'Create a new intent spec in the workspace. Requires at minimum a title, objective, and productId. Returns the created intent with its ID. Use list_intents first to see existing intents and avoid duplicates.',
-    inputSchema: {
-        title: zod_1.z.string().describe('Short name for the intent (e.g., "Improve onboarding flow")'),
-        objective: zod_1.z.string().describe('Why this matters — the problem and who has it'),
-        productId: zod_1.z.string().describe('Product (Space) ID this intent belongs to. Use get_workspace to find product IDs.'),
-        outcomes: zod_1.z.array(zod_1.z.string()).optional().describe('Observable, testable state changes'),
-        constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Hard limits the implementation must respect'),
-        healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('What to monitor after shipping'),
-        edgeCases: zod_1.z.array(zod_1.z.object({
-            scenario: zod_1.z.string(),
-            expectedBehavior: zod_1.z.string(),
-        })).optional().describe('Failure modes and boundary conditions'),
-        verification: zod_1.z.object({
-            manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
-            unitTests: zod_1.z.array(zod_1.z.string()).optional(),
-            e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
-        }).optional().describe('How to confirm it works'),
-        problemSeverity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('How severe the problem is'),
-    },
-    annotations: WRITE_OP,
-}, async ({ productId, ...rest }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Creating intents requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
-    }
-    const result = await client.createIntent({ productId, ...rest });
-    return {
-        content: [{
-                type: 'text',
-                text: `Intent created: ${result.id}\nTitle: "${result.title}"\nStatus: ${result.status}\nProduct: ${result.productId || productId}`
-            }]
-    };
-});
-server.registerTool('update_intent', {
-    title: 'Update Intent',
-    description: "Update an existing intent's content. Provide only the fields you want to change. Does NOT change intent status (use update_intent_status for that).",
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to update'),
-        title: zod_1.z.string().optional().describe('New title'),
-        objective: zod_1.z.string().optional().describe('Updated objective'),
-        outcomes: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all outcomes'),
-        constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all constraints'),
-        healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all health metrics'),
-        edgeCases: zod_1.z.array(zod_1.z.object({
-            scenario: zod_1.z.string(),
-            expectedBehavior: zod_1.z.string(),
-        })).optional().describe('Replace all edge cases'),
-        verification: zod_1.z.object({
-            manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
-            unitTests: zod_1.z.array(zod_1.z.string()).optional(),
-            e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
-        }).optional().describe('Replace verification plan'),
-        problemSeverity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
-    },
-    annotations: { ...WRITE_OP, idempotentHint: true },
-}, async ({ intentId, ...updates }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Updating intents requires cloud mode.' }] };
-    }
-    const result = await client.updateIntent(intentId, updates);
-    const changedFields = Object.keys(updates).filter(k => updates[k] !== undefined);
-    return {
-        content: [{
-                type: 'text',
-                text: `Intent ${intentId} updated. Fields changed: ${changedFields.join(', ')}`
-            }]
-    };
-});
-server.registerTool('query_evidence', {
-    title: 'Query Evidence',
-    description: 'Search evidence items (friction points, user quotes, observations, metrics, feature requests) by product, type, severity, or text. Returns matching evidence with IDs that can be linked to intents.',
-    inputSchema: {
-        productId: zod_1.z.string().optional().describe('Filter by product (Space) ID'),
-        type: zod_1.z.enum(['friction', 'quote', 'observation', 'metric', 'request']).optional().describe('Filter by evidence type'),
-        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Filter by severity'),
-        search: zod_1.z.string().optional().describe('Text search across evidence content'),
-        tags: zod_1.z.string().optional().describe('Comma-separated tags to filter by'),
-        limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
-    },
-    annotations: READ_ONLY,
-}, async (filters) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Evidence queries require cloud mode.' }] };
-    }
-    const result = await client.queryEvidence(filters);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(result, null, 2)
-            }]
-    };
-});
-server.registerTool('create_evidence', {
-    title: 'Create Evidence',
-    description: 'Create a new evidence item (e.g., a discovered bug, user feedback quote, behavioral observation, or feature request). Evidence can later be linked to intents to support prioritization.',
-    inputSchema: {
-        content: zod_1.z.string().describe('The evidence content — a finding, quote, or observation'),
-        type: zod_1.z.enum(['friction', 'quote', 'observation', 'metric', 'request']).describe('Type of evidence'),
-        productId: zod_1.z.string().describe('Product (Space) ID this evidence belongs to'),
-        source: zod_1.z.string().optional().describe('Where this evidence came from (e.g., "User interview", "Bug report", "Support ticket")'),
-        sourceUrl: zod_1.z.string().optional().describe('URL to the original source'),
-        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Severity level (required for friction type)'),
-        sentiment: zod_1.z.enum(['positive', 'negative', 'neutral', 'mixed']).optional().describe('Emotional sentiment'),
-        tags: zod_1.z.array(zod_1.z.string()).optional().describe('Category tags (e.g., ["Onboarding", "Performance"])'),
-        stage: zod_1.z.string().optional().describe('User journey stage (e.g., "Discovery", "Checkout")'),
-    },
-    annotations: WRITE_OP,
-}, async ({ productId, ...rest }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Creating evidence requires cloud mode.' }] };
-    }
-    const result = await client.createEvidence({ productId, ...rest });
-    return {
-        content: [{
-                type: 'text',
-                text: `Evidence created: ${result.id}\nType: ${result.type}\nContent: "${(result.content || '').slice(0, 80)}${(result.content || '').length > 80 ? '...' : ''}"`
-            }]
-    };
-});
-server.registerTool('link_evidence', {
-    title: 'Link Evidence to Intent',
-    description: 'Link or unlink evidence items to/from an intent. Linking evidence to intents establishes traceability between user problems and planned solutions.',
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to link evidence to'),
-        link: zod_1.z.array(zod_1.z.string()).optional().describe('Evidence IDs to link to this intent'),
-        unlink: zod_1.z.array(zod_1.z.string()).optional().describe('Evidence IDs to unlink from this intent'),
-    },
-    annotations: WRITE_OP,
-}, async ({ intentId, link, unlink }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Evidence linking requires cloud mode.' }] };
-    }
-    const result = await client.linkEvidence(intentId, { link, unlink });
-    const actions = [];
-    if (link && link.length > 0)
-        actions.push(`linked ${result.linked} evidence items`);
-    if (unlink && unlink.length > 0)
-        actions.push(`unlinked ${result.unlinked} evidence items`);
-    return {
-        content: [{
-                type: 'text',
-                text: `Intent ${intentId}: ${actions.join(', ')}. Total evidence linked: ${result.evidenceIds.length}`
-            }]
-    };
-});
-server.registerTool('verify_implementation', {
-    title: 'Verify Implementation',
-    description: 'AI-grade your implementation against the intent spec. Checks each outcome, constraint, constitution rule, and edge case. Returns pass/fail per item with reasoning and an overall score. Also logs the result as an implementation note.',
-    inputSchema: {
-        intentId: zod_1.z.string().describe('The intent ID to verify against'),
-        summary: zod_1.z.string().describe('Description of what was implemented and how'),
-        codeChanges: zod_1.z.string().optional().describe('Summary of code changes (file list, key modifications)'),
-    },
-    annotations: WRITE_OP,
-}, async ({ intentId, summary, codeChanges }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Verification requires cloud mode.' }] };
-    }
-    try {
-        const result = await client.verifyImplementation(intentId, summary, codeChanges);
-        let text = `Verification ${result.pass ? 'PASSED' : 'FAILED'} (score: ${result.score}/100)\n\n`;
-        text += `${result.summary}\n\n`;
-        for (const r of result.results) {
-            const icon = r.status === 'pass' ? '[PASS]' : r.status === 'fail' ? '[FAIL]' : '[????]';
-            text += `${icon} [${r.category}] ${r.item}\n    ${r.reasoning}\n`;
+        const result = await client.updateIntentStatus(intentId, status);
+        let responseText = `Intent ${intentId} status updated to "${status}".`;
+        // Surface verification checklist for shipped/verified transitions
+        if (result.verificationChecklist && result.verificationChecklist.length > 0) {
+            responseText += `\n\nVerification Checklist (${result.verificationChecklistCount} items to verify):`;
+            for (const item of result.verificationChecklist) {
+                responseText += `\n  [ ] [${item.category}] ${item.text}`;
+            }
+            responseText += `\n\nThese items should be verified. Use log_implementation_note to record verification results.`;
         }
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Verification failed: ${e.message}` }] };
-    }
-});
-server.registerTool('dismiss_signal', {
-    title: 'Dismiss Signal',
-    description: 'Dismiss a signal by ID. Use this when a signal has been addressed or is no longer relevant.',
-    inputSchema: {
-        signalId: zod_1.z.string().describe('The signal ID to dismiss'),
-    },
-    annotations: { ...WRITE_OP, idempotentHint: true },
-}, async ({ signalId }) => {
-    if (isLocalMode) {
-        return { content: [{ type: 'text', text: 'Dismissing signals requires cloud mode.' }] };
-    }
-    try {
-        await client.dismissSignal(signalId);
         return {
             content: [{
                     type: 'text',
-                    text: `Signal ${signalId} dismissed successfully.`
+                    text: responseText
                 }]
         };
-    }
-    catch (e) {
-        return { content: [{ type: 'text', text: `Failed to dismiss signal: ${e.message}` }] };
-    }
-});
-// ============================================================
-// Prompts
-// ============================================================
-server.prompt('implement-intent', 'Get full implementation context for a specific intent, including objective, outcomes, constraints, edge cases, and verification steps.', {
-    intentId: zod_1.z.string().describe('The intent ID to implement'),
-}, async ({ intentId }) => {
-    return {
-        messages: [{
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: `I need to implement intent ${intentId}. Please:\n1. Use the get_agent_prompt tool to fetch the full execution prompt for this intent\n2. Use get_constitution to check for workspace constraints I must respect\n3. Review the intent details and create an implementation plan\n4. After implementation, use verify_implementation to AI-grade your work against the spec\n5. If verification passes, use update_intent_status to mark it as "shipped"\n6. Use log_implementation_note to document key technical decisions`,
-                },
-            }],
-    };
-});
-server.prompt('review-risks', 'Analyze the intent graph for architectural risks, circular dependencies, bottlenecks, and stalled work.', {}, async () => {
-    return {
-        messages: [{
-                role: 'user',
-                content: {
+    });
+    server.registerTool('log_implementation_note', {
+        title: 'Log Implementation Note',
+        description: 'Record a technical decision or implementation note for an intent. Use this to document why you chose a specific approach.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to attach the note to'),
+            note: zod_1.z.string().describe('The implementation note or technical decision'),
+        },
+        annotations: WRITE_OP,
+    }, async ({ intentId, note }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Notes are not available in local mode. Use cloud mode.' }] };
+        }
+        const result = await client.logNote(intentId, note, 'mcp');
+        return {
+            content: [{
                     type: 'text',
-                    text: 'Please analyze our intent graph for risks:\n1. Use analyze_intent_graph with analysis "full" to get the complete graph analysis\n2. Summarize the critical path and explain why it matters\n3. Flag any cycles (circular dependencies) as urgent issues\n4. Identify bottlenecks \u2014 intents that block many others, especially if still in draft\n5. Suggest concrete actions to reduce risk',
-                },
-            }],
-    };
-});
-server.prompt('what-next', 'Suggest the highest-priority intent to work on next, based on dependency graph analysis and current status.', {}, async () => {
-    return {
-        messages: [{
-                role: 'user',
-                content: {
+                    text: `Note logged for intent ${intentId}: "${note}"`
+                }]
+        };
+    });
+    server.registerTool('create_intent', {
+        title: 'Create Intent',
+        description: 'Create a new intent spec in the workspace. Requires at minimum a title, objective, and productId. Returns the created intent with its ID. Use list_intents first to see existing intents and avoid duplicates.',
+        inputSchema: {
+            title: zod_1.z.string().describe('Short name for the intent (e.g., "Improve onboarding flow")'),
+            objective: zod_1.z.string().describe('Why this matters — the problem and who has it'),
+            productId: zod_1.z.string().describe('Product (Space) ID this intent belongs to. Use get_workspace to find product IDs.'),
+            outcomes: zod_1.z.array(zod_1.z.string()).optional().describe('Observable, testable state changes'),
+            constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Hard limits the implementation must respect'),
+            healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('What to monitor after shipping'),
+            edgeCases: zod_1.z.array(zod_1.z.object({
+                scenario: zod_1.z.string(),
+                expectedBehavior: zod_1.z.string(),
+            })).optional().describe('Failure modes and boundary conditions'),
+            verification: zod_1.z.object({
+                manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
+                unitTests: zod_1.z.array(zod_1.z.string()).optional(),
+                e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
+            }).optional().describe('How to confirm it works'),
+            problemSeverity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('How severe the problem is'),
+        },
+        annotations: WRITE_OP,
+    }, async ({ productId, ...rest }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Creating intents requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
+        }
+        const result = await client.createIntent({ productId, ...rest });
+        return {
+            content: [{
                     type: 'text',
-                    text: 'Help me decide what to work on next:\n1. Use analyze_intent_graph with analysis "critical-path" to find the critical path\n2. Use list_intents with status "approved" to see what\'s ready for implementation\n3. Consider: which approved intents are on the critical path? Which unblock the most other work?\n4. Recommend the single highest-impact intent to implement next, and explain why',
-                },
-            }],
-    };
-});
-server.prompt('create-from-evidence', 'Search for evidence items, identify patterns, and create an intent based on the strongest evidence cluster.', {
-    productId: zod_1.z.string().describe('The product ID to search evidence for'),
-}, async ({ productId }) => {
-    return {
-        messages: [{
-                role: 'user',
-                content: {
+                    text: `Intent created: ${result.id}\nTitle: "${result.title}"\nStatus: ${result.status}\nProduct: ${result.productId || productId}`
+                }]
+        };
+    });
+    server.registerTool('update_intent', {
+        title: 'Update Intent',
+        description: "Update an existing intent's content. Provide only the fields you want to change. Does NOT change intent status (use update_intent_status for that).",
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to update'),
+            title: zod_1.z.string().optional().describe('New title'),
+            objective: zod_1.z.string().optional().describe('Updated objective'),
+            outcomes: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all outcomes'),
+            constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all constraints'),
+            healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('Replace all health metrics'),
+            edgeCases: zod_1.z.array(zod_1.z.object({
+                scenario: zod_1.z.string(),
+                expectedBehavior: zod_1.z.string(),
+            })).optional().describe('Replace all edge cases'),
+            verification: zod_1.z.object({
+                manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
+                unitTests: zod_1.z.array(zod_1.z.string()).optional(),
+                e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
+            }).optional().describe('Replace verification plan'),
+            problemSeverity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
+        },
+        annotations: { ...WRITE_OP, idempotentHint: true },
+    }, async ({ intentId, ...updates }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Updating intents requires cloud mode.' }] };
+        }
+        const result = await client.updateIntent(intentId, updates);
+        const changedFields = Object.keys(updates).filter(k => updates[k] !== undefined);
+        return {
+            content: [{
                     type: 'text',
-                    text: `Help me create a new intent from evidence:\n1. Use query_evidence with productId "${productId}" to see what evidence exists\n2. Look for patterns — multiple friction points about the same issue, or high-severity items\n3. Propose an intent based on the strongest evidence cluster\n4. Use create_intent to create the intent\n5. Use link_evidence to link the relevant evidence items to the new intent`,
-                },
-            }],
-    };
-});
-// ============================================================
-// Intent Compiler — Zero-config tools (no API key needed)
-// ============================================================
-const intentSpecSchema = {
-    title: zod_1.z.string().describe('Short name for the intent'),
-    objective: zod_1.z.string().describe('Why this matters — the problem and who has it'),
-    outcomes: zod_1.z.array(zod_1.z.string()).describe('Observable, testable state changes'),
-    constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Hard limits the implementation must respect'),
-    edgeCases: zod_1.z.array(zod_1.z.object({
-        scenario: zod_1.z.string(),
-        expectedBehavior: zod_1.z.string(),
-    })).optional().describe('Failure modes and boundary conditions'),
-    healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('What to monitor after shipping'),
-    verification: zod_1.z.object({
-        manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
-        unitTests: zod_1.z.array(zod_1.z.string()).optional(),
-        e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
-    }).optional().describe('How to confirm it works'),
-};
-server.prompt('compile-intent', 'Start a Socratic conversation to build a structured intent spec from user feedback or a problem description. No Pathmode account needed.', {}, async () => {
-    return {
-        messages: [{
-                role: 'user',
-                content: {
+                    text: `Intent ${intentId} updated. Fields changed: ${changedFields.join(', ')}`
+                }]
+        };
+    });
+    server.registerTool('query_evidence', {
+        title: 'Query Evidence',
+        description: 'Search evidence items (friction points, user quotes, observations, metrics, feature requests) by product, type, severity, or text. Returns matching evidence with IDs that can be linked to intents.',
+        inputSchema: {
+            productId: zod_1.z.string().optional().describe('Filter by product (Space) ID'),
+            type: zod_1.z.enum(['friction', 'quote', 'observation', 'metric', 'request']).optional().describe('Filter by evidence type'),
+            severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Filter by severity'),
+            search: zod_1.z.string().optional().describe('Text search across evidence content'),
+            tags: zod_1.z.string().optional().describe('Comma-separated tags to filter by'),
+            limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
+        },
+        annotations: READ_ONLY,
+    }, async (filters) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Evidence queries require cloud mode.' }] };
+        }
+        const result = await client.queryEvidence(filters);
+        return {
+            content: [{
                     type: 'text',
-                    text: (0, intent_compiler_1.getCompileIntentPrompt)(),
-                },
-            }],
-    };
-});
-server.tool('intent_save', 'Save an intent spec to intent.md in the project root. Called after building a spec through conversation.', {
-    spec: zod_1.z.object(intentSpecSchema),
-    path: zod_1.z.string().optional().describe('File path relative to cwd. Defaults to intent.md'),
-}, async ({ spec, path }) => {
-    const filePath = (0, path_1.resolve)(process.cwd(), path || 'intent.md');
-    const content = (0, intent_compiler_1.formatIntentMd)({ ...spec, id: `intent_${Date.now()}` });
-    (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
-    return {
-        content: [{
-                type: 'text',
-                text: `✓ Saved intent spec to ${filePath}\n\nTo connect this to Pathmode for dependency tracking and team collaboration, visit pathmode.io`,
-            }],
-    };
-});
-server.tool('intent_export', 'Export an intent spec as .cursorrules or CLAUDE.md section for AI agent consumption.', {
-    format: zod_1.z.enum(['cursorrules', 'claude-md']).describe('Export format'),
-    spec: zod_1.z.object(intentSpecSchema),
-    path: zod_1.z.string().optional().describe('Output file path. Defaults to .cursorrules or CLAUDE.md'),
-}, async ({ format, spec, path }) => {
-    if (format === 'cursorrules') {
-        const content = (0, intent_compiler_1.formatCursorRules)(spec);
-        const filePath = (0, path_1.resolve)(process.cwd(), path || '.cursorrules');
-        (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.registerTool('create_evidence', {
+        title: 'Create Evidence',
+        description: 'Create a new evidence item (e.g., a discovered bug, user feedback quote, behavioral observation, or feature request). Evidence can later be linked to intents to support prioritization.',
+        inputSchema: {
+            content: zod_1.z.string().describe('The evidence content — a finding, quote, or observation'),
+            type: zod_1.z.enum(['friction', 'quote', 'observation', 'metric', 'request']).describe('Type of evidence'),
+            productId: zod_1.z.string().describe('Product (Space) ID this evidence belongs to'),
+            source: zod_1.z.string().optional().describe('Where this evidence came from (e.g., "User interview", "Bug report", "Support ticket")'),
+            sourceUrl: zod_1.z.string().optional().describe('URL to the original source'),
+            severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Severity level (required for friction type)'),
+            sentiment: zod_1.z.enum(['positive', 'negative', 'neutral', 'mixed']).optional().describe('Emotional sentiment'),
+            tags: zod_1.z.array(zod_1.z.string()).optional().describe('Category tags (e.g., ["Onboarding", "Performance"])'),
+            stage: zod_1.z.string().optional().describe('User journey stage (e.g., "Discovery", "Checkout")'),
+        },
+        annotations: WRITE_OP,
+    }, async ({ productId, ...rest }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Creating evidence requires cloud mode.' }] };
+        }
+        const result = await client.createEvidence({ productId, ...rest });
         return {
             content: [{
                     type: 'text',
-                    text: `✓ Exported .cursorrules to ${filePath}\n\nCursor and other AI agents will now see this intent as their implementation context.`,
-                }],
+                    text: `Evidence created: ${result.id}\nType: ${result.type}\nContent: "${(result.content || '').slice(0, 80)}${(result.content || '').length > 80 ? '...' : ''}"`
+                }]
         };
-    }
-    else {
-        const section = (0, intent_compiler_1.formatClaudeMdSection)(spec);
-        const filePath = (0, path_1.resolve)(process.cwd(), path || 'CLAUDE.md');
-        // Append or replace PATHMODE section in existing file
-        let existing = '';
-        try {
-            existing = (0, fs_1.readFileSync)(filePath, 'utf-8');
-        }
-        catch { /* file doesn't exist yet */ }
-        const marker = /<!-- PATHMODE:START -->[\s\S]*?<!-- PATHMODE:END -->/;
-        const updated = marker.test(existing)
-            ? existing.replace(marker, section)
-            : existing ? existing + '\n\n' + section : section;
-        (0, fs_1.writeFileSync)(filePath, updated, 'utf-8');
+    });
+    server.registerTool('link_evidence', {
+        title: 'Link Evidence to Intent',
+        description: 'Link or unlink evidence items to/from an intent. Linking evidence to intents establishes traceability between user problems and planned solutions.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to link evidence to'),
+            link: zod_1.z.array(zod_1.z.string()).optional().describe('Evidence IDs to link to this intent'),
+            unlink: zod_1.z.array(zod_1.z.string()).optional().describe('Evidence IDs to unlink from this intent'),
+        },
+        annotations: WRITE_OP,
+    }, async ({ intentId, link, unlink }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Evidence linking requires cloud mode.' }] };
+        }
+        const result = await client.linkEvidence(intentId, { link, unlink });
+        const actions = [];
+        if (link && link.length > 0)
+            actions.push(`linked ${result.linked} evidence items`);
+        if (unlink && unlink.length > 0)
+            actions.push(`unlinked ${result.unlinked} evidence items`);
         return {
             content: [{
                     type: 'text',
-                    text: `✓ Exported CLAUDE.md section to ${filePath}\n\nClaude Code will now see this intent as context in every conversation.`,
+                    text: `Intent ${intentId}: ${actions.join(', ')}. Total evidence linked: ${result.evidenceIds.length}`
+                }]
+        };
+    });
+    server.registerTool('verify_implementation', {
+        title: 'Verify Implementation',
+        description: 'AI-grade your implementation against the intent spec. Checks each outcome, constraint, constitution rule, and edge case. Returns pass/fail per item with reasoning and an overall score. Also logs the result as an implementation note.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent ID to verify against'),
+            summary: zod_1.z.string().describe('Description of what was implemented and how'),
+            codeChanges: zod_1.z.string().optional().describe('Summary of code changes (file list, key modifications)'),
+        },
+        annotations: WRITE_OP,
+    }, async ({ intentId, summary, codeChanges }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Verification requires cloud mode.' }] };
+        }
+        try {
+            const result = await client.verifyImplementation(intentId, summary, codeChanges);
+            let text = `Verification ${result.pass ? 'PASSED' : 'FAILED'} (score: ${result.score}/100)\n\n`;
+            text += `${result.summary}\n\n`;
+            for (const r of result.results) {
+                const icon = r.status === 'pass' ? '[PASS]' : r.status === 'fail' ? '[FAIL]' : '[????]';
+                text += `${icon} [${r.category}] ${r.item}\n    ${r.reasoning}\n`;
+            }
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Verification failed: ${e.message}` }] };
+        }
+    });
+    // ============================================================
+    // Prompts
+    // ============================================================
+    server.prompt('implement-intent', 'Get full implementation context for a specific intent, including objective, outcomes, constraints, edge cases, and verification steps.', {
+        intentId: zod_1.z.string().describe('The intent ID to implement'),
+    }, async ({ intentId }) => {
+        return {
+            messages: [{
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `I need to implement intent ${intentId}. Please:\n1. Use the get_agent_prompt tool to fetch the full execution prompt for this intent\n2. Use get_constitution to check for workspace constraints I must respect\n3. Review the intent details and create an implementation plan\n4. After implementation, use verify_implementation to AI-grade your work against the spec\n5. If verification passes, use update_intent_status to mark it as "shipped"\n6. Use log_implementation_note to document key technical decisions`,
+                    },
                 }],
         };
-    }
-});
-// ============================================================
-// Resources
-// ============================================================
-server.resource('intent://current', 'intent://current', async (uri) => {
-    if (isLocalMode) {
-        const intents = (0, local_reader_1.readLocalIntents)();
+    });
+    server.prompt('review-risks', 'Analyze the intent graph for architectural risks, circular dependencies, bottlenecks, and stalled work.', {}, async () => {
         return {
-            contents: [{
-                    uri: uri.href,
-                    mimeType: 'application/json',
-                    text: JSON.stringify(intents[0] || null, null, 2),
-                }]
+            messages: [{
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'Please analyze our intent graph for risks:\n1. Use analyze_intent_graph with analysis "full" to get the complete graph analysis\n2. Summarize the critical path and explain why it matters\n3. Flag any cycles (circular dependencies) as urgent issues\n4. Identify bottlenecks \u2014 intents that block many others, especially if still in draft\n5. Suggest concrete actions to reduce risk',
+                    },
+                }],
         };
-    }
-    const intents = await client.listIntents('approved');
-    const current = intents[0] || (await client.listIntents())[0] || null;
-    return {
-        contents: [{
-                uri: uri.href,
-                mimeType: 'application/json',
-                text: JSON.stringify(current, null, 2),
-            }]
-    };
-});
-server.resource('intent://graph', 'intent://graph', async (uri) => {
-    if (isLocalMode) {
+    });
+    server.prompt('what-next', 'Suggest the highest-priority intent to work on next, based on dependency graph analysis and current status.', {}, async () => {
         return {
-            contents: [{
-                    uri: uri.href,
-                    mimeType: 'application/json',
-                    text: JSON.stringify({ error: 'Graph not available in local mode' }),
-                }]
+            messages: [{
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'Help me decide what to work on next:\n1. Use analyze_intent_graph with analysis "critical-path" to find the critical path\n2. Use list_intents with status "approved" to see what\'s ready for implementation\n3. Consider: which approved intents are on the critical path? Which unblock the most other work?\n4. Recommend the single highest-impact intent to implement next, and explain why',
+                    },
+                }],
         };
-    }
-    const intents = await client.listIntents();
-    const graph = intents.map(i => ({
-        id: i.id,
-        title: i.title,
-        status: i.status,
-        relations: i.relations,
-    }));
-    return {
-        contents: [{
-                uri: uri.href,
-                mimeType: 'application/json',
-                text: JSON.stringify(graph, null, 2),
-            }]
+    });
+    server.prompt('create-from-evidence', 'Search for evidence items, identify patterns, and create an intent based on the strongest evidence cluster.', {
+        productId: zod_1.z.string().describe('The product ID to search evidence for'),
+    }, async ({ productId }) => {
+        return {
+            messages: [{
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `Help me create a new intent from evidence:\n1. Use query_evidence with productId "${productId}" to see what evidence exists\n2. Look for patterns — multiple friction points about the same issue, or high-severity items\n3. Propose an intent based on the strongest evidence cluster\n4. Use create_intent to create the intent\n5. Use link_evidence to link the relevant evidence items to the new intent`,
+                    },
+                }],
+        };
+    });
+    // ============================================================
+    // Intent Compiler — Zero-config tools (no API key needed)
+    // ============================================================
+    const intentSpecSchema = {
+        title: zod_1.z.string().describe('Short name for the intent'),
+        objective: zod_1.z.string().describe('Why this matters — the problem and who has it'),
+        outcomes: zod_1.z.array(zod_1.z.string()).describe('Observable, testable state changes'),
+        constraints: zod_1.z.array(zod_1.z.string()).optional().describe('Hard limits the implementation must respect'),
+        edgeCases: zod_1.z.array(zod_1.z.object({
+            scenario: zod_1.z.string(),
+            expectedBehavior: zod_1.z.string(),
+        })).optional().describe('Failure modes and boundary conditions'),
+        healthMetrics: zod_1.z.array(zod_1.z.string()).optional().describe('What to monitor after shipping'),
+        verification: zod_1.z.object({
+            manualChecks: zod_1.z.array(zod_1.z.string()).optional(),
+            unitTests: zod_1.z.array(zod_1.z.string()).optional(),
+            e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
+        }).optional().describe('How to confirm it works'),
     };
-});
-server.resource('intent://workspace-strategy', 'intent://workspace-strategy', async (uri) => {
-    if (isLocalMode) {
+    server.prompt('compile-intent', 'Start a Socratic conversation to build a structured intent spec from user feedback or a problem description. No Pathmode account needed.', {}, async () => {
         return {
-            contents: [{
-                    uri: uri.href,
-                    mimeType: 'application/json',
-                    text: JSON.stringify({ error: 'Workspace strategy not available in local mode' }),
-                }]
+            messages: [{
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: (0, intent_compiler_1.getCompileIntentPrompt)(),
+                    },
+                }],
         };
-    }
-    try {
-        const workspace = await client.getWorkspace();
+    });
+    server.tool('intent_save', 'Save an intent spec to intent.md in the project root. Called after building a spec through conversation.', {
+        spec: zod_1.z.object(intentSpecSchema),
+        path: zod_1.z.string().optional().describe('File path relative to cwd. Defaults to intent.md'),
+    }, async ({ spec, path }) => {
+        const filePath = (0, path_1.resolve)(process.cwd(), path || 'intent.md');
+        const content = (0, intent_compiler_1.formatIntentMd)({ ...spec, id: `intent_${Date.now()}` });
+        (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✓ Saved intent spec to ${filePath}\n\nTo connect this to Pathmode for dependency tracking and team collaboration, visit pathmode.io`,
+                }],
+        };
+    });
+    server.tool('intent_export', 'Export an intent spec as .cursorrules or CLAUDE.md section for AI agent consumption.', {
+        format: zod_1.z.enum(['cursorrules', 'claude-md']).describe('Export format'),
+        spec: zod_1.z.object(intentSpecSchema),
+        path: zod_1.z.string().optional().describe('Output file path. Defaults to .cursorrules or CLAUDE.md'),
+    }, async ({ format, spec, path }) => {
+        if (format === 'cursorrules') {
+            const content = (0, intent_compiler_1.formatCursorRules)(spec);
+            const filePath = (0, path_1.resolve)(process.cwd(), path || '.cursorrules');
+            (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✓ Exported .cursorrules to ${filePath}\n\nCursor and other AI agents will now see this intent as their implementation context.`,
+                    }],
+            };
+        }
+        else {
+            const section = (0, intent_compiler_1.formatClaudeMdSection)(spec);
+            const filePath = (0, path_1.resolve)(process.cwd(), path || 'CLAUDE.md');
+            // Append or replace PATHMODE section in existing file
+            let existing = '';
+            try {
+                existing = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            }
+            catch { /* file doesn't exist yet */ }
+            const marker = /<!-- PATHMODE:START -->[\s\S]*?<!-- PATHMODE:END -->/;
+            const updated = marker.test(existing)
+                ? existing.replace(marker, section)
+                : existing ? existing + '\n\n' + section : section;
+            (0, fs_1.writeFileSync)(filePath, updated, 'utf-8');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✓ Exported CLAUDE.md section to ${filePath}\n\nClaude Code will now see this intent as context in every conversation.`,
+                    }],
+            };
+        }
+    });
+    // ============================================================
+    // Resources
+    // ============================================================
+    server.resource('intent://current', 'intent://current', async (uri) => {
+        if (isLocalMode) {
+            const intents = (0, local_reader_1.readLocalIntents)();
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(intents[0] || null, null, 2),
+                    }]
+            };
+        }
+        const intents = await client.listIntents('approved');
+        const current = intents[0] || (await client.listIntents())[0] || null;
         return {
             contents: [{
                     uri: uri.href,
                     mimeType: 'application/json',
-                    text: JSON.stringify({
-                        name: workspace.name,
-                        strategy: workspace.strategy,
-                        constitutionRules: workspace.constitutionRules?.filter(r => r.isActive),
-                    }, null, 2),
+                    text: JSON.stringify(current, null, 2),
                 }]
         };
-    }
-    catch {
+    });
+    server.resource('intent://graph', 'intent://graph', async (uri) => {
+        if (isLocalMode) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: 'Graph not available in local mode' }),
+                    }]
+            };
+        }
+        const intents = await client.listIntents();
+        const graph = intents.map(i => ({
+            id: i.id,
+            title: i.title,
+            status: i.status,
+            relations: i.relations,
+        }));
         return {
             contents: [{
                     uri: uri.href,
                     mimeType: 'application/json',
-                    text: JSON.stringify({ error: 'Failed to fetch workspace strategy' }),
+                    text: JSON.stringify(graph, null, 2),
                 }]
         };
+    });
+    server.resource('intent://workspace-strategy', 'intent://workspace-strategy', async (uri) => {
+        if (isLocalMode) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: 'Workspace strategy not available in local mode' }),
+                    }]
+            };
+        }
+        try {
+            const workspace = await client.getWorkspace();
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            name: workspace.name,
+                            strategy: workspace.strategy,
+                            constitutionRules: workspace.constitutionRules?.filter(r => r.isActive),
+                        }, null, 2),
+                    }]
+            };
+        }
+        catch {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: 'Failed to fetch workspace strategy' }),
+                    }]
+            };
+        }
+    });
+    // ============================================================
+    // Start
+    // ============================================================
+    async function main() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
     }
-});
-// ============================================================
-// Start
-// ============================================================
-async function main() {
-    const transport = new stdio_js_1.StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch((error) => {
-    console.error('Failed to start Pathmode MCP server:', error);
-    process.exit(1);
-});
+    main().catch((error) => {
+        console.error('Failed to start Pathmode MCP server:', error);
+        process.exit(1);
+    });
+} // end startMcpServer()
 
 })();