@pathmode/mcp-server 1.4.4 → 1.5.0

package/dist/index.js

@@ -25565,7 +25565,7 @@ class Ajv {
     constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
-        this.formats = {};
+        this.formats = Object.create(null);
         this._compilations = new Set();
         this._loading = {};
         this._cache = new Map();
@@ -28017,6 +28017,7 @@ exports["default"] = def;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const code_1 = __nccwpck_require__(8484);
+const util_1 = __nccwpck_require__(4464);
 const codegen_1 = __nccwpck_require__(1436);
 const error = {
     message: ({ schemaCode }) => (0, codegen_1.str) `must match pattern "${schemaCode}"`,
@@ -28029,11 +28030,19 @@ const def = {
     $data: true,
     error,
     code(cxt) {
-        const { data, $data, schema, schemaCode, it } = cxt;
-        // TODO regexp should be wrapped in try/catchs
+        const { gen, data, $data, schema, schemaCode, it } = cxt;
         const u = it.opts.unicodeRegExp ? "u" : "";
-        const regExp = $data ? (0, codegen_1._) `(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-        cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        if ($data) {
+            const { regExp } = it.opts.code;
+            const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._) `new RegExp` : (0, util_1.useFunc)(gen, regExp);
+            const valid = gen.let("valid");
+            gen.try(() => gen.assign(valid, (0, codegen_1._) `${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+            cxt.fail$data((0, codegen_1._) `!${valid}`);
+        }
+        else {
+            const regExp = (0, code_1.usePattern)(cxt, schema);
+            cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        }
     },
 };
 exports["default"] = def;
@@ -33531,6 +33540,7 @@ exports.loadConfig = loadConfig;
 const fs_1 = __importDefault(__nccwpck_require__(9896));
 const path_1 = __importDefault(__nccwpck_require__(6928));
 const os_1 = __importDefault(__nccwpck_require__(857));
+const isDebug = process.env.PATHMODE_MCP_DEBUG === '1';
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.pathmode');
 const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
 function loadConfig() {
@@ -33563,7 +33573,8 @@ class PathmodeClient {
     }
     async fetch(path, options = {}) {
         const url = `${this.apiUrl}/api/v1${path}`;
-        console.error(`[pathmode-mcp] fetch: ${url}, key prefix: ${this.apiKey.substring(0, 16)}`);
+        if (isDebug)
+            console.error(`[pathmode-mcp] fetch: ${url}`);
         const response = await fetch(url, {
             ...options,
             headers: {
@@ -33574,7 +33585,7 @@ class PathmodeClient {
         });
         if (!response.ok) {
             const body = await response.json().catch(() => ({ error: response.statusText }));
-            console.error(`[pathmode-mcp] ${response.status}: ${JSON.stringify(body)}, key length: ${this.apiKey.length}`);
+            console.error(`[pathmode-mcp] API error ${response.status}: ${body.error || response.statusText}`);
             throw new Error(`API error (${response.status}): ${body.error || response.statusText}`);
         }
         return response;
@@ -33678,6 +33689,198 @@ class PathmodeClient {
 exports.PathmodeClient = PathmodeClient;
 
 
+/***/ }),
+
+/***/ 3783:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * Pathmode MCP Install Skills Command
+ *
+ * Copies the bundled Claude Code skill pack into .claude/skills/
+ * (project-local, default) or ~/.claude/skills/ (global, with --global).
+ *
+ * Usage:
+ *   npx @pathmode/mcp-server install-skills
+ *   npx @pathmode/mcp-server install-skills --global
+ *   npx @pathmode/mcp-server install-skills --force
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isInstallSkillsCommand = isInstallSkillsCommand;
+exports.runInstallSkills = runInstallSkills;
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+const os_1 = __importDefault(__nccwpck_require__(857));
+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 isInstallSkillsCommand(argv = process.argv) {
+    return argv.includes('install-skills');
+}
+function getInstallSkillsArgs(argv = process.argv) {
+    const idx = argv.findIndex(a => a === 'install-skills');
+    return idx === -1 ? [] : argv.slice(idx + 1);
+}
+function shortenPath(p) {
+    const home = os_1.default.homedir();
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+/**
+ * Locate the bundled skills/ directory.
+ *
+ * When installed via npm, this file is at <pkg>/dist/install-skills.js
+ * and skills/ sits at <pkg>/skills/. When running from source (ts-node),
+ * this file is at <pkg>/src/install-skills.ts and skills/ is at <pkg>/skills/.
+ *
+ * Either way, going up one level from __dirname and joining "skills" finds it.
+ */
+function findSkillsDir() {
+    const candidates = [
+        path_1.default.resolve(__dirname, '..', 'skills'), // npm install layout (dist/ -> ../skills)
+        path_1.default.resolve(__dirname, '..', '..', 'skills'), // edge case if bundled deeper
+    ];
+    for (const c of candidates) {
+        if (!fs_1.default.existsSync(c) || !fs_1.default.statSync(c).isDirectory())
+            continue;
+        // Sanity check: directory must contain at least one <name>/SKILL.md
+        const entries = fs_1.default.readdirSync(c);
+        const hasSkill = entries.some(e => fs_1.default.existsSync(path_1.default.join(c, e, 'SKILL.md')));
+        if (hasSkill)
+            return c;
+    }
+    return null;
+}
+function copyRecursive(src, dest) {
+    if (!fs_1.default.existsSync(dest)) {
+        fs_1.default.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs_1.default.readdirSync(src, { withFileTypes: true });
+    for (const e of entries) {
+        const srcPath = path_1.default.join(src, e.name);
+        const destPath = path_1.default.join(dest, e.name);
+        if (e.isDirectory()) {
+            copyRecursive(srcPath, destPath);
+        }
+        else {
+            fs_1.default.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+async function runInstallSkills() {
+    const args = getInstallSkillsArgs();
+    const isGlobal = args.includes('--global');
+    const isForce = args.includes('--force');
+    const wantsHelp = args.includes('--help') || args.includes('-h');
+    log('');
+    log(`${BOLD}Pathmode Skills Install${RESET}`);
+    log(`${DIM}──────────────────────${RESET}`);
+    log('');
+    if (wantsHelp) {
+        log(`Usage: ${CYAN}npx @pathmode/mcp-server install-skills${RESET} [options]`);
+        log('');
+        log('Options:');
+        log(`  ${BOLD}--global${RESET}   Install into ~/.claude/skills/ instead of ./.claude/skills/`);
+        log(`  ${BOLD}--force${RESET}    Overwrite existing skill directories`);
+        log(`  ${BOLD}--help${RESET}     Show this message`);
+        log('');
+        log('Copies the bundled Claude Code skill pack into your skills directory.');
+        log('Skills auto-trigger when your natural-language request matches their description —');
+        log('no slash commands needed.');
+        log('');
+        return;
+    }
+    const skillsDir = findSkillsDir();
+    if (!skillsDir) {
+        fail('Could not locate the bundled skills/ directory.');
+        log(`  Expected to find it at <package-root>/skills/ relative to ${shortenPath(__dirname)}.`);
+        log(`  If you cloned this repo and are running from source, ensure ${BOLD}skills/${RESET} exists at the package root.`);
+        log('');
+        process.exit(1);
+    }
+    const targetDir = isGlobal
+        ? path_1.default.join(os_1.default.homedir(), '.claude', 'skills')
+        : path_1.default.join(process.cwd(), '.claude', 'skills');
+    log(`  Source: ${DIM}${shortenPath(skillsDir)}${RESET}`);
+    log(`  Target: ${DIM}${shortenPath(targetDir)}${RESET}`);
+    log('');
+    if (!fs_1.default.existsSync(targetDir)) {
+        try {
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+        }
+        catch (err) {
+            fail(`Could not create target directory: ${err.message}`);
+            log('');
+            process.exit(1);
+        }
+    }
+    const entries = fs_1.default.readdirSync(skillsDir, { withFileTypes: true });
+    let installed = 0;
+    let skipped = 0;
+    let overwritten = 0;
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        // Only copy directories that contain a SKILL.md
+        const skillFile = path_1.default.join(skillsDir, e.name, 'SKILL.md');
+        if (!fs_1.default.existsSync(skillFile))
+            continue;
+        const destPath = path_1.default.join(targetDir, e.name);
+        const existsAlready = fs_1.default.existsSync(destPath);
+        if (existsAlready && !isForce) {
+            warn(`${e.name} ${DIM}(already installed — pass --force to overwrite)${RESET}`);
+            skipped++;
+            continue;
+        }
+        try {
+            if (existsAlready && isForce) {
+                fs_1.default.rmSync(destPath, { recursive: true, force: true });
+            }
+            copyRecursive(path_1.default.join(skillsDir, e.name), destPath);
+            success(e.name);
+            if (existsAlready)
+                overwritten++;
+            else
+                installed++;
+        }
+        catch (err) {
+            fail(`${e.name} — ${err.message}`);
+        }
+    }
+    log('');
+    const lines = [];
+    if (installed > 0)
+        lines.push(`${BOLD}${installed}${RESET} installed`);
+    if (overwritten > 0)
+        lines.push(`${BOLD}${overwritten}${RESET} updated`);
+    if (skipped > 0)
+        lines.push(`${BOLD}${skipped}${RESET} skipped`);
+    log(`  ${lines.join('  ·  ') || 'No skills processed.'}`);
+    log('');
+    if (installed + overwritten > 0) {
+        log(`  ${BOLD}Next:${RESET} Restart Claude Code so the new skills register at session start.`);
+        log(`        Then try: ${CYAN}"help me write a spec for [your problem]"${RESET}`);
+        log('');
+    }
+    else if (skipped > 0) {
+        log(`  All skills already installed. Run with ${BOLD}--force${RESET} to overwrite.`);
+        log('');
+    }
+}
+
+
 /***/ }),
 
 /***/ 6488:
@@ -33810,6 +34013,7 @@ IMPORTANT:
   - constraints: string[] (optional)
   - edgeCases: { scenario: string, expectedBehavior: string }[] (optional)
   - healthMetrics: string[] (optional)
+  - scope: { inScope?: string[], outOfScope?: string[] } (optional)
   - verification: { manualChecks?: string[], unitTests?: string[], e2eTests?: string[] } (optional)
 
 Now, start the conversation. If they haven't provided one yet, ask for the concrete evidence (quote, metric, or ticket) driving this work.`;
@@ -34111,6 +34315,14 @@ function readIntentFile(filePath) {
         const constraints = extractListSection(body, 'Constraints');
         const healthMetrics = extractListSection(body, 'Health Metrics');
         const edgeCases = extractEdgeCases(body);
+        const scope = extractScope(body);
+        const parsedVerification = extractVerification(body);
+        const frontmatterVerification = data.verification && typeof data.verification === 'object'
+            ? data.verification
+            : null;
+        const verification = Object.keys(parsedVerification).length > 0
+            ? parsedVerification
+            : (frontmatterVerification || {});
         return {
             id: data.id || path_1.default.basename(filePath, '.md'),
             status: data.status || 'draft',
@@ -34123,7 +34335,8 @@ function readIntentFile(filePath) {
             constraints,
             edgeCases,
             healthMetrics,
-            verification: data.verification || {},
+            scope: scope || undefined,
+            verification,
             source: 'local',
         };
     }
@@ -34177,6 +34390,72 @@ function extractEdgeCases(body) {
     }
     return cases;
 }
+/**
+ * Extract Scope section with **In scope:** and **Out of scope:** sub-lists.
+ * Matches the format emitted by formatIntentMd().
+ */
+function extractScope(body) {
+    const section = extractSection(body, 'Scope');
+    if (!section)
+        return null;
+    const inScope = [];
+    const outOfScope = [];
+    let target = null;
+    for (const line of section.split('\n')) {
+        if (/^\*\*In scope[:\*]*/.test(line.trim())) {
+            target = inScope;
+            continue;
+        }
+        if (/^\*\*Out of scope[:\*]*/.test(line.trim())) {
+            target = outOfScope;
+            continue;
+        }
+        if (target && line.match(/^[-*]\s/)) {
+            target.push(line.replace(/^[-*]\s+/, '').trim());
+        }
+    }
+    if (inScope.length === 0 && outOfScope.length === 0)
+        return null;
+    const result = {};
+    if (inScope.length > 0)
+        result.inScope = inScope;
+    if (outOfScope.length > 0)
+        result.outOfScope = outOfScope;
+    return result;
+}
+/**
+ * Extract Verification section with **E2E Tests**, **Unit Tests**, **Manual Checks** sub-lists.
+ * Matches the format emitted by formatIntentMd().
+ */
+function extractVerification(body) {
+    const section = extractSection(body, 'Verification');
+    if (!section)
+        return {};
+    const result = {};
+    let currentKey = null;
+    for (const line of section.split('\n')) {
+        const trimmed = line.trim();
+        if (/^\*\*E2E Tests?\*?\*?:?/.test(trimmed)) {
+            currentKey = 'e2eTests';
+            result[currentKey] = [];
+            continue;
+        }
+        if (/^\*\*Unit Tests?\*?\*?:?/.test(trimmed)) {
+            currentKey = 'unitTests';
+            result[currentKey] = [];
+            continue;
+        }
+        if (/^\*\*Manual Checks?\*?\*?:?/.test(trimmed)) {
+            currentKey = 'manualChecks';
+            result[currentKey] = [];
+            continue;
+        }
+        if (currentKey && trimmed.match(/^[-*]\s/)) {
+            result[currentKey].push(trimmed.replace(/^[-*]\s+(\[.\]\s+)?/, '').trim());
+        }
+    }
+    return result;
+}
 
 
 /***/ }),
@@ -64047,9 +64326,11 @@ 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 setup pm_live_xxx   # Auto-configure your tools
+ *   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
+ *   npx @pathmode/mcp-server install-skills         # Copy the skill pack into .claude/skills/
+ *   npx @pathmode/mcp-server install-skills --global  # Install into ~/.claude/skills/ instead
  *
  * The Intent Compiler (compile-intent prompt, intent_save, intent_export tools)
  * works without an API key — zero-config intent spec building in Claude Code.
@@ -64088,16 +64369,23 @@ const api_client_1 = __nccwpck_require__(7475);
 const local_reader_1 = __nccwpck_require__(3518);
 const intent_compiler_1 = __nccwpck_require__(6488);
 const setup_1 = __nccwpck_require__(8294);
+const install_skills_1 = __nccwpck_require__(3783);
 // ─── 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.
+// Human-readable subcommands (`setup`, `install-skills`) use stdout
+// and must run before StdioServerTransport claims stdout for JSON-RPC.
+// We call startMcpServer() only when NOT in a subcommand.
 if ((0, setup_1.isSetupCommand)()) {
     (0, setup_1.runSetup)().then(() => process.exit(0)).catch((err) => {
         console.error(err);
         process.exit(1);
     });
 }
+else if ((0, install_skills_1.isInstallSkillsCommand)()) {
+    (0, install_skills_1.runInstallSkills)().then(() => process.exit(0)).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
 else {
     startMcpServer();
 }
@@ -64105,9 +64393,12 @@ function startMcpServer() {
     // ─── MCP Server ───────────────────────────────────────────────
     const isLocalMode = process.argv.includes('--local');
     let client = null;
+    const isDebug = process.env.PATHMODE_MCP_DEBUG === '1';
     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 (isDebug) {
+            console.error(`[pathmode-mcp] API key present: ${!!config?.apiKey}, url: ${config?.apiUrl || 'none'}`);
+        }
         if (config) {
             client = new api_client_1.PathmodeClient(config);
         }
@@ -64118,38 +64409,74 @@ function startMcpServer() {
     // ============================================================
     const server = new mcp_js_1.McpServer({
         name: 'pathmode',
-        version: '1.3.0',
+        version: '1.4.5',
     });
     // Annotation presets
     const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
     const WRITE_OP = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
+    // Cloud-mode guard — returns a clean error instead of crashing on client!
+    const CLOUD_REQUIRED_MSG = 'This tool requires a Pathmode API key. Run `npx @pathmode/mcp-server setup pm_live_xxx` to connect, or set the PATHMODE_API_KEY environment variable.';
+    function requireCloudClient() {
+        if (!client)
+            throw new CloudClientError();
+        return client;
+    }
+    class CloudClientError extends Error {
+        constructor() { super(CLOUD_REQUIRED_MSG); this.name = 'CloudClientError'; }
+    }
+    function normalizeText(value) {
+        return (value || '').trim();
+    }
+    // Keep this selection heuristic aligned with the canonical readiness rules in
+    // /Users/jannelammi/code/Pathmode/lib/intentReadiness.ts. The MCP package cannot
+    // import app/lib code directly, so this mirrors only the minimum logic needed
+    // for get_current_intent fallback behavior.
+    function isPlaceholderIntent(intent) {
+        const title = normalizeText(intent.title).toLowerCase();
+        const objective = normalizeText(intent.objective);
+        const outcomeCount = (intent.outcomes || []).filter((outcome) => normalizeText(typeof outcome === 'string' ? outcome : outcome?.text).length > 0).length;
+        return title === 'new intent' || title === 'untitled intent' || objective.length < 15 || outcomeCount === 0;
+    }
+    function pickCurrentIntent(intents) {
+        const approvedReady = intents.find((intent) => intent.status === 'approved' && !isPlaceholderIntent(intent));
+        if (approvedReady)
+            return approvedReady;
+        const anyReady = intents.find((intent) => !isPlaceholderIntent(intent));
+        if (anyReady)
+            return anyReady;
+        return intents[0];
+    }
+    // Note: The MCP SDK catches errors thrown in tool handlers and returns them as
+    // error text results. CloudClientError thrown by requireCloudClient() will
+    // surface its message to the client without crashing the server.
     // ============================================================
     // 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.',
+        description: 'Get the currently active intent, preferring approved intents with real objective/outcome content over empty stubs. 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];
+            const current = pickCurrentIntent(filtered);
             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');
+        const cloud = requireCloudClient();
+        const intents = await cloud.listIntents(status || 'approved');
         if (intents.length === 0) {
-            const allIntents = await client.listIntents();
+            const allIntents = await cloud.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(pickCurrentIntent(allIntents), null, 2) }] };
         }
-        return { content: [{ type: 'text', text: JSON.stringify(intents[0], null, 2) }] };
+        return { content: [{ type: 'text', text: JSON.stringify(pickCurrentIntent(intents), null, 2) }] };
     });
     server.registerTool('list_intents', {
         title: 'List Intents',
@@ -64167,7 +64494,8 @@ function startMcpServer() {
                     }]
             };
         }
-        const intents = await client.listIntents(status);
+        const cloud = requireCloudClient();
+        const intents = await cloud.listIntents(status);
         return {
             content: [{
                     type: 'text',
@@ -64190,7 +64518,7 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
         }
         try {
-            const intent = await client.getIntent(intentId);
+            const intent = await requireCloudClient().getIntent(intentId);
             return { content: [{ type: 'text', text: JSON.stringify(intent, null, 2) }] };
         }
         catch (e) {
@@ -64206,7 +64534,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Relations are not available in local mode.' }] };
         }
-        const intent = await client.getIntent(intentId);
+        const intent = await requireCloudClient().getIntent(intentId);
         return {
             content: [{
                     type: 'text',
@@ -64237,7 +64565,7 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: JSON.stringify({ results: matches, count: matches.length, query }, null, 2) }] };
         }
         try {
-            const intents = await client.listIntents(status);
+            const intents = await requireCloudClient().listIntents(status);
             const q = query.toLowerCase();
             const matches = intents.filter(i => {
                 const text = [i.title, i.objective, ...(i.outcomes || []).map((o) => typeof o === 'string' ? o : o.text), ...(i.constraints || [])].join(' ').toLowerCase();
@@ -64269,7 +64597,7 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: 'Graph analysis requires cloud mode.' }] };
         }
         try {
-            const intents = await client.listIntents();
+            const intents = await requireCloudClient().listIntents();
             if (intents.length === 0) {
                 return { content: [{ type: 'text', text: 'No intents found in workspace.' }] };
             }
@@ -64297,7 +64625,7 @@ function startMcpServer() {
                     }
                 }
             }
-            // Detect cycles
+            // Detect cycles (iterative DFS with neighbor iterators)
             const WHITE = 0, GRAY = 1, BLACK = 2;
             const color = new Map();
             const parent = new Map();
@@ -64307,31 +64635,36 @@ function startMcpServer() {
             for (const startId of forward.keys()) {
                 if (color.get(startId) !== WHITE)
                     continue;
-                const stack = [startId];
+                // Each stack frame: [nodeId, iterator over its neighbors]
+                const stack = [];
+                color.set(startId, GRAY);
                 parent.set(startId, null);
+                stack.push([startId, (forward.get(startId) || new Set()).values()]);
                 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);
+                    const [id, iter] = stack[stack.length - 1];
+                    const next = iter.next();
+                    if (!next.done) {
+                        const dep = next.value;
+                        if (color.get(dep) === WHITE) {
+                            color.set(dep, GRAY);
+                            parent.set(dep, id);
+                            stack.push([dep, (forward.get(dep) || new Set()).values()]);
+                        }
+                        else if (color.get(dep) === GRAY) {
+                            // Back edge — extract cycle from parent chain
+                            const cycle = [dep];
+                            let cur = id;
+                            while (cur !== dep) {
+                                cycle.push(cur);
+                                cur = parent.get(cur);
                             }
+                            cycle.push(dep);
+                            cycle.reverse();
+                            cycles.push(cycle);
                         }
                     }
                     else {
+                        // All neighbors explored — mark finished
                         color.set(id, BLACK);
                         stack.pop();
                     }
@@ -64453,7 +64786,7 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: 'Export requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
         }
         try {
-            const content = await client.exportContext(format, intentId, productId);
+            const content = await requireCloudClient().exportContext(format, intentId, productId);
             return { content: [{ type: 'text', text: content }] };
         }
         catch (e) {
@@ -64472,7 +64805,7 @@ function startMcpServer() {
         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');
+        const result = await requireCloudClient().getIntentPrompt(intentId, 'claude-code', mode || 'execute');
         return {
             content: [{
                     type: 'text',
@@ -64488,7 +64821,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Workspace details are not available in local mode.' }] };
         }
-        const workspace = await client.getWorkspace();
+        const workspace = await requireCloudClient().getWorkspace();
         return {
             content: [{
                     type: 'text',
@@ -64504,7 +64837,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Constitution rules are not available in local mode.' }] };
         }
-        const result = await client.getConstitution();
+        const result = await requireCloudClient().getConstitution();
         return {
             content: [{
                     type: 'text',
@@ -64527,7 +64860,7 @@ function startMcpServer() {
         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);
+        const result = await requireCloudClient().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) {
@@ -64556,7 +64889,7 @@ function startMcpServer() {
         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');
+        const result = await requireCloudClient().logNote(intentId, note, 'mcp');
         return {
             content: [{
                     type: 'text',
@@ -64590,7 +64923,7 @@ function startMcpServer() {
         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 });
+        const result = await requireCloudClient().createIntent({ productId, ...rest });
         return {
             content: [{
                     type: 'text',
@@ -64624,7 +64957,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Updating intents requires cloud mode.' }] };
         }
-        const result = await client.updateIntent(intentId, updates);
+        const result = await requireCloudClient().updateIntent(intentId, updates);
         const changedFields = Object.keys(updates).filter(k => updates[k] !== undefined);
         return {
             content: [{
@@ -64649,7 +64982,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Evidence queries require cloud mode.' }] };
         }
-        const result = await client.queryEvidence(filters);
+        const result = await requireCloudClient().queryEvidence(filters);
         return {
             content: [{
                     type: 'text',
@@ -64669,14 +65002,14 @@ function startMcpServer() {
             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")'),
+            stage: zod_1.z.string().optional().describe('Workflow 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 });
+        const result = await requireCloudClient().createEvidence({ productId, ...rest });
         return {
             content: [{
                     type: 'text',
@@ -64697,7 +65030,7 @@ function startMcpServer() {
         if (isLocalMode) {
             return { content: [{ type: 'text', text: 'Evidence linking requires cloud mode.' }] };
         }
-        const result = await client.linkEvidence(intentId, { link, unlink });
+        const result = await requireCloudClient().linkEvidence(intentId, { link, unlink });
         const actions = [];
         if (link && link.length > 0)
             actions.push(`linked ${result.linked} evidence items`);
@@ -64724,7 +65057,7 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: 'Verification requires cloud mode.' }] };
         }
         try {
-            const result = await client.verifyImplementation(intentId, summary, codeChanges);
+            const result = await requireCloudClient().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) {
@@ -64801,6 +65134,10 @@ function startMcpServer() {
             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'),
+        scope: zod_1.z.object({
+            inScope: zod_1.z.array(zod_1.z.string()).optional().describe('What is in scope for this intent'),
+            outOfScope: zod_1.z.array(zod_1.z.string()).optional().describe('What is explicitly out of scope'),
+        }).optional().describe('Scope boundaries — what to build and what to avoid'),
         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(),
@@ -64884,15 +65221,27 @@ function startMcpServer() {
                     }]
             };
         }
-        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),
-                }]
-        };
+        try {
+            const cloud = requireCloudClient();
+            const intents = await cloud.listIntents('approved');
+            const current = intents[0] || (await cloud.listIntents())[0] || null;
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(current, null, 2),
+                    }]
+            };
+        }
+        catch {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: CLOUD_REQUIRED_MSG }),
+                    }]
+            };
+        }
     });
     server.resource('intent://graph', 'intent://graph', async (uri) => {
         if (isLocalMode) {
@@ -64904,20 +65253,31 @@ function startMcpServer() {
                     }]
             };
         }
-        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),
-                }]
-        };
+        try {
+            const intents = await requireCloudClient().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),
+                    }]
+            };
+        }
+        catch {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: CLOUD_REQUIRED_MSG }),
+                    }]
+            };
+        }
     });
     server.resource('intent://workspace-strategy', 'intent://workspace-strategy', async (uri) => {
         if (isLocalMode) {
@@ -64930,7 +65290,7 @@ function startMcpServer() {
             };
         }
         try {
-            const workspace = await client.getWorkspace();
+            const workspace = await requireCloudClient().getWorkspace();
             return {
                 contents: [{
                         uri: uri.href,