@pathmode/mcp-server 1.13.1 → 1.14.0

package/dist/index.js

@@ -33543,13 +33543,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.PathmodeClient = void 0;
+exports.PathmodeClient = exports.ApiError = void 0;
 exports.normalizeApiKey = normalizeApiKey;
 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';
+/** An API failure that keeps the response body, so callers can act on `code` and its payload. */
+class ApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(message) {
+        super(message);
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.pathmode');
 const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
 /**
@@ -33620,7 +33631,15 @@ class PathmodeClient {
                     '(1) re-run "npx @pathmode/mcp-server setup pm_live_xxx" with a fresh key from your workspace settings at https://pathmode.io, or ' +
                     '(2) remove PATHMODE_API_KEY (and ~/.pathmode/config.json) and restart to use free keyless local mode, where specs live in intent.md and no account is needed.');
             }
-            throw new Error(`API error (${response.status}): ${body.error || response.statusText}`);
+            // Carry the structured body, not just a sentence. PRODUCT_REQUIRED ships the candidate
+            // list precisely so the agent can ask which product and retry; flattening it to a string
+            // threw away the only thing that made the error actionable.
+            const err = new ApiError(`API error (${response.status}): ${body.error || response.statusText}`);
+            err.status = response.status;
+            const structured = body;
+            err.code = typeof structured.code === 'string' ? structured.code : undefined;
+            err.body = body;
+            throw err;
         }
         return response;
     }
@@ -33657,6 +33676,45 @@ class PathmodeClient {
                 console.error(`[pathmode-mcp] handshake failed (ignored): ${e}`);
         }
     }
+    /**
+     * Report that one tool fired. Cloud mode only — see instrumentToolTelemetry in
+     * index.ts, which is the thing that decides whether this is ever reached.
+     *
+     * The handshake tells the server a client launched; nothing told it whether the
+     * client did anything. Three tools compute and write entirely on this machine and
+     * reach no data endpoint, so with a valid key their invocations produced neither an
+     * `api_call` nor any other trace: 140 launches and zero calls in 13.5 hours reads
+     * the same whether the user hammered the preflight loop or never invoked a thing.
+     *
+     * Carries a tool name and an outcome. Never arguments, spec content, paths, or
+     * anything read out of the user's repo — the server-side allowlist rejects a name
+     * it does not recognise, so this stays a name-and-outcome channel even if a future
+     * caller here gets careless.
+     *
+     * Silent by contract, exactly like handshake(): never throws, never writes to
+     * stdout (stdout belongs to JSON-RPC), never awaited on the tool's path. A tool
+     * result must not depend on our analytics reaching us. Deliberately does NOT go
+     * through `fetch()` above, which logs to stderr and throws on non-2xx.
+     */
+    async recordToolCall(tool, outcome) {
+        try {
+            const res = await fetch(`${this.apiUrl}/api/v1/connection/tool-call`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ tool, outcome }),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (isDebug)
+                console.error(`[pathmode-mcp] tool-call ${tool}/${outcome}: ${res.status}`);
+        }
+        catch (e) {
+            if (isDebug)
+                console.error(`[pathmode-mcp] tool-call failed (ignored): ${e}`);
+        }
+    }
     async listIntents(status) {
         const params = status ? `?status=${status}` : '';
         const res = await this.fetch(`/intents${params}`);
@@ -33685,6 +33743,35 @@ class PathmodeClient {
         });
         return res.json();
     }
+    /**
+     * Hand back what the repo looks like where an intent lands.
+     *
+     * Provenance is deliberately not a parameter: the server stamps source, timestamp and spec
+     * version, and ignores any attempt to supply them. `expectedSpecVersion` is the one exception,
+     * and it is a question rather than a claim — "was the spec still this when I read it?" — answered
+     * with 409 if not.
+     */
+    /**
+     * Append one decision to an intent's audit trail.
+     *
+     * Its own endpoint rather than a field on create/update, because that route validates every
+     * evidence id against the workspace and drops the ones that do not resolve — a caller must not be
+     * able to fabricate provenance by writing the column directly.
+     */
+    async recordDecision(intentId, input) {
+        const res = await this.fetch(`/intents/${intentId}/decisions`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+        return res.json();
+    }
+    async saveImplementationContext(intentId, input) {
+        const res = await this.fetch(`/intents/${intentId}/implementation-context`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+        return res.json();
+    }
     async recordFinding(intentId, input) {
         const res = await this.fetch(`/intents/${intentId}/findings`, {
             method: 'POST',
@@ -33692,6 +33779,13 @@ class PathmodeClient {
         });
         return res.json();
     }
+    async recordOutcomeMeasurement(intentId, input) {
+        const res = await this.fetch(`/intents/${intentId}/outcomes`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+        return res.json();
+    }
     async getWorkspace() {
         const res = await this.fetch('/workspace');
         return res.json();
@@ -34026,7 +34120,7 @@ async function runInstallSkills() {
 /***/ }),
 
 /***/ 6488:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
@@ -34046,6 +34140,9 @@ exports.formatIntentMd = formatIntentMd;
 exports.formatCursorRules = formatCursorRules;
 exports.formatClaudeMdSection = formatClaudeMdSection;
 exports.formatOutcomeRubric = formatOutcomeRubric;
+// Verification check collection. Mirrors lib/verification in the main app — this package is
+// standalone (own ncc build) and can't import it, so the type + adapter live here. `kind` is the
+const crypto_1 = __nccwpck_require__(6982);
 const VERIFICATION_KIND_LABELS = {
     fastest: 'Fastest check',
     'shipped-signal': 'Shipped signal',
@@ -34237,14 +34334,61 @@ function decisionLines(decisions, heading) {
  * is saved twice must keep its identity and its lifecycle state. Only a genuinely new intent
  * (no id) gets a minted id, version 1, and status 'draft'.
  */
+/**
+ * The body of `## Implementation Context` in intent.md.
+ *
+ * Two sources, one section. Local mode carries prose the agent gathered; cloud intents carry the
+ * analyzer's structured object. Rendering both under the same heading is what lets a spec move
+ * between modes without the section disappearing on the way through.
+ */
+function implementationContextBody(spec) {
+    const text = spec.implementationContextText?.trim();
+    if (text)
+        return [text];
+    const ic = spec.implementationContext;
+    if (!ic)
+        return [];
+    const lines = [];
+    if (ic.relevantAreas?.length) {
+        lines.push('### Relevant areas');
+        for (const a of ic.relevantAreas) {
+            if (a?.path?.trim())
+                lines.push(`- \`${a.path}\`${a.reason?.trim() ? ` — ${a.reason}` : ''}`);
+        }
+    }
+    if (ic.currentBehavior?.trim()) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Current behavior');
+        lines.push(ic.currentBehavior.trim());
+    }
+    if (ic.risks?.length) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Risks');
+        for (const r of ic.risks)
+            if (r?.trim())
+                lines.push(`- ${r.trim()}`);
+    }
+    if (ic.verificationSuggestions?.length) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Verification suggestions');
+        for (const v of ic.verificationSuggestions)
+            if (v?.trim())
+                lines.push(`- ${v.trim()}`);
+    }
+    return lines;
+}
 function formatIntentMd(spec, opts = {}) {
     const now = new Date().toISOString();
     const frontmatter = {
-        id: spec.id || `intent_${Date.now()}`,
+        id: spec.id || (0, crypto_1.randomUUID)(),
         version: opts.version && opts.version >= 1 ? opts.version : 1,
         status: opts.status || 'draft',
         ...(opts.readiness ? { readiness: opts.readiness } : {}),
         ...(opts.source ? { source: opts.source } : {}),
+        ...(opts.specVersion ? { specVersion: opts.specVersion } : {}),
         created: opts.created || now,
         updated: now,
     };
@@ -34269,6 +34413,15 @@ function formatIntentMd(spec, opts = {}) {
         sections.push('## Current State');
         sections.push(spec.currentState.trim());
     }
+    // Sits next to Current State on purpose: one is what the author says is true today, the other is
+    // what the repo says. Same heading the cloud agent prompt emits, so a handoff reads identically
+    // in either mode.
+    const icBody = implementationContextBody(spec);
+    if (icBody.length) {
+        sections.push('');
+        sections.push('## Implementation Context');
+        sections.push(...icBody);
+    }
     sections.push(...decisionLines(spec.decisions, '## Decisions & Ruled-Out Alternatives'));
     if (spec.outcomes?.length) {
         sections.push('');
@@ -34556,6 +34709,26 @@ function buildWriterDescription(spec) {
     sections.push('Write your deliverables to /mnt/session/outputs/. Iterate until the grader is satisfied.');
     return sections.join('\n');
 }
+/**
+ * May this implementation context set grading criteria?
+ *
+ * The rubric turns `risks` into must-handle criteria whose absence is a FAIL, and
+ * `verificationSuggestions` into checks the grader runs. That is fine when the analyzer wrote them:
+ * it is a separate party from the agent being graded. It is not fine when the agent wrote them,
+ * because then the party under judgment is drafting its own rubric — it could file a trivial risk it
+ * has already handled, or omit the hard one, and the grader would never know the difference.
+ *
+ * Agent-supplied context still reaches the implementing agent as prose; it just cannot bind the
+ * grader until a human has looked at it and promoted it. Anything without a `source` is analyzer
+ * output from before this distinction existed, and keeps its old behavior.
+ */
+function bindsGradingCriteria(ic) {
+    if (!ic)
+        return false;
+    if (ic.source !== 'agent')
+        return true;
+    return !!ic.promotedAt;
+}
 /**
  * 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
@@ -34580,7 +34753,7 @@ function buildGraderRubric(spec, opts = {}) {
     }
     // 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());
+    const risks = (bindsGradingCriteria(spec.implementationContext) ? spec.implementationContext?.risks ?? [] : []).filter((r) => r?.trim());
     if (edgeCases.length || risks.length) {
         sections.push('');
         sections.push('## Edge cases (must handle)');
@@ -34614,9 +34787,11 @@ function buildGraderRubric(spec, opts = {}) {
     const checks = [];
     for (const c of toVerificationChecks(spec.verification))
         checks.push(`[${c.kind}] ${renderCheckLine(c)}`);
-    for (const t of spec.implementationContext?.verificationSuggestions ?? [])
-        if (t?.trim())
-            checks.push(`[suggested] ${t}`);
+    if (bindsGradingCriteria(spec.implementationContext)) {
+        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)');
@@ -34754,6 +34929,7 @@ function readIntentMeta(filePath) {
             version: Number.isFinite(version) && version >= 1 ? version : 1,
             status: typeof data.status === 'string' && data.status.trim() ? data.status.trim() : 'draft',
             created: typeof data.created === 'string' ? data.created : undefined,
+            specVersion: typeof data.specVersion === 'string' && data.specVersion.trim() ? data.specVersion.trim() : undefined,
         };
     }
     catch {
@@ -34797,6 +34973,7 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
         version: Number.isFinite(version) && version >= 1 ? version : 1,
         objective: data.objective || extractSection(sections, 'Objective') || '',
         currentState: extractSection(sections, 'Current State') || undefined,
+        implementationContext: extractSection(sections, 'Implementation Context') || undefined,
         title: data.title || data.userGoal || extractTitle(body) || 'Untitled Intent',
         stageName: data.stage || undefined,
         severity: data.severity || undefined,
@@ -35040,6 +35217,108 @@ function hasVerificationContent(v) {
 }
 
 
+/***/ }),
+
+/***/ 1635:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+/**
+ * Input schema for the `record_outcome_measurement` tool.
+ *
+ * **This mirrors `lib/outcomeMeasurementRecord.ts` in the web app and must stay in step
+ * with it.** It cannot import it: this package publishes to npm as a standalone bundle
+ * (ncc, no workspace deps), so reaching into the app's `lib/` would drag the web app into
+ * the published artifact.
+ *
+ * Duplication is the cost, drift is the risk, and drift already happened once — the first
+ * version of this tool accepted requests the API then rejected: both outcome selectors
+ * omitted, a rolling window with no duration, a fixed window with no bounds, a free-form
+ * `evaluatedAt`, and unbounded strings where the API caps length. Every one of those cost
+ * an agent a network round trip to learn something it could have been told locally.
+ * `measurement-schema.test.ts` pins the cases so the next drift fails in CI instead.
+ *
+ * Bounds below are the API's: 500 chars for text values, 100 for short identifiers, 50 for
+ * units and source labels.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.recordOutcomeMeasurementInputSchema = exports.provenanceShape = exports.expectationShape = exports.windowShape = exports.queryRefShape = exports.windowKindEnum = exports.comparatorEnum = void 0;
+exports.outcomeSelectorError = outcomeSelectorError;
+const zod_1 = __nccwpck_require__(924);
+const MAX_TEXT = 500;
+const MAX_SHORT = 100;
+const MAX_UNIT = 50;
+exports.comparatorEnum = zod_1.z.enum(['gt', 'gte', 'lt', 'lte', 'eq']);
+exports.windowKindEnum = zod_1.z.enum(['rolling', 'fixed', 'since_ship']);
+exports.queryRefShape = zod_1.z.object({
+    kind: zod_1.z.string().trim().min(1).max(MAX_SHORT).describe('How to interpret the id, e.g. "saved_insight"'),
+    id: zod_1.z.string().trim().min(1).max(MAX_TEXT).describe('Stable id of the query. An id, never a name — names get renamed and the record then points nowhere.'),
+});
+/**
+ * Refinements do not appear in the JSON Schema the model sees, so the requirement is also
+ * stated in each `describe`. The refinement is what stops a malformed window reaching the
+ * API; the description is what stops the model producing one in the first place.
+ */
+exports.windowShape = zod_1.z
+    .object({
+    kind: exports.windowKindEnum.describe('How the window is bounded'),
+    duration: zod_1.z.string().trim().min(1).max(MAX_SHORT).optional().describe('REQUIRED when kind is "rolling", e.g. "28d"'),
+    start: zod_1.z.string().trim().min(1).max(MAX_SHORT).optional().describe('REQUIRED when kind is "fixed"'),
+    end: zod_1.z.string().trim().min(1).max(MAX_SHORT).optional().describe('REQUIRED when kind is "fixed"'),
+})
+    .refine(w => w.kind !== 'rolling' || !!w.duration, {
+    message: 'A rolling window requires a duration',
+    path: ['duration'],
+})
+    .refine(w => w.kind !== 'fixed' || (!!w.start && !!w.end), {
+    message: 'A fixed window requires both start and end',
+    path: ['start'],
+});
+exports.expectationShape = zod_1.z.object({
+    operator: exports.comparatorEnum,
+    target: zod_1.z.number().finite(),
+    unit: zod_1.z.string().trim().max(MAX_UNIT).optional(),
+});
+exports.provenanceShape = zod_1.z.object({
+    provider: zod_1.z.string().trim().min(1).max(MAX_SHORT).describe('System the number came from, e.g. "posthog"'),
+    queryRef: exports.queryRefShape,
+    queryVersion: zod_1.z.string().trim().min(1).max(MAX_SHORT).optional().describe('Version or hash of the query, so a later edit to it is detectable'),
+    window: exports.windowShape,
+    evaluatedAt: zod_1.z.string().datetime().optional().describe('ISO-8601 timestamp of when you ran the query, e.g. "2026-08-25T12:00:00Z". Defaults to now.'),
+    expectation: exports.expectationShape.optional().describe('The threshold the outcome named. Supply this together with numericValue and the server decides `met` itself rather than taking your word for it.'),
+    rawResponse: zod_1.z.unknown().optional().describe('Snapshot of what the provider returned, so the number survives the query being changed or deleted'),
+    recordedByTool: zod_1.z.string().trim().min(1).max(MAX_SHORT).optional().describe('Which tool recorded this, e.g. "claude-code"'),
+});
+/** The tool's field map, in the ZodRawShape form `registerTool` expects. */
+exports.recordOutcomeMeasurementInputSchema = {
+    intentId: zod_1.z.string().trim().min(1).describe('The intent whose outcome you measured'),
+    outcomeId: zod_1.z.string().trim().min(1).optional().describe('Stable id of the outcome, from get_intent. Preferred over outcomeIndex.'),
+    outcomeIndex: zod_1.z.number().int().nonnegative().optional().describe('Positional fallback when the outcome has no id. Exactly one of outcomeId or outcomeIndex is required.'),
+    actualValue: zod_1.z.string().trim().min(1).max(MAX_TEXT).describe('What you measured, as displayable text, e.g. "12.4%" or "3m 20s"'),
+    numericValue: zod_1.z.number().finite().optional().describe('The same value as a number. Required for the server to check an expectation — without it the verdict can only be self-reported.'),
+    baselineValue: zod_1.z.string().trim().max(MAX_TEXT).optional().describe('What it was before, if you know it'),
+    unit: zod_1.z.string().trim().max(MAX_UNIT).optional().describe('Unit of the value, e.g. "%", "seconds", "signups/day"'),
+    met: zod_1.z.boolean().optional().describe('Only for when there is no computable expectation. Stored as a self-report, not as a checked fact.'),
+    source: zod_1.z.string().trim().max(MAX_UNIT).optional().describe('Where the number came from, e.g. "posthog"'),
+    measurement: exports.provenanceShape.optional().describe('Provenance. Omit only if you genuinely cannot say where the number came from.'),
+};
+/**
+ * The one constraint that cannot live in the field map.
+ *
+ * `registerTool` takes a ZodRawShape and builds the object itself, so an object-level
+ * `.refine()` across two sibling fields has nowhere to attach. Checking it in the handler
+ * keeps the failure local and the message identical to the API's, instead of spending a
+ * round trip to be told the same thing.
+ */
+function outcomeSelectorError(input) {
+    if (input.outcomeId == null && input.outcomeIndex == null) {
+        return 'outcomeId (preferred) or outcomeIndex is required. Call get_intent to read the outcome ids on this intent.';
+    }
+    return null;
+}
+
+
 /***/ }),
 
 /***/ 4681:
@@ -35092,6 +35371,111 @@ function mergePathmodeSection(existing, section) {
 }
 
 
+/***/ }),
+
+/***/ 4239:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+/**
+ * Push a saved spec to the workspace, in the order that makes a retry repair rather than duplicate.
+ *
+ * Three legs, and the split between them is the whole design:
+ *
+ *   1. **Identity** (create or update). The only leg allowed to fail the save. It settles what this
+ *      spec IS and returns the server's opaque version token.
+ *   2. **The file write**, via `onIdentitySettled`, immediately after leg 1 and BEFORE the rest.
+ *   3. **Enrichment** (decisions, implementation context). These report; they never fail the save.
+ *
+ * Why the file cannot wait until every leg succeeds: the write is what puts `specVersion` on disk,
+ * and `specVersion` on disk is what makes the NEXT save an update. Defer the write and a failure in
+ * leg 3 leaves a cloud record with no local token — so the next save looks like a first save and
+ * creates a SECOND intent. Refusing to write would not prevent divergence, it would manufacture
+ * duplicates, which is worse than the state it was avoiding.
+ *
+ * Enrichment goes through dedicated endpoints rather than fields on create because each is validated
+ * there: evidence ids are checked against the workspace so provenance cannot be fabricated, and
+ * implementation context is stamped with its source so unpromoted agent content stays out of the
+ * grading rubric. Riding along on create would bypass both.
+ *
+ * A failed enrichment leg is recoverable by saving again: its content is already in the local file,
+ * and the retry is an update.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pushSpec = pushSpec;
+async function pushSpec(input) {
+    const { client, id, existingSpecVersion, payload } = input;
+    let canonicalId;
+    let specVersion;
+    let sourceUrl;
+    try {
+        // On create the local id travels with the spec. Promotion must not change identity: a
+        // keyless author may already have stamped `intent/<uuid>` on a branch, and a new id would
+        // quietly break the merge resolution that stamp exists for.
+        let saved;
+        if (existingSpecVersion) {
+            saved = await client.updateIntent(id, { ...payload, expectedVersion: existingSpecVersion });
+        }
+        else {
+            try {
+                saved = await client.createIntent({ ...payload, id });
+            }
+            catch (e) {
+                // The create may have COMMITTED and lost its response — a dropped connection after
+                // the insert. Retrying then hits INTENT_ID_TAKEN forever, and because specVersion
+                // never reached the file every later save also looks like a first save. Since WE
+                // chose the id, a taken id in our own workspace is our own record: adopt it.
+                if (e?.code === 'INTENT_ID_TAKEN' && client.getIntent) {
+                    saved = await client.getIntent(id);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        canonicalId = saved.id || id;
+        specVersion = saved.specVersion;
+        sourceUrl = `https://www.pathmode.io/intent/${canonicalId}`;
+    }
+    catch (e) {
+        // Keep the structured detail. PRODUCT_REQUIRED carries the candidate products so the agent can
+        // ask which one and retry; a flattened message leaves it with nothing to act on.
+        const products = Array.isArray(e?.body?.products) ? e.body.products : undefined;
+        return {
+            ok: false,
+            error: String(e?.message || e),
+            ...(e?.code ? { code: e.code } : {}),
+            ...(products ? { products } : {}),
+        };
+    }
+    input.onIdentitySettled({ canonicalId, specVersion, sourceUrl });
+    const didNotTravel = [];
+    for (const d of input.decisions ?? []) {
+        try {
+            await client.recordDecision(canonicalId, { choice: d.choice, reason: d.reason, ruledOut: d.ruledOut });
+        }
+        catch {
+            didNotTravel.push(`decision "${d.choice.slice(0, 40)}" — save again to retry`);
+        }
+    }
+    if (input.implementationContext?.trim()) {
+        try {
+            // State the version this was gathered against, so a spec that moved between the
+            // identity write and here is a 409 rather than context describing a spec that is gone.
+            await client.saveImplementationContext(canonicalId, {
+                currentBehavior: input.implementationContext,
+                ...(specVersion ? { expectedSpecVersion: specVersion } : {}),
+            });
+        }
+        catch {
+            didNotTravel.push('implementation context — call record_implementation_context to retry');
+        }
+    }
+    return { ok: true, canonicalId, specVersion, sourceUrl, didNotTravel };
+}
+
+
 /***/ }),
 
 /***/ 3079:
@@ -39224,7 +39608,7 @@ const EMPTY_COMPLETION_RESULT = {
 
 /***/ }),
 
-/***/ 4239:
+/***/ 9477:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -65268,7 +65652,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"$schema":"http://json-schema.org/dra
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@pathmode/mcp-server","version":"1.13.1","publishConfig":{"access":"public"},"mcpName":"io.github.pathmodeio/mcp-server","description":"Deterministic intent preflight before your agent builds: six calibrated gates, keyless, no model call. Draft and sharpen specs in conversation, or connect a Pathmode workspace to sync intent and evidence across a team.","main":"dist/index.js","bin":{"pathmode-mcp":"dist/index.js"},"files":["dist/","manifest.json","icon.svg","README.md","skills/"],"scripts":{"build":"rm -rf dist && ncc build src/index.ts -o dist","dev":"ts-node src/index.ts","prepublishOnly":"npm run build"},"keywords":["pathmode","mcp","model-context-protocol","claude-code","claude-code-skills","agent-skills","cursor","windsurf","intent-engineering","intent-compiler","ai-agents","product-development","dependency-graph","strategic-planning"],"author":"Pathmode","license":"MIT","type":"commonjs","engines":{"node":">=18.0.0"},"homepage":"https://pathmode.io","dependencies":{"@modelcontextprotocol/sdk":"^1.12.1","gray-matter":"^4.0.3","zod":"^3.24.0"},"devDependencies":{"@types/node":"^25.1.0","@vercel/ncc":"^0.38.4","ts-node":"^10.9.2","typescript":"^5.9.3"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@pathmode/mcp-server","version":"1.14.0","publishConfig":{"access":"public"},"mcpName":"io.github.pathmodeio/mcp-server","description":"Deterministic intent preflight before your agent builds: six calibrated gates, keyless, no model call. Draft and sharpen specs in conversation, or connect a Pathmode workspace to sync intent and evidence across a team.","main":"dist/index.js","bin":{"pathmode-mcp":"dist/index.js"},"files":["dist/","manifest.json","icon.svg","README.md","skills/"],"scripts":{"build":"rm -rf dist && ncc build src/index.ts -o dist","dev":"ts-node src/index.ts","prepublishOnly":"npm run build"},"keywords":["pathmode","mcp","model-context-protocol","claude-code","claude-code-skills","agent-skills","cursor","windsurf","intent-engineering","intent-compiler","ai-agents","product-development","dependency-graph","strategic-planning"],"author":"Pathmode","license":"MIT","type":"commonjs","engines":{"node":">=18.0.0"},"homepage":"https://pathmode.io","dependencies":{"@modelcontextprotocol/sdk":"^1.12.1","gray-matter":"^4.0.3","zod":"^3.24.0"},"devDependencies":{"@types/node":"^25.1.0","@vercel/ncc":"^0.38.4","ts-node":"^10.9.2","typescript":"^5.9.3"}}');
 
 /***/ })
 
@@ -65358,7 +65742,9 @@ if (typeof globalThis.fetch === 'undefined') {
     }
 }
 const mcp_js_1 = __nccwpck_require__(3886);
-const stdio_js_1 = __nccwpck_require__(4239);
+const crypto_1 = __nccwpck_require__(6982);
+const push_spec_1 = __nccwpck_require__(4239);
+const stdio_js_1 = __nccwpck_require__(9477);
 const zod_1 = __nccwpck_require__(924);
 const path_1 = __nccwpck_require__(6928);
 const fs_1 = __nccwpck_require__(9896);
@@ -65369,6 +65755,7 @@ const save_policy_1 = __nccwpck_require__(6137);
 const intent_compiler_1 = __nccwpck_require__(6488);
 const pathmode_section_1 = __nccwpck_require__(4681);
 const setup_1 = __nccwpck_require__(8294);
+const measurement_schema_1 = __nccwpck_require__(1635);
 const install_skills_1 = __nccwpck_require__(3783);
 const cli_info_1 = __nccwpck_require__(7198);
 // Server version is sourced from package.json so the version reported to MCP
@@ -65460,6 +65847,64 @@ function startMcpServer() {
     const cloudOnly = isLocalMode
         ? { registerTool: (() => undefined) }
         : server;
+    // ── Per-tool-invocation signal ────────────────────────────────
+    //
+    // LOCAL MODE EMITS NOTHING. Keyless installs make no network request at all, which is a
+    // published promise (see LOCAL_MODE_INSTRUCTIONS above and pathmode.io/privacy), not an
+    // implementation detail. The gate is the early return below; there is no other path to
+    // recordToolCall.
+    //
+    // In cloud mode the launch handshake said a client started and nothing said whether it
+    // did anything. check_intent_readiness on an inline spec, intent_save and intent_export
+    // compute and write entirely on this machine, so even with a valid key they reached no
+    // endpoint and produced no `api_call` — 140 launches and zero calls in 13.5 hours reads
+    // identically whether the preflight loop was hammered or never touched.
+    //
+    // Wired at the registration seam rather than inside ~25 handlers: a tool added later is
+    // measured because it was registered, not because someone remembered to instrument it.
+    // Both entry points are patched because McpServer.tool() and .registerTool() each build
+    // the handler directly (neither delegates to the other), so this wraps every tool
+    // exactly once. Sends a name and an outcome, never an argument.
+    //
+    // Known gap: the SDK rejects arguments that fail the tool's zod schema before the handler
+    // runs, so a malformed call is answered with -32602 and reports nothing. What this
+    // measures is "a tool executed", not "a tool was attempted". Seeing the malformed
+    // attempts would mean hooking the tools/call request handler instead, which is private
+    // SDK surface — worth doing only if the executed-call numbers turn out to need it.
+    function instrumentToolTelemetry() {
+        if (isLocalMode || !client)
+            return;
+        const cloud = client;
+        // Fire-and-forget on both paths, never awaited: a tool's result must not wait on,
+        // or be lost to, our analytics. recordToolCall swallows its own failures.
+        const wrap = (name, handler) => async (...args) => {
+            try {
+                const result = await handler(...args);
+                void cloud.recordToolCall(name, result?.isError ? 'error' : 'ok');
+                return result;
+            }
+            catch (e) {
+                // The SDK turns a thrown handler error into an isError result for the client;
+                // we record the outcome and stay out of the way.
+                void cloud.recordToolCall(name, 'error');
+                throw e;
+            }
+        };
+        // The handler is the last argument of both signatures — tool(name, ...rest, cb) and
+        // registerTool(name, config, cb).
+        const patch = (method) => {
+            const original = server[method].bind(server);
+            server[method] = (...args) => {
+                const handler = args[args.length - 1];
+                if (typeof handler !== 'function')
+                    return original(...args);
+                return original(...args.slice(0, -1), wrap(String(args[0]), handler));
+            };
+        };
+        patch('tool');
+        patch('registerTool');
+    }
+    instrumentToolTelemetry();
     function normalizeText(value) {
         return (value || '').trim();
     }
@@ -66033,7 +66478,7 @@ function startMcpServer() {
     // ============================================================
     cloudOnly.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.',
+        description: 'Update the status of an intent. **If the change ships through a pull request, do NOT use this to mark it shipped** — stamp the intent reference on the branch or PR body and let the merge do it, because the merge grades the real diff and an intent already at shipped is skipped by that grading. Use this for work that will never appear in a PR, and for the shipped→verified transition once the outcome is confirmed in production. 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'),
@@ -66080,6 +66525,50 @@ function startMcpServer() {
                 }]
         };
     });
+    cloudOnly.registerTool('record_implementation_context', {
+        title: 'Record Implementation Context',
+        description: 'Hand back what the repo actually looks like where an intent lands: the files and modules involved, how it behaves today, what a change would risk, and how to verify it. You are already in the working tree, so read it rather than guessing — you see more than our repo analyzer can, including uncommitted work. Advisory by design: it never changes the readiness verdict. Its job is to stop the NEXT agent from rediscovering the codebase, and to surface the case where the thing being specified half-exists already.',
+        inputSchema: {
+            intentId: zod_1.z.string().describe('The intent this context describes'),
+            relevantAreas: zod_1.z.array(zod_1.z.object({
+                path: zod_1.z.string().describe('File or directory path'),
+                reason: zod_1.z.string().describe('Why this change touches it'),
+            })).optional().describe('Where the change lands. Max 100.'),
+            currentBehavior: zod_1.z.string().optional().describe('How the code behaves today where this lands, read from the tree rather than assumed.'),
+            liftEstimate: zod_1.z.enum(['low', 'medium', 'high']).optional().describe('Rough size of the change.'),
+            risks: zod_1.z.array(zod_1.z.string()).optional().describe('What a change here could break. Reaches the implementing agent as prose; it does NOT become a grading criterion until a human promotes it, because you would otherwise be writing the rubric you are graded against.'),
+            verificationSuggestions: zod_1.z.array(zod_1.z.string()).optional().describe('Checks worth running. Same promotion rule as risks.'),
+            expectedSpecVersion: zod_1.z.string().optional().describe('The spec content hash you gathered this against, from a previous read. If the spec has moved since, the write is refused rather than attaching a description of a spec that no longer exists.'),
+        },
+    }, async ({ intentId, ...input }) => {
+        if (isLocalMode) {
+            // Not a dead end: the local path exists and is lossless, because intent_save carries the
+            // whole spec rather than read-modify-writing a file this tool would have to reconstruct.
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'In keyless local mode there is no separate call for this. Pass the same text to `intent_save` as `implementationContext` and it lands in the `## Implementation Context` section of intent.md.',
+                    }],
+            };
+        }
+        try {
+            const result = await requireCloudClient().saveImplementationContext(intentId, input);
+            const ctx = result?.implementationContext ?? {};
+            const areas = Array.isArray(ctx.relevantAreas) ? ctx.relevantAreas.length : 0;
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✓ Implementation context recorded for ${intentId} (${areas} area(s), spec version ${result?.specVersion ?? 'unknown'}).\n\nIt reaches the implementing agent as context. Risks and verification suggestions stay out of the grading rubric until a human promotes them.`,
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: 'text', text: `Failed to record implementation context: ${e?.message || e}` }],
+                isError: true,
+            };
+        }
+    });
     cloudOnly.registerTool('record_implementation_finding', {
         title: 'Record Implementation Finding',
         description: 'Write a correction back to an intent when BUILDING it revealed the spec was wrong. Use this the moment you discover the spec assumed something the implementation contradicts — instead of only fixing it in your head or this chat, record it so the NEXT agent or person inherits the correction. This is the inverse of a decision: it closes the refinement loop so the same stale premise is not rebuilt. Open findings ride into future agent prompts until a human reconciles them into the spec.',
@@ -66105,14 +66594,47 @@ function startMcpServer() {
                 }]
         };
     });
+    cloudOnly.registerTool('record_outcome_measurement', {
+        title: 'Record Outcome Measurement',
+        description: 'Record what actually happened to one of an intent\'s outcomes after it shipped. Use this to close the loop: the spec said what should change, this says whether it did. NOT for spec corrections — those are record_implementation_finding. Send numericValue together with measurement.expectation and the server computes whether the target was met, which is what makes the record auditable rather than an assertion; a `met` you supply yourself is stored but marked self-reported. Point measurement.queryRef at a STABLE id (for PostHog, a saved insight id) rather than a metric name, because names get renamed and the record then points nowhere.',
+        inputSchema: measurement_schema_1.recordOutcomeMeasurementInputSchema,
+        annotations: WRITE_OP,
+    }, async ({ intentId, ...input }) => {
+        if (isLocalMode) {
+            return { content: [{ type: 'text', text: 'Recording outcome measurements requires cloud mode. Use PATHMODE_API_KEY to connect.' }] };
+        }
+        // Caught here rather than at the API: registerTool builds the input object itself,
+        // so this cross-field rule has nowhere to attach in the schema. Same message the
+        // API would return, one round trip earlier.
+        const selectorError = (0, measurement_schema_1.outcomeSelectorError)(input);
+        if (selectorError) {
+            return { content: [{ type: 'text', text: selectorError }], isError: true };
+        }
+        const result = await requireCloudClient().recordOutcomeMeasurement(intentId, input);
+        const basis = result?.metBasis;
+        const verdict = result?.met === null || result?.met === undefined
+            ? 'No verdict recorded'
+            : result.met ? 'Target met' : 'Target not met';
+        const how = basis === 'computed'
+            ? ' (computed by Pathmode from the expectation you supplied)'
+            : basis === 'self_report'
+                ? ' (recorded as your self-report — send numericValue and an expectation next time and Pathmode will check it)'
+                : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Measurement recorded for intent ${intentId}: ${result?.actualValue ?? input.actualValue}. ${verdict}${how}.`
+                }]
+        };
+    });
     cloudOnly.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.',
+        description: 'Create a new intent spec in the workspace WITHOUT writing a file. Use this only when there is no repository to write into — outside a project directory, intent_save would put intent.md wherever the process happens to be running. Inside a repo, prefer intent_save: it writes the file and syncs to the workspace in one step. Requires at minimum a title and objective; productId is resolved server-side when the workspace has exactly one real product. 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'),
             currentState: zod_1.z.string().optional().describe('How this works today, before the change: existing behavior, the workaround users rely on, what is broken. Tells implementing agents what must not regress. Omit for genuinely net-new capability.'),
-            productId: zod_1.z.string().describe('Product (Space) ID this intent belongs to. Use get_workspace to find product IDs.'),
+            productId: zod_1.z.string().optional().describe('Product (Space) ID this intent belongs to. Omit it and the server resolves it when the workspace has exactly one real product. If it cannot, you get code PRODUCT_REQUIRED with the candidate list: ASK THE USER which product, then retry with an explicit id. Do not guess — a GitHub binding hangs off the product, so the product decides which repository the PR stamp and merge verification apply to, and a wrong guess surfaces much later as a merge that silently fails to verify.'),
             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'),
@@ -66335,7 +66857,7 @@ function startMcpServer() {
                     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`,
+                        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. Name the work so the merge can find it: branch \`intent/${intentId}\`, or put \`pathmode:${intentId}\` in the pull request body\n5. After implementation, use verify_implementation to AI-grade your work against the spec\n6. If this change goes through a pull request, STOP there — the merge grades the real diff and moves the intent to Shipped. Do NOT call update_intent_status: an intent already at shipped is skipped by the merge, so an early flip replaces a diff-backed verdict with an unverified one\n7. Only if there will be no pull request, use update_intent_status to mark it "shipped"\n8. Use log_implementation_note to document key technical decisions`,
                     },
                 }],
         };
@@ -66383,6 +66905,8 @@ function startMcpServer() {
         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'),
         currentState: zod_1.z.string().optional().describe('How this works today, before the change — existing behavior and workarounds, so the implementation knows what must not regress. Omit for net-new capability.'),
+        implementationContext: zod_1.z.string().optional().describe('What the repo actually looks like where this change lands: the files and modules involved, what already exists, what it would touch, how to verify it. You are in the working tree — go read it. Markdown, sub-headings welcome. Advisory: it never changes the readiness verdict, it just stops the implementing agent from rediscovering the codebase.'),
+        productId: zod_1.z.string().optional().describe('Which product this intent belongs to (cloud mode only). Omit it and the server resolves it when the workspace has exactly one real product; if it cannot, the save fails with PRODUCT_REQUIRED and the candidate list, and you should ask the user which one and retry with an explicit id rather than guessing — a GitHub binding hangs off the product, so it decides which repository merge verification applies to.'),
         outcomes: zod_1.z.array(zod_1.z.string()).describe('Observable, testable state changes'),
         decisions: zod_1.z.array(zod_1.z.object({
             choice: zod_1.z.string(),
@@ -66422,6 +66946,21 @@ function startMcpServer() {
                 }],
         };
     });
+    /**
+     * Tool input → IntentFields.
+     *
+     * The tool parameter is called `implementationContext` because that is the section it becomes and
+     * the language the agent thinks in. IntentFields reserves that name for the cloud analyzer's
+     * STRUCTURED object, so the prose moves to `implementationContextText` on the way in. Keeping the
+     * split explicit here is what stops a string from reaching code that expects `.relevantAreas`.
+     */
+    function toIntentFields(spec) {
+        const { implementationContext, ...rest } = spec;
+        return {
+            ...rest,
+            ...(implementationContext?.trim() ? { implementationContextText: implementationContext } : {}),
+        };
+    }
     server.registerTool('check_intent_readiness', {
         title: 'Check Intent Readiness (Preflight)',
         description: 'Run the deterministic preflight on an intent spec before handing it to an implementation agent. Six calibrated checks — title, objective, outcomes, constraints, edge cases, verification — computed by pure functions: no model call, no network, the same spec always gets the same verdict. Pass a spec inline to check before saving, pass intentId to check a specific saved intent, or pass nothing to check the current intent. A failing verdict names the exact blockers; repair the fields and re-run. This is the gate that runs at preflight.pathmode.io.',
@@ -66473,7 +67012,7 @@ function startMcpServer() {
                 }],
         };
     });
-    server.tool('intent_save', 'Save an intent spec to intent.md in the project root. Called after building a spec through conversation. Re-saving the same intent bumps its version and preserves its status; it never silently replaces a different intent.', {
+    server.tool('intent_save', 'Save an intent spec to intent.md in the project root — the default choice when you are working inside a repository. With a Pathmode API key set it ALSO creates or updates the intent in the workspace and records the sync in the file, so the file is the projection of the record rather than a second copy of it. Re-saving the same intent bumps its version and preserves its status; it never silently replaces a different intent. Use create_intent instead when there is no repository to write into.', {
         spec: zod_1.z.object(intentSpecSchema),
         path: zod_1.z.string().optional().describe('File path relative to the project root. Must stay inside the project (absolute paths and ".." are rejected). Defaults to intent.md'),
         overwrite: zod_1.z.boolean().optional().describe('Replace the file even when it already holds a DIFFERENT intent. Default false — the save is refused instead, so an unrelated spec is never clobbered.'),
@@ -66484,7 +67023,7 @@ function startMcpServer() {
             existing,
             incomingId: spec.id,
             overwrite,
-            mintId: () => `intent_${Date.now()}`,
+            mintId: () => (0, crypto_1.randomUUID)(),
         });
         if (decision.action === 'refuse') {
             return {
@@ -66504,9 +67043,75 @@ function startMcpServer() {
         // The preflight verdict travels with the file: stamped into frontmatter on every save,
         // recomputed from the spec alone (deterministic). A failing verdict never blocks the
         // save — the gate reports, the user decides.
-        const verdict = (0, readiness_1.computeReadinessVerdict)(spec);
-        const content = (0, intent_compiler_1.formatIntentMd)({ ...spec, id }, { version, status, created, readiness: (0, readiness_1.formatReadinessFrontmatter)(verdict) });
-        (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+        const fields = toIntentFields(spec);
+        const verdict = (0, readiness_1.computeReadinessVerdict)(fields);
+        // The push and the file write are one ordered unit; see push-spec.ts for why the write
+        // cannot wait for the enrichment legs.
+        let canonicalId = id;
+        let specVersion;
+        let sourceUrl;
+        let didNotTravel = [];
+        const writeSpecFile = (opts) => {
+            const content = (0, intent_compiler_1.formatIntentMd)({ ...fields, id: opts.canonicalId }, {
+                version, status, created,
+                readiness: (0, readiness_1.formatReadinessFrontmatter)(verdict),
+                specVersion: opts.specVersion,
+                source: opts.sourceUrl,
+            });
+            (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+        };
+        if (isLocalMode) {
+            writeSpecFile({ canonicalId: id });
+        }
+        else {
+            const result = await (0, push_spec_1.pushSpec)({
+                client: requireCloudClient(),
+                id,
+                existingSpecVersion: existing?.specVersion,
+                payload: {
+                    title: spec.title,
+                    objective: spec.objective,
+                    ...(spec.currentState !== undefined ? { currentState: spec.currentState } : {}),
+                    outcomes: spec.outcomes,
+                    ...(spec.constraints ? { constraints: spec.constraints } : {}),
+                    ...(spec.healthMetrics ? { healthMetrics: spec.healthMetrics } : {}),
+                    ...(spec.edgeCases ? { edgeCases: spec.edgeCases } : {}),
+                    ...(spec.verification ? { verification: spec.verification } : {}),
+                    ...(spec.scope ? { scope: spec.scope } : {}),
+                    ...(spec.productId ? { productId: spec.productId } : {}),
+                },
+                decisions: spec.decisions,
+                implementationContext: spec.implementationContext,
+                onIdentitySettled: writeSpecFile,
+            });
+            if (!result.ok) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                `✗ Not saved. The workspace refused the spec, so ${filePath} was left alone.`,
+                                '',
+                                result.error,
+                                ...(result.code === 'PRODUCT_REQUIRED' && result.products?.length
+                                    ? [
+                                        '',
+                                        'Ask the user which product this belongs to, then call intent_save again with productId:',
+                                        ...result.products.map(p => `  - ${p.id}  ${p.name}${p.isExample ? '  (example product)' : ''}`),
+                                        'Do not guess: the product decides which repository merge verification applies to.',
+                                    ]
+                                    : []),
+                                '',
+                                'Writing the file anyway would leave it disagreeing with the record, invisibly.',
+                            ].join('\n'),
+                        }],
+                    isError: true,
+                };
+            }
+            canonicalId = result.canonicalId;
+            specVersion = result.specVersion;
+            sourceUrl = result.sourceUrl;
+            didNotTravel = result.didNotTravel;
+        }
         const action = decision.action === 'update' ? `Updated intent spec (v${version})` : 'Saved intent spec';
         const readinessNote = verdict.ready
             ? ''
@@ -66514,7 +67119,18 @@ function startMcpServer() {
         return {
             content: [{
                     type: 'text',
-                    text: `✓ ${action} at ${filePath}\n  id: ${id} · status: ${status} · readiness: ${(0, readiness_1.formatReadinessFrontmatter)(verdict)}${readinessNote}\n\nTo connect this to Pathmode for dependency tracking and team collaboration, visit pathmode.io`,
+                    text: [
+                        `✓ ${action} at ${filePath}`,
+                        `  id: ${canonicalId} · status: ${status} · readiness: ${(0, readiness_1.formatReadinessFrontmatter)(verdict)}`,
+                        ...(sourceUrl ? [`  synced to ${sourceUrl}`] : []),
+                        ...(didNotTravel.length
+                            ? ['', 'Saved, but these did NOT reach the workspace:', ...didNotTravel.map(x => `  - ${x}`)]
+                            : []),
+                        readinessNote,
+                        ...(isLocalMode
+                            ? ['', 'To connect this to Pathmode for dependency tracking and team collaboration, visit pathmode.io']
+                            : []),
+                    ].join('\n'),
                 }],
         };
     });
@@ -66523,8 +67139,9 @@ function startMcpServer() {
         spec: zod_1.z.object(intentSpecSchema),
         path: zod_1.z.string().optional().describe('Output file path relative to the project root. Must stay inside the project (absolute paths and ".." are rejected). Defaults to .cursorrules, CLAUDE.md, or AGENTS.md'),
     }, async ({ format, spec, path }) => {
+        const fields = toIntentFields(spec);
         if (format === 'cursorrules') {
-            const content = (0, intent_compiler_1.formatCursorRules)(spec);
+            const content = (0, intent_compiler_1.formatCursorRules)(fields);
             const filePath = resolveWithinProject(path || '.cursorrules');
             (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
             return {
@@ -66535,7 +67152,7 @@ function startMcpServer() {
             };
         }
         else if (format === 'outcome-rubric') {
-            const content = (0, intent_compiler_1.formatOutcomeRubric)(spec);
+            const content = (0, intent_compiler_1.formatOutcomeRubric)(fields);
             const filePath = resolveWithinProject(path || 'outcome-rubric.md');
             (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
             return {
@@ -66546,7 +67163,7 @@ function startMcpServer() {
             };
         }
         else {
-            const section = (0, intent_compiler_1.formatClaudeMdSection)(spec);
+            const section = (0, intent_compiler_1.formatClaudeMdSection)(fields);
             const defaultFile = format === 'agents-md' ? 'AGENTS.md' : 'CLAUDE.md';
             const filePath = resolveWithinProject(path || defaultFile);
             let existing = '';