@pathmode/mcp-server 1.4.5 → 1.6.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;
@@ -33680,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:
@@ -33702,6 +33903,7 @@ exports.getCompileIntentPrompt = getCompileIntentPrompt;
 exports.formatIntentMd = formatIntentMd;
 exports.formatCursorRules = formatCursorRules;
 exports.formatClaudeMdSection = formatClaudeMdSection;
+exports.formatOutcomeRubric = formatOutcomeRubric;
 /** Extract text from a string or structured outcome. */
 function getOutcomeText(o) {
     return typeof o === 'string' ? o : o.text;
@@ -34057,6 +34259,224 @@ function formatClaudeMdSection(spec) {
     sections.push('<!-- PATHMODE:END -->');
     return sections.join('\n\n');
 }
+function getOutcomePriority(o) {
+    return typeof o === 'string' ? undefined : o.priority;
+}
+/** Map an outcome priority to grader-facing strength language. */
+function priorityToBar(priority) {
+    switch (priority) {
+        case 'should': return 'Expected';
+        case 'could': return 'Optional — note if present, do not fail if absent';
+        case 'must':
+        default: return 'Required';
+    }
+}
+/**
+ * Dedup constraint strings by a normalized key — strips trailing parenthetical
+ * refs (e.g. "(CON-2)"), trailing punctuation, and case, so an intent constraint
+ * and its constitution twin collapse to one. Keeps the first (more specific) form.
+ */
+function dedupeByNormalized(items) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of items) {
+        const item = raw?.trim();
+        if (!item)
+            continue;
+        const key = item
+            .toLowerCase()
+            .replace(/\s*\([^)]*\)\s*/g, ' ')
+            .replace(/[.\s]+$/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+/**
+ * Build the writer-facing task description — what the agent reads. Maps to the
+ * `description` field of a `user.define_outcome` event.
+ */
+function buildWriterDescription(spec) {
+    const sections = [];
+    sections.push(`Deliver: ${spec.title || 'Untitled intent'}.`);
+    if (spec.objective) {
+        sections.push('');
+        sections.push(`Why this matters: ${spec.objective}`);
+    }
+    if (spec.scope?.inScope?.length) {
+        sections.push('');
+        sections.push('In scope:');
+        for (const item of spec.scope.inScope)
+            sections.push(`- ${item}`);
+    }
+    if (spec.scope?.outOfScope?.length) {
+        sections.push('');
+        sections.push('Out of scope — do not do these:');
+        for (const item of spec.scope.outOfScope)
+            sections.push(`- ${item}`);
+    }
+    const ic = spec.implementationContext;
+    if (ic?.relevantAreas?.length) {
+        sections.push('');
+        sections.push('Relevant areas of the codebase:');
+        for (const a of ic.relevantAreas) {
+            if (a?.path?.trim())
+                sections.push(`- ${a.path}${a.reason?.trim() ? ` — ${a.reason}` : ''}`);
+        }
+    }
+    if (ic?.currentBehavior?.trim()) {
+        sections.push('');
+        sections.push(`Current behavior: ${ic.currentBehavior.trim()}`);
+    }
+    sections.push('');
+    sections.push('Write your deliverables to /mnt/session/outputs/. Iterate until the grader is satisfied.');
+    return sections.join('\n');
+}
+/**
+ * Build the grader-facing rubric — what the independent grader reads. Maps to the
+ * `rubric` field of a `user.define_outcome` event. Every criterion is written to
+ * force the grader to find concrete evidence rather than trust the writer.
+ */
+function buildGraderRubric(spec, opts = {}) {
+    const sections = [];
+    sections.push(`You are grading the artifact(s) in /mnt/session/outputs/ for: "${spec.title || 'Untitled intent'}".`);
+    sections.push('Score each criterion below independently. PASS a criterion only when you can point to concrete evidence in the artifact — a measured value, a visible state, a passing test, or a quoted line. The writer asserting it is done is NOT evidence.');
+    // Outcomes → coverage criteria
+    const outcomes = (spec.outcomes ?? []).filter((o) => getOutcomeText(o)?.trim());
+    if (outcomes.length) {
+        sections.push('');
+        sections.push('## Outcomes (coverage)');
+        let i = 1;
+        for (const o of outcomes) {
+            const bar = priorityToBar(getOutcomePriority(o));
+            sections.push(`${i}. [${bar}] ${getOutcomeText(o)}`);
+            sections.push('   - Evidence: point to the specific value, state, or test result in the artifact that proves this. If you cannot, mark FAIL.');
+            i++;
+        }
+    }
+    // Edge cases → must-handle criteria (structured edge cases + implementation-context risks)
+    const edgeCases = (spec.edgeCases ?? []).filter((ec) => ec.scenario?.trim() || ec.expectedBehavior?.trim());
+    const risks = (spec.implementationContext?.risks ?? []).filter((r) => r?.trim());
+    if (edgeCases.length || risks.length) {
+        sections.push('');
+        sections.push('## Edge cases (must handle)');
+        for (const ec of edgeCases) {
+            sections.push(`- ${ec.scenario} → expected: ${ec.expectedBehavior}`);
+            sections.push(`   - Evidence: locate or construct the "${ec.scenario}" condition and confirm the expected behavior occurs. Absent handling = FAIL.`);
+        }
+        for (const r of risks) {
+            sections.push(`- Guard against: ${r}`);
+            sections.push('   - Evidence: show the artifact handles this failure mode — a test, a guard clause, or a visible safe state. Unaddressed = FAIL.');
+        }
+    }
+    // Constraints + constitution + out-of-scope → out-of-bounds / no-fire list
+    const outOfBounds = [];
+    if (spec.constraints?.length)
+        outOfBounds.push(...spec.constraints);
+    if (opts.constitutionRules?.length)
+        outOfBounds.push(...opts.constitutionRules);
+    if (spec.scope?.outOfScope?.length) {
+        for (const item of spec.scope.outOfScope)
+            outOfBounds.push(`Stays out of scope: ${item}`);
+    }
+    const cleanedBounds = dedupeByNormalized(outOfBounds);
+    if (cleanedBounds.length) {
+        sections.push('');
+        sections.push('## Constraints (out of bounds — FAIL the artifact if any are violated)');
+        for (const c of cleanedBounds)
+            sections.push(`- ${c}`);
+    }
+    // Verification → procedures the grader must run to produce evidence
+    const v = spec.verification;
+    const checks = [];
+    for (const t of v?.e2eTests ?? [])
+        if (t?.trim())
+            checks.push(`[e2e] ${t}`);
+    for (const t of v?.unitTests ?? [])
+        if (t?.trim())
+            checks.push(`[unit] ${t}`);
+    for (const t of v?.manualChecks ?? [])
+        if (t?.trim())
+            checks.push(`[manual] ${t}`);
+    for (const t of spec.implementationContext?.verificationSuggestions ?? [])
+        if (t?.trim())
+            checks.push(`[suggested] ${t}`);
+    if (checks.length) {
+        sections.push('');
+        sections.push('## Checks to run (produce the evidence yourself)');
+        for (const c of checks)
+            sections.push(`- ${c}`);
+    }
+    // Health metrics → observable-signal criteria
+    const metrics = (spec.healthMetrics ?? []).filter((m) => m?.trim());
+    if (metrics.length) {
+        sections.push('');
+        sections.push('## Observable signals');
+        for (const m of metrics) {
+            sections.push(`- The artifact leaves a way to measure: ${m}`);
+        }
+    }
+    // Grader output format — proven shape from the Outcomes cookbook
+    sections.push('');
+    sections.push('## Output format');
+    sections.push('Line 1: a scoreboard — "Outcomes X/Y met. Constraints OK|VIOLATED. Edge cases X/Y."');
+    sections.push('Then one bullet per FAILED item only: "<section> <item> — FAIL. <what is missing and what to change>." One sentence per bullet.');
+    sections.push('Do not fail the artifact for style preferences, pre-existing issues outside this intent, or anything not listed above.');
+    return sections.join('\n');
+}
+/**
+ * Generate a Claude Managed Agents "Outcomes" rubric document for an intent.
+ *
+ * Outcomes (`user.define_outcome`) takes two separate fields: a `description`
+ * the writer agent reads, and a `rubric` the independent grader reads. This
+ * exporter renders both — clearly separated so they paste straight into the API —
+ * turning the intent's outcomes, edge cases, constraints, constitution rules and
+ * verification into checkable, evidence-forcing grader criteria.
+ *
+ * Docs: https://platform.claude.com/docs/en/managed-agents/define-outcomes
+ */
+function formatOutcomeRubric(spec, opts = {}) {
+    const maxIterations = opts.maxIterations ?? 5;
+    const description = buildWriterDescription(spec);
+    const rubric = buildGraderRubric(spec, opts);
+    const hasVerification = [
+        ...(spec.verification?.e2eTests ?? []),
+        ...(spec.verification?.unitTests ?? []),
+        ...(spec.verification?.manualChecks ?? []),
+    ].some((t) => t?.trim());
+    const doc = [];
+    doc.push('<!-- Pathmode → Claude Managed Agents: Outcomes rubric -->');
+    doc.push(`<!-- Generated ${new Date().toISOString()} | pathmode.io -->`);
+    doc.push('');
+    doc.push('# How to use this');
+    doc.push('');
+    doc.push('Send a `user.define_outcome` event to a Managed Agents session (beta header `managed-agents-2026-04-01`):');
+    doc.push('- Put **Writer Description** into the `description` field (the agent reads this).');
+    doc.push('- Put **Grader Rubric** into the `rubric` field (the independent grader reads this).');
+    doc.push(`- Suggested \`max_iterations\`: ${maxIterations} (Outcomes default 3, max 20).`);
+    if (!hasVerification) {
+        doc.push('');
+        doc.push('> ⚠ This intent has no verification defined, so grader criteria fall back to generic evidence requirements. Run `verify-intent` to sharpen the checks.');
+    }
+    doc.push('');
+    doc.push('---');
+    doc.push('');
+    doc.push('# Writer Description');
+    doc.push('');
+    doc.push(description);
+    doc.push('');
+    doc.push('---');
+    doc.push('');
+    doc.push('# Grader Rubric');
+    doc.push('');
+    doc.push(rubric);
+    doc.push('');
+    return doc.join('\n');
+}
 
 
 /***/ }),
@@ -64125,9 +64545,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.
@@ -64166,16 +64588,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();
 }
@@ -64199,7 +64628,7 @@ function startMcpServer() {
     // ============================================================
     const server = new mcp_js_1.McpServer({
         name: 'pathmode',
-        version: '1.4.4',
+        version: '1.4.5',
     });
     // Annotation presets
     const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -64214,6 +64643,28 @@ function startMcpServer() {
     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.
@@ -64222,14 +64673,14 @@ function startMcpServer() {
     // ============================================================
     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.' }] };
             }
@@ -64242,9 +64693,9 @@ function startMcpServer() {
             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',
@@ -64540,11 +64991,27 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: `Graph analysis failed: ${e.message}` }] };
         }
     });
+    /** Map a cloud ApiIntent into the IntentFields shape the formatters consume. */
+    function apiIntentToFields(intent) {
+        const v = (intent.verification || {});
+        return {
+            id: intent.id,
+            title: intent.title,
+            objective: intent.objective,
+            outcomes: intent.outcomes ?? [],
+            constraints: intent.constraints,
+            edgeCases: (intent.edgeCases ?? []).map((e) => ({ scenario: e.scenario, expectedBehavior: e.expectedBehavior })),
+            healthMetrics: intent.healthMetrics,
+            scope: intent.scope,
+            verification: { manualChecks: v.manualChecks, unitTests: v.unitTests, e2eTests: v.e2eTests },
+            implementationContext: intent.implementationContext ?? undefined,
+        };
+    }
     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. For cursorrules/intent-md, product context is always derived from the resolved intent. For claude-md, pass productId to select a specific product, otherwise the first active product is used.',
+        description: 'Export workspace context as a formatted file. Use "claude-md" for CLAUDE.md (full workspace context), "cursorrules" for Cursor AI rules, "intent-md" for a single intent specification file, or "outcome-rubric" for a Claude Managed Agents Outcomes rubric (writer description + evidence-forcing grader rubric) derived from the resolved intent, its implementation context, and the workspace constitution. For cursorrules/intent-md/outcome-rubric, product context is always derived from the resolved intent. For claude-md, pass productId to select a specific product, otherwise the first active product is used.',
         inputSchema: {
-            format: zod_1.z.enum(['claude-md', 'cursorrules', 'intent-md']).describe('Export format'),
+            format: zod_1.z.enum(['claude-md', 'cursorrules', 'intent-md', 'outcome-rubric']).describe('Export format'),
             intentId: zod_1.z.string().optional().describe('Intent ID (optional, for cursorrules and intent-md)'),
             productId: zod_1.z.string().optional().describe('Product ID (optional, only used for claude-md format to select a specific product)'),
         },
@@ -64554,6 +65021,25 @@ function startMcpServer() {
             return { content: [{ type: 'text', text: 'Export requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
         }
         try {
+            if (format === 'outcome-rubric') {
+                const cloud = requireCloudClient();
+                const intent = intentId
+                    ? await cloud.getIntent(intentId)
+                    : (pickCurrentIntent(await cloud.listIntents('approved')) || pickCurrentIntent(await cloud.listIntents()));
+                if (!intent) {
+                    return { content: [{ type: 'text', text: 'No intent found to export. Pass an intentId, or create an approved intent first.' }] };
+                }
+                let constitutionRules = [];
+                try {
+                    const constitution = await cloud.getConstitution();
+                    constitutionRules = (constitution?.rules ?? [])
+                        .filter((r) => r?.isActive !== false && r?.text?.trim())
+                        .map((r) => r.text.trim());
+                }
+                catch { /* constitution is optional context */ }
+                const rubric = (0, intent_compiler_1.formatOutcomeRubric)(apiIntentToFields(intent), { constitutionRules });
+                return { content: [{ type: 'text', text: rubric }] };
+            }
             const content = await requireCloudClient().exportContext(format, intentId, productId);
             return { content: [{ type: 'text', text: content }] };
         }
@@ -64937,8 +65423,8 @@ function startMcpServer() {
                 }],
         };
     });
-    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'),
+    server.tool('intent_export', 'Export an intent spec as .cursorrules, a CLAUDE.md section, or a Claude Managed Agents Outcomes rubric for AI agent consumption.', {
+        format: zod_1.z.enum(['cursorrules', 'claude-md', 'outcome-rubric']).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 }) => {
@@ -64953,6 +65439,17 @@ function startMcpServer() {
                     }],
             };
         }
+        else if (format === 'outcome-rubric') {
+            const content = (0, intent_compiler_1.formatOutcomeRubric)(spec);
+            const filePath = (0, path_1.resolve)(process.cwd(), path || 'outcome-rubric.md');
+            (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✓ Exported Outcomes rubric to ${filePath}\n\nPaste the Writer Description into the \`description\` field and the Grader Rubric into the \`rubric\` field of a Managed Agents \`user.define_outcome\` event. Docs: https://platform.claude.com/docs/en/managed-agents/define-outcomes`,
+                    }],
+            };
+        }
         else {
             const section = (0, intent_compiler_1.formatClaudeMdSection)(spec);
             const filePath = (0, path_1.resolve)(process.cwd(), path || 'CLAUDE.md');
@@ -64962,7 +65459,10 @@ function startMcpServer() {
                 existing = (0, fs_1.readFileSync)(filePath, 'utf-8');
             }
             catch { /* file doesn't exist yet */ }
-            const marker = /<!-- PATHMODE:START -->[\s\S]*?<!-- PATHMODE:END -->/;
+            // Tolerant of the suffixed start marker emitted by formatClaudeMdSection
+            // (`<!-- PATHMODE:START - Do not edit... -->`), so re-exports replace
+            // the block instead of appending a duplicate.
+            const marker = /<!-- PATHMODE:START[\s\S]*?-->[\s\S]*?<!-- PATHMODE:END -->/;
             const updated = marker.test(existing)
                 ? existing.replace(marker, section)
                 : existing ? existing + '\n\n' + section : section;