@pathmode/mcp-server 1.14.1 → 1.15.1

package/dist/index.js

@@ -34140,6 +34140,8 @@ exports.formatIntentMd = formatIntentMd;
 exports.formatCursorRules = formatCursorRules;
 exports.formatClaudeMdSection = formatClaudeMdSection;
 exports.formatOutcomeRubric = formatOutcomeRubric;
+exports.spliceConfirmationsSection = spliceConfirmationsSection;
+exports.renderConfirmationsSection = renderConfirmationsSection;
 // 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);
@@ -34476,6 +34478,41 @@ function formatIntentMd(spec, opts = {}) {
                 sections.push(`- [ ] ${renderCheckLine(c)}`);
         }
     }
+    // `## Confirmations` is emitted LAST so it never sits between the fields a reader is
+    // comparing, and so appending one cannot shift any other section's parse. Derived fields
+    // (assurance, source) are NOT written: anything read from a file is local-unverified.
+    const rawConfirmations = spec.confirmations;
+    const confirmations = Array.isArray(rawConfirmations)
+        ? rawConfirmations
+        : [];
+    // Filter BEFORE emitting the heading: a spec whose only confirmation targets an
+    // unwaivable dimension must not leave an empty `## Confirmations` section behind.
+    const emittable = confirmations.filter((c) => {
+        const dim = String(c.dimension ?? '').toLowerCase();
+        const kind = String(c.kind ?? '').toLowerCase();
+        const by = String(c.by ?? '').toLowerCase();
+        return ['objective', 'outcomes'].includes(dim)
+            && ['confirmed', 'waived'].includes(kind)
+            && ['agent', 'human'].includes(by);
+    });
+    if (emittable.length) {
+        sections.push('');
+        sections.push('## Confirmations');
+        for (const c of emittable) {
+            const dim = String(c.dimension ?? '').toLowerCase();
+            const kind = String(c.kind ?? '').toLowerCase();
+            const by = String(c.by ?? '').toLowerCase();
+            sections.push('');
+            sections.push(`**${dim}** — ${kind} by ${by}`);
+            for (const key of ['actor', 'problem', 'outcome', 'observable', 'reason', 'anchor', 'at']) {
+                const v = c[key];
+                if (typeof v !== 'string' || !v.trim())
+                    continue;
+                // Values are single-line by contract; the writer flattens rather than escaping.
+                sections.push(`- ${key}: ${v.replace(/\s+/g, ' ').trim()}`);
+            }
+        }
+    }
     sections.push('');
     return sections.join('\n');
 }
@@ -34860,6 +34897,62 @@ function formatOutcomeRubric(spec, opts = {}) {
     doc.push('');
     return doc.join('\n');
 }
+/**
+ * Splice a `## Confirmations` section into an existing intent.md WITHOUT regenerating the file.
+ *
+ * Regenerating through formatIntentMd is lossy by construction: LocalIntent is a projection, so
+ * a round-trip drops unknown frontmatter keys, resets `version` and `status` to their defaults,
+ * restamps `created`, and deletes any section the reader has no field for. Measured on a real
+ * spec: status approved -> draft, version 7 -> 1, and `source`, `specVersion` and a `## Evidence`
+ * section gone. A tool that records a judgment must not destroy the document it judges.
+ *
+ * So this is a text operation. It replaces an existing `## Confirmations` section in place, or
+ * appends one at the end, and touches nothing else in the file.
+ */
+function spliceConfirmationsSection(original, section) {
+    const lines = original.split('\n');
+    const start = lines.findIndex(l => /^##\s+Confirmations\s*$/.test(l));
+    if (start === -1) {
+        const trimmed = original.replace(/\s*$/, '');
+        return `${trimmed}\n\n${section.trim()}\n`;
+    }
+    // Run to the next `##`/`#` heading, so a later section survives untouched.
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^#{1,2}\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, start).join('\n').replace(/\s*$/, '');
+    const after = lines.slice(end).join('\n').replace(/^\s*/, '');
+    return `${before}\n\n${section.trim()}\n${after ? `\n${after}` : ''}`;
+}
+/** Render confirmation records as the `## Confirmations` section body. */
+function renderConfirmationsSection(records) {
+    const emittable = records.filter((c) => {
+        const dim = String(c.dimension ?? '').toLowerCase();
+        const kind = String(c.kind ?? '').toLowerCase();
+        const by = String(c.by ?? '').toLowerCase();
+        return ['objective', 'outcomes'].includes(dim)
+            && ['confirmed', 'waived'].includes(kind)
+            && ['agent', 'human'].includes(by);
+    });
+    if (!emittable.length)
+        return '';
+    const out = ['## Confirmations'];
+    for (const c of emittable) {
+        out.push('');
+        out.push(`**${String(c.dimension).toLowerCase()}** — ${String(c.kind).toLowerCase()} by ${String(c.by).toLowerCase()}`);
+        for (const key of ['actor', 'problem', 'outcome', 'observable', 'reason', 'anchor', 'at']) {
+            const v = c[key];
+            if (typeof v !== 'string' || !v.trim())
+                continue;
+            out.push(`- ${key}: ${v.replace(/\s+/g, ' ').trim()}`);
+        }
+    }
+    return out.join('\n');
+}
 
 
 /***/ }),
@@ -34890,6 +34983,43 @@ exports.parseIntentMarkdown = parseIntentMarkdown;
 const fs_1 = __importDefault(__nccwpck_require__(9896));
 const path_1 = __importDefault(__nccwpck_require__(6928));
 const gray_matter_1 = __importDefault(__nccwpck_require__(9599));
+const CONFIRMATION_HEADER_RE = /^\*\*(objective|outcomes)\*\*\s*[—–-]\s*(confirmed|waived)\s+by\s+(agent|human)\s*$/i;
+const CONFIRMATION_FIELD_RE = /^\s*[-*]\s+(actor|problem|outcome|observable|reason|anchor|at)\s*:\s*(.+)$/i;
+/**
+ * Parse `## Confirmations` permissively; the gate validates.
+ *
+ * A block missing its anchor still parses and is reported by the gate as `malformed` or `stale`
+ * rather than vanishing here. Silent drops at parse time are what make "my confirmation did
+ * nothing" undebuggable, which is the precedent this deliberately does not copy.
+ *
+ * A value runs to end of line, so it may contain colons, dashes and quotes without escaping.
+ * A duplicate key inside one block is last-wins, matching splitSections' duplicate-heading rule.
+ * A line matching neither shape is ignored, so stray prose cannot open a block.
+ */
+function extractConfirmations(sections) {
+    const out = [];
+    let current = null;
+    for (const line of sections.get('Confirmations') ?? []) {
+        const header = line.trim().match(CONFIRMATION_HEADER_RE);
+        if (header) {
+            current = {
+                dimension: header[1].toLowerCase(),
+                kind: header[2].toLowerCase(),
+                by: header[3].toLowerCase(),
+                assurance: 'local-unverified',
+                source: 'file',
+            };
+            out.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        const field = line.match(CONFIRMATION_FIELD_RE);
+        if (field)
+            current[field[1].toLowerCase()] = field[2].trim();
+    }
+    return out;
+}
 const DECISIONS_HEADING = 'Decisions & Ruled-Out Alternatives';
 /**
  * Read all intent.md files from the current directory and subdirectories (1 level deep).
@@ -34956,13 +35086,65 @@ function readIntentFile(filePath) {
  * Exported so lib/intentMdParseParity.test.ts can hold the web paste-box parser
  * (lib/intentMdParse.ts) to this implementation's behavior on gate-relevant fields.
  */
+/**
+ * Sections win; frontmatter fills an absence. Mirrors lib/intentMdParse.preferSection.
+ *
+ * Local mode originally read only files that formatIntentMd wrote, which always carry body
+ * sections, so the fallback never fired and was omitted. The preflight CLI broke that
+ * assumption: it points this parser at hand-written files, including the frontmatter-only
+ * shape the /intentspec starter and `pathmode validate` both bless. Without the fallback the
+ * same CLI validated a spec's outcomes as schema-correct and then reported "nothing found"
+ * for them, which is the false "you wrote nothing" this codebase has spent a research cycle
+ * stamping out.
+ */
+function preferSection(fromSection, fromFrontmatter) {
+    if (fromSection.length > 0)
+        return fromSection;
+    if (!Array.isArray(fromFrontmatter))
+        return [];
+    return fromFrontmatter
+        .map((v) => (typeof v === 'string' ? v : coerceItemText(v)))
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+/** Coerce a structured frontmatter entry ({text}, {description}) to its text, else ''. */
+function coerceItemText(v) {
+    if (!v || typeof v !== 'object')
+        return '';
+    const o = v;
+    for (const key of ['text', 'description', 'title']) {
+        if (typeof o[key] === 'string')
+            return o[key];
+    }
+    return '';
+}
+/** Frontmatter edge cases in the schema's {scenario, expectedBehavior} shape. */
+function frontmatterEdgeCases(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v
+        .map((e) => {
+        const o = (e ?? {});
+        return {
+            scenario: typeof o.scenario === 'string' ? o.scenario.trim() : '',
+            expectedBehavior: typeof o.expectedBehavior === 'string' ? o.expectedBehavior.trim()
+                : typeof o.expected_behavior === 'string' ? o.expected_behavior.trim() : '',
+        };
+    })
+        .filter((e) => e.scenario || e.expectedBehavior);
+}
 function parseIntentMarkdown(content, fallbackId = 'intent') {
-    const { data, content: body } = (0, gray_matter_1.default)(content);
+    const { data, content: rawBody } = (0, gray_matter_1.default)(content);
+    const body = stripFencedBlocks(rawBody);
     const sections = splitSections(body);
     const parsedVerification = extractVerification(sections);
-    const frontmatterVerification = data.verification && typeof data.verification === 'object'
-        ? data.verification
-        : null;
+    // The public schema allows verification as a flat string array; read it as manual checks
+    // rather than silently producing {} (the same adapter normalizeSpecForReadiness applies).
+    const frontmatterVerification = Array.isArray(data.verification)
+        ? { manualChecks: data.verification.map(v => typeof v === 'string' ? v : coerceItemText(v)).filter(Boolean) }
+        : data.verification && typeof data.verification === 'object'
+            ? data.verification
+            : null;
     const verification = hasVerificationContent(parsedVerification)
         ? parsedVerification
         : (frontmatterVerification || {});
@@ -34977,13 +35159,14 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
         title: data.title || data.userGoal || extractTitle(body) || 'Untitled Intent',
         stageName: data.stage || undefined,
         severity: data.severity || undefined,
-        outcomes: extractListSection(sections, 'Outcomes'),
+        outcomes: preferSection(extractListSection(sections, 'Outcomes'), data.outcomes),
         decisions: extractDecisions(sections),
-        constraints: extractListSection(sections, 'Constraints'),
-        edgeCases: extractEdgeCases(sections),
-        healthMetrics: extractListSection(sections, 'Health Metrics'),
+        constraints: preferSection(extractListSection(sections, 'Constraints'), data.constraints),
+        edgeCases: (() => { const fromBody = extractEdgeCases(sections); return fromBody.length ? fromBody : frontmatterEdgeCases(data.edgeCases); })(),
+        healthMetrics: preferSection(extractListSection(sections, 'Health Metrics'), data.healthMetrics),
         scope: extractScope(sections) || undefined,
         verification,
+        confirmations: extractConfirmations(sections),
         source: 'local',
     };
 }
@@ -34995,6 +35178,46 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
  * wins. `###` is not a section boundary (`^##\s+` cannot match `### `), so sub-headings stay
  * inside their parent section.
  */
+/**
+ * Remove fenced code blocks before any structural parsing.
+ *
+ * A spec's fenced blocks are examples and payloads, never spec structure, but the
+ * section walker is line-based: a `## ` inside a fence opens a bogus section, and
+ * `isListItem` matches `^\s*[-*]\s`, so a C comment line (` * @brief ...`) or a YAML
+ * list inside a fence becomes an outcome. Measured in the wild: one OpenSpec change
+ * contributed 21 Doxygen `@brief` lines as "outcomes" and passed a gate a reviewer
+ * fails it on (docs/research/openspec-corpus-audit.md).
+ *
+ * Fenced content is DROPPED, not kept-and-ignored. Nothing downstream reads a fence as
+ * a check (verification takes list items only), so keeping it would only feed code
+ * noise to the lexical gates that read the prose fields.
+ *
+ * Indented (4-space) code blocks are deliberately NOT handled: they are
+ * indistinguishable from indented list continuations, and dropping those would lose
+ * real content. An unclosed fence swallows the rest of the document, which is what a
+ * markdown renderer does, so the parser reads what the author sees.
+ */
+function stripFencedBlocks(body) {
+    const out = [];
+    let fence = null;
+    for (const line of body.split('\n')) {
+        const marker = line.match(/^\s*(`{3,}|~{3,})/);
+        if (marker) {
+            const char = marker[1][0];
+            const len = marker[1].length;
+            if (!fence) {
+                fence = { char, len };
+                continue;
+            }
+            if (char === fence.char && len >= fence.len)
+                fence = null;
+            continue;
+        }
+        if (!fence)
+            out.push(line);
+    }
+    return out.join('\n');
+}
 function splitSections(body) {
     const sections = new Map();
     let current = null;
@@ -35506,6 +35729,8 @@ exports.isConstraintConcrete = isConstraintConcrete;
 exports.isVerificationCheckSubstantive = isVerificationCheckSubstantive;
 exports.isObjectiveSpecific = isObjectiveSpecific;
 exports.isOutcomeMeasurable = isOutcomeMeasurable;
+exports.normalizeAnchor = normalizeAnchor;
+exports.fieldDigest = fieldDigest;
 exports.computeReadinessVerdict = computeReadinessVerdict;
 exports.formatReadinessFrontmatter = formatReadinessFrontmatter;
 exports.formatReadinessVerdict = formatReadinessVerdict;
@@ -35624,6 +35849,122 @@ exports.READINESS_BLOCKER_DESCRIPTIONS = {
     verification: 'No concrete verification — describe at least one check specific enough to run.',
 };
 /** Display order for the gate strip (title first, matching the Preflight page). */
+// ── Confirmation anchoring ──────────────────────────────────────────────────
+/**
+ * Fold away everything that is a rewrite of the same claim, and nothing that is a change to it.
+ * NFC because one glyph has two encodings; soft hyphens because editors inject them invisibly;
+ * quote/dash folding and markdown emphasis because adding `**` around a word is formatting, not
+ * a reword. Lowercased and whitespace-collapsed last.
+ */
+function normalizeAnchor(value) {
+    return coerceText(value)
+        .normalize('NFC')
+        .replace(/­/g, '')
+        .replace(/[‘’ʼ]/g, "'")
+        .replace(/[“”]/g, '"')
+        .replace(/[–—]/g, '-')
+        .replace(/\*/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+/**
+ * 64-bit FNV-1a over the normalized field text, as 16 lowercase hex chars.
+ *
+ * NOT sha256, and deliberately not node:crypto. lib/intentReadiness.ts is imported by
+ * 'use client' components (PreflightVerdictDemo, SpecPanel, DraftWorkspace), so the app-side
+ * half of this parity pair runs in the browser, where node crypto does not exist and
+ * crypto.subtle is async while this gate is synchronous and pure. Do not "upgrade" this to
+ * sha256 without checking that constraint first.
+ *
+ * A weak hash is adequate because this is change detection, not a security boundary: anyone
+ * who can forge a confirmation can edit the digest beside it. Accidental collision over 64 bits
+ * is negligible, and a collision only means a confirmation outlives an edit it should not have.
+ */
+function fieldDigest(text) {
+    const s = normalizeAnchor(text);
+    let h = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    const mask = 0xffffffffffffffffn;
+    for (let i = 0; i < s.length; i++) {
+        h = (h ^ BigInt(s.charCodeAt(i))) * prime & mask;
+    }
+    return h.toString(16).padStart(16, '0');
+}
+/** Only these two are waivable or confirmable. goal and verification are unrepresentable here. */
+const CONFIRMABLE = ['objective', 'outcomes'];
+/**
+ * Apply confirmations to the dimensions the gate could not confirm lexically.
+ *
+ * Structural checks ONLY: the gate never reads the prose of `actor`, `problem` or `reason`, it
+ * only checks that they are present and that the anchor still matches the field it was made
+ * against. Interpreting them is the consumer's job, which is the whole point of the split.
+ *
+ * The uniform rule is `anchor === fieldDigest(current field text)`. It covers both kinds and
+ * both directions: editing a confirmed objective kills the confirmation, and filling in an
+ * objective that was waived as absent kills the waiver, because '' and the new text digest
+ * differently.
+ */
+function applyConfirmations(detail, digests, raw) {
+    const rejected = [];
+    for (const entry of asArray(raw)) {
+        const c = (entry ?? {});
+        const dim = coerceText(c.dimension).trim();
+        const kind = coerceText(c.kind).trim();
+        const by = coerceText(c.by).trim();
+        if (!CONFIRMABLE.includes(dim)) {
+            rejected.push({ code: 'unknown-dimension', dimension: dim || '(none)' });
+            continue;
+        }
+        const d = detail[dim];
+        if (kind === 'waived') {
+            // Amendment A: a waiver is a human decision. An agent may propose one; only a human
+            // may make it. Without this an agent's cheapest route to a green gate is one call.
+            if (by !== 'human') {
+                rejected.push({ code: 'waiver-requires-human', dimension: dim });
+                continue;
+            }
+            if (!coerceText(c.reason).trim()) {
+                rejected.push({ code: 'malformed', dimension: dim });
+                continue;
+            }
+        }
+        else if (kind === 'confirmed') {
+            const filled = dim === 'objective'
+                ? coerceText(c.actor).trim() && coerceText(c.problem).trim()
+                : coerceText(c.outcome).trim() && coerceText(c.observable).trim();
+            if (!filled) {
+                rejected.push({ code: 'malformed', dimension: dim });
+                continue;
+            }
+            // M3: there is no path from a blank spec to a pass. Absent is unconfirmable;
+            // waiving it is the honest move and stays available above.
+            if (d?.state === 'absent') {
+                rejected.push({ code: 'nothing-to-confirm', dimension: dim });
+                continue;
+            }
+        }
+        else {
+            rejected.push({ code: 'malformed', dimension: dim });
+            continue;
+        }
+        if (coerceText(c.anchor).trim() !== digests[dim]) {
+            rejected.push({ code: 'stale', dimension: dim });
+            continue;
+        }
+        if (d && d.state !== 'pass') {
+            d.state = kind === 'waived' ? 'not_applicable' : 'pass';
+            d.confirmedBy = by === 'human' ? 'human' : 'agent';
+            // Assurance is never taken from the record: a file cannot vouch for itself. Anything
+            // arriving without an authenticated boundary is local-unverified, and renders that way.
+            d.assurance = coerceText(c.assurance).trim() === 'authenticated'
+                ? 'authenticated' : 'local-unverified';
+            if (kind === 'waived')
+                d.reason = coerceText(c.reason).trim();
+        }
+    }
+    return rejected;
+}
 exports.READINESS_GATE_ORDER = ['goal', 'objective', 'outcomes', 'constraints', 'edgeCases', 'verification'];
 /** Blocker emission order — byte-identical to lib/intentReadiness computeReviewSignals. */
 const BLOCKER_ORDER = ['objective', 'goal', 'outcomes', 'constraints', 'edgeCases', 'verification'];
@@ -35669,7 +36010,41 @@ function computeReadinessVerdict(spec) {
     const failingBlockers = BLOCKER_ORDER
         .filter(k => !signals[k])
         .map(k => exports.READINESS_BLOCKER_DESCRIPTIONS[k]);
-    return { ready: failingBlockers.length === 0, signals, failingBlockers };
+    // What the reader read, per dimension, independent of whether the heuristic accepted it.
+    // Placeholder text is deliberately not extracted: no path from a blank spec to confirmable.
+    const objectiveText = coerceText(spec.objective).trim();
+    const titleText = coerceText(spec.title).trim();
+    const extractedBy = {
+        goal: isLikelyPlaceholderText(titleText) ? '' : titleText,
+        objective: isLikelyPlaceholderText(objectiveText) ? '' : objectiveText,
+        outcomes: nonEmptyOutcomes.join('; '),
+        constraints: asArray(spec.constraints).map(c => coerceText(c).trim()).filter(Boolean).join('; '),
+        edgeCases: asArray(spec.edgeCases)
+            .map((ec) => coerceText(ec?.scenario).trim())
+            .filter(Boolean).join('; '),
+        verification: verificationDescriptions(spec.verification).join('; '),
+    };
+    const detail = {};
+    for (const key of exports.READINESS_GATE_ORDER) {
+        const text = extractedBy[key] ?? '';
+        detail[key] = signals[key]
+            ? { state: 'pass', ...(text ? { extracted: text } : {}) }
+            : text
+                ? { state: 'unconfirmed', extracted: text }
+                : { state: 'absent' };
+    }
+    // Confirmations only ever move a dimension the heuristics already failed; `signals` is never
+    // mutated, so the lexical verdict stays visible underneath.
+    const anchorDigests = {
+        objective: fieldDigest(extractedBy.objective),
+        outcomes: fieldDigest(extractedBy.outcomes),
+    };
+    const rejectedConfirmations = applyConfirmations(detail, anchorDigests, spec.confirmations);
+    const confirmedReady = exports.READINESS_GATE_ORDER.every(k => signals[k] || detail[k]?.state === 'pass' || detail[k]?.state === 'not_applicable');
+    return {
+        ready: failingBlockers.length === 0,
+        signals, failingBlockers, detail, rejectedConfirmations, confirmedReady,
+    };
 }
 const GATE_LABELS = {
     goal: 'Title',
@@ -35696,29 +36071,100 @@ const FRONTMATTER_GATE_LABELS = {
  */
 function formatReadinessFrontmatter(verdict) {
     const total = exports.READINESS_GATE_ORDER.length;
-    const passed = exports.READINESS_GATE_ORDER.filter((k) => verdict.signals[k]).length;
-    if (verdict.ready)
-        return `passed ${passed}/${total}`;
-    const blocking = exports.READINESS_GATE_ORDER.filter((k) => !verdict.signals[k]).map((k) => FRONTMATTER_GATE_LABELS[k]);
-    return `failed ${passed}/${total} — blocking: ${blocking.join(', ')}`;
+    // A confirmed dimension counts as passed; a WAIVED one never does (contract amendment D:
+    // "passed 6/6 (1 waived)" launders an exception into the score). Waivers are counted
+    // separately and named, and a spec with both product dimensions waived is not scored at all.
+    const passed = exports.READINESS_GATE_ORDER.filter((k) => verdict.detail?.[k]?.state === 'pass' || verdict.signals[k]).length;
+    const waived = exports.READINESS_GATE_ORDER.filter((k) => verdict.detail?.[k]?.state === 'not_applicable');
+    const blocking = exports.READINESS_GATE_ORDER.filter((k) => !verdict.signals[k] && verdict.detail?.[k]?.state !== 'pass' && verdict.detail?.[k]?.state !== 'not_applicable').map((k) => FRONTMATTER_GATE_LABELS[k]);
+    if (blocking.length)
+        return `failed ${passed}/${total} — blocking: ${blocking.join(', ')}`;
+    if (waived.length === 2)
+        return 'product intent preflight not applicable to this change';
+    if (waived.length)
+        return `ready with exceptions: ${passed} passed, ${waived.length} waived (${waived.map(k => FRONTMATTER_GATE_LABELS[k]).join(', ')})`;
+    return `passed ${passed}/${total}`;
+}
+/**
+ * The extra line an `unconfirmed` dimension earns: what was read, and an honest statement of
+ * what the check could not find in it.
+ *
+ * Only objective and outcomes appear here, and that scoping is the finding, not caution. The
+ * audit measured that most failures on those two are false negatives from a fixed English
+ * vocabulary. Verification's measured misses were all extraction failures, so quoting text
+ * back there would imply a confidence the evidence does not support.
+ */
+const UNCONFIRMED_HINT = {
+    objective: 'Read this, but could not confirm an affected actor and a concrete problem in it. If it already names them, this check reads a fixed vocabulary and may be missing valid phrasing:',
+    outcomes: 'Read these, but could not confirm an observable threshold in enough of them. If they are already observable, this check reads a fixed vocabulary and may be missing valid phrasing:',
+};
+/** Keep a quoted extraction to one readable line; the full text is in verdict.detail. */
+function truncateForQuote(text, max = 160) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
 }
 /** Human/agent-readable verdict block, stable enough to parse by line prefix. */
-function formatReadinessVerdict(verdict, specTitle) {
+function formatReadinessVerdict(verdict, specTitle, 
+/** Override the closing repair line. The default names MCP tools, which are wrong in a CLI
+ *  reading a repo that has never installed Pathmode. */
+repairHint) {
     const lines = [];
     const name = (specTitle || '').trim();
-    if (verdict.ready) {
-        lines.push(`✓ Preflight passed${name ? ` for "${name}"` : ''}. 6/6 checks. Ready to hand to an agent.`);
+    // The RESOLVED state is what a reader acts on: `ready`/`signals` stay the pure lexical
+    // verdict underneath, so what a spec earned stays distinguishable from what was vouched for,
+    // but a confirmed dimension must stop being reported as a blocker or the whole confirmation
+    // loop is invisible.
+    const resolved = (k) => verdict.detail?.[k]?.state ?? (verdict.signals[k] ? 'pass' : 'absent');
+    const stillBlocking = BLOCKER_ORDER.filter(k => !verdict.signals[k] && resolved(k) !== 'pass' && resolved(k) !== 'not_applicable');
+    const waivedKeys = BLOCKER_ORDER.filter(k => resolved(k) === 'not_applicable');
+    const vouched = BLOCKER_ORDER.filter(k => !verdict.signals[k] && resolved(k) === 'pass');
+    if (!stillBlocking.length) {
+        if (waivedKeys.length === 2) {
+            lines.push(`– Product intent preflight not applicable to this change${name ? ` ("${name}")` : ''}.`);
+        }
+        else if (waivedKeys.length) {
+            lines.push(`✓ Ready with exceptions${name ? ` for "${name}"` : ''}. ${6 - waivedKeys.length} passed, ${waivedKeys.length} waived.`);
+        }
+        else {
+            lines.push(`✓ Preflight passed${name ? ` for "${name}"` : ''}. 6/6 checks. Ready to hand to an agent.`);
+        }
+        for (const k of vouched) {
+            const d = verdict.detail?.[k];
+            const who = d?.confirmedBy ?? 'agent';
+            lines.push(`  ✓ ${GATE_LABELS[k]} confirmed by ${who}${who === 'human' && d?.assurance !== 'authenticated' ? ' (unverified)' : ''}, not by the check`);
+        }
+        for (const k of waivedKeys) {
+            const d = verdict.detail?.[k];
+            const who = d?.confirmedBy ?? 'human';
+            lines.push(`  – ${GATE_LABELS[k]} waived by ${who}${who === 'human' && d?.assurance !== 'authenticated' ? ' (unverified)' : ''}: ${d?.reason || 'no reason recorded'}`);
+        }
     }
     else {
-        lines.push(`✗ Preflight failed${name ? ` for "${name}"` : ''}. ${verdict.failingBlockers.length}/6 checks blocking.`);
-        for (const b of verdict.failingBlockers)
-            lines.push(`  ✗ ${b}`);
+        lines.push(`✗ Preflight failed${name ? ` for "${name}"` : ''}. ${stillBlocking.length}/6 checks blocking.`);
+        // Blocker lines stay byte-identical and in order; an unconfirmed dimension gets an
+        // extra indented line quoting what was actually read. Without it the verdict says
+        // "name the actor" to an author who named one in words this vocabulary misses, which
+        // an audit of 80 real specs measured as the majority of these failures
+        // (docs/research/openspec-corpus-audit.md).
+        for (const key of BLOCKER_ORDER) {
+            if (verdict.signals[key] || resolved(key) === 'pass' || resolved(key) === 'not_applicable')
+                continue;
+            lines.push(`  ✗ ${exports.READINESS_BLOCKER_DESCRIPTIONS[key]}`);
+            const d = verdict.detail?.[key];
+            if (d?.state === 'unconfirmed' && d.extracted && UNCONFIRMED_HINT[key]) {
+                lines.push(`    ↳ ${UNCONFIRMED_HINT[key]}`);
+                lines.push(`      "${truncateForQuote(d.extracted)}"`);
+            }
+        }
     }
     lines.push('');
-    lines.push(exports.READINESS_GATE_ORDER.map(k => `${verdict.signals[k] ? '✓' : '·'} ${GATE_LABELS[k]}`).join('  '));
-    if (!verdict.ready) {
+    lines.push(exports.READINESS_GATE_ORDER.map(k => {
+        const st = resolved(k);
+        return `${st === 'pass' ? '✓' : st === 'not_applicable' ? '–' : st === 'unconfirmed' ? '?' : '·'} ${GATE_LABELS[k]}`;
+    }).join('  '));
+    if (stillBlocking.length) {
         lines.push('');
-        lines.push('Repair the failing fields (ask the user one targeted question per blocker), save with intent_save, and re-run check_intent_readiness. The verdict is deterministic: the same spec always gets the same result.');
+        lines.push(repairHint ?? 'Repair the failing fields (ask the user one targeted question per blocker), save with intent_save, and re-run check_intent_readiness. The verdict is deterministic: the same spec always gets the same result.');
     }
     return lines.join('\n');
 }
@@ -65652,7 +66098,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.14.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.15.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"}}');
 
 /***/ })
 
@@ -67070,12 +67516,23 @@ function startMcpServer() {
         let sourceUrl;
         let didNotTravel = [];
         const writeSpecFile = (opts) => {
-            const content = (0, intent_compiler_1.formatIntentMd)({ ...fields, id: opts.canonicalId }, {
+            let 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,
             });
+            // Carry existing confirmations across the rewrite. intent_save builds its content from
+            // the incoming spec, which by design has no `confirmations` field (that absence is what
+            // enforces M1: a confirmation cannot be minted in the write that authored the field).
+            // Without this the very next save silently deletes every confirmation the file holds,
+            // and the anchors would have caught nothing because the records would be gone.
+            // Confirmations are re-validated on read, so a save that changed the field text simply
+            // leaves them stale rather than wrongly live.
+            const prior = (0, fs_1.existsSync)(filePath) ? (0, local_reader_1.readIntentFile)(filePath)?.confirmations ?? [] : [];
+            if (prior.length) {
+                content = (0, intent_compiler_1.spliceConfirmationsSection)(content, (0, intent_compiler_1.renderConfirmationsSection)(prior));
+            }
             (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
         };
         if (isLocalMode) {
@@ -67152,6 +67609,98 @@ function startMcpServer() {
                 }],
         };
     });
+    /**
+     * Confirm or waive a readiness dimension the deterministic gate could not confirm on its own.
+     *
+     * M1 (a confirmation must not be minted in the write that authored the field) is enforced by the
+     * TOOL BOUNDARY, not by tracking state: `intent_save` has no `confirmations` parameter, so the
+     * only way a confirmation exists is a separate call against a file a previous write produced.
+     * Keep it that way. Adding confirmations to intent_save would let an agent author a field and
+     * vouch for it in one breath, which is the rubber stamp this whole mechanism exists to price.
+     *
+     * The tool stamps `by: agent` for a confirmation and never accepts a `by` parameter. A waiver is
+     * a human decision (contract amendment A) and requires `humanApproved`, which the agent may only
+     * set after the user has actually said so. That is forgeable, and so is every other byte of a
+     * local file; what it buys is that the shortcut is not an official one-call path to a green gate.
+     */
+    server.registerTool('confirm_intent_dimension', {
+        title: 'Confirm or waive a readiness dimension',
+        description: 'Resolve an "unconfirmed" readiness dimension in a local intent.md. Use this when check_intent_readiness reports that it READ your objective or outcomes but could not confirm them: the gate matches a fixed English vocabulary and misses valid phrasing, including other languages. ' +
+            'confirm: state who is affected and what goes wrong for them, in your own words, and the dimension passes. ' +
+            'waive: mark the dimension as not applicable to this change (a pure refactor has no product outcome). A waiver is a HUMAN decision, so set humanApproved only after the user has explicitly agreed. ' +
+            'The confirmation is bound to the exact text it was made against and dies automatically if that text is edited. You cannot confirm a dimension the gate read nothing for; write the field first, save, then confirm.',
+        inputSchema: {
+            dimension: zod_1.z.enum(['objective', 'outcomes']).describe('Only these two are confirmable. Title and verification are never waivable.'),
+            action: zod_1.z.enum(['confirm', 'waive']).describe('confirm: vouch that the text names what the gate could not find. waive: this dimension does not apply to this change.'),
+            actor: zod_1.z.string().optional().describe('confirm + objective: who is affected, in your words.'),
+            problem: zod_1.z.string().optional().describe('confirm + objective: what goes wrong for them today.'),
+            outcome: zod_1.z.string().optional().describe('confirm + outcomes: the observable change.'),
+            observable: zod_1.z.string().optional().describe('confirm + outcomes: how you would see it.'),
+            reason: zod_1.z.string().optional().describe('waive: why this dimension does not apply.'),
+            humanApproved: zod_1.z.boolean().optional().describe('waive only. Set ONLY after the user has explicitly approved the waiver. Recorded as a human decision that this environment cannot verify.'),
+            path: zod_1.z.string().optional().describe('Path to the intent file. Defaults to intent.md.'),
+        },
+    }, async ({ dimension, action, actor, problem, outcome, observable, reason, humanApproved, path }) => {
+        const filePath = resolveWithinProject(path || 'intent.md');
+        const existing = (0, local_reader_1.readIntentFile)(filePath);
+        if (!existing) {
+            return { content: [{ type: 'text', text: `✗ No intent file at ${filePath}. Save one with intent_save first, then confirm.` }] };
+        }
+        const verdict = (0, readiness_1.computeReadinessVerdict)({ ...existing, confirmations: existing.confirmations });
+        const state = verdict.detail[dimension]?.state;
+        if (state === 'pass') {
+            return { content: [{ type: 'text', text: `· ${dimension} already passes on its own. Nothing to confirm.` }] };
+        }
+        if (action === 'confirm' && state === 'absent') {
+            return { content: [{ type: 'text', text: `✗ Cannot confirm ${dimension}: the reader found nothing there. Write the field, save with intent_save, then confirm. If it genuinely does not apply to this change, waive it instead.` }] };
+        }
+        if (action === 'waive' && !humanApproved) {
+            return { content: [{ type: 'text', text: `✗ A waiver is a human decision. Ask the user whether ${dimension} genuinely does not apply to this change, and call again with humanApproved once they have said so.` }] };
+        }
+        if (action === 'confirm') {
+            const missing = dimension === 'objective'
+                ? (!actor?.trim() || !problem?.trim()) && 'actor and problem'
+                : (!outcome?.trim() || !observable?.trim()) && 'outcome and observable';
+            if (missing)
+                return { content: [{ type: 'text', text: `✗ A confirmation must name the ${missing}. A bare yes is not a confirmation.` }] };
+        }
+        if (action === 'waive' && !reason?.trim()) {
+            return { content: [{ type: 'text', text: '✗ A waiver must carry a reason.' }] };
+        }
+        // Anchor to exactly what the gate read for this dimension, so an edit invalidates it.
+        const anchor = (0, readiness_1.fieldDigest)(verdict.detail[dimension]?.extracted ?? '');
+        const record = action === 'waive'
+            ? { dimension, kind: 'waived', by: 'human', reason: reason.trim(), anchor }
+            : {
+                dimension, kind: 'confirmed', by: 'agent', anchor,
+                ...(dimension === 'objective'
+                    ? { actor: actor.trim(), problem: problem.trim() }
+                    : { outcome: outcome.trim(), observable: observable.trim() }),
+            };
+        // One live record per dimension: a re-confirmation replaces rather than accumulates.
+        const kept = existing.confirmations.filter(c => c.dimension !== dimension);
+        const next = [...kept, record];
+        // SPLICE, never regenerate. formatIntentMd round-trips through a lossy projection: it
+        // would reset version and status to defaults, restamp created, and delete unknown
+        // frontmatter keys and any section the reader has no field for. Recording a judgment
+        // must not damage the document being judged.
+        const original = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        const content = (0, intent_compiler_1.spliceConfirmationsSection)(original, (0, intent_compiler_1.renderConfirmationsSection)(next));
+        (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
+        const after = (0, readiness_1.computeReadinessVerdict)({ ...existing, confirmations: [...kept, record] });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✓ ${dimension} ${action === 'waive' ? 'waived' : 'confirmed'} in ${filePath}`,
+                        `  ${after.detail[dimension]?.state === 'not_applicable' ? 'not applicable to this change' : 'confirmed against the current text'} · anchor ${anchor}`,
+                        action === 'waive' ? '  Recorded as a human decision this environment cannot verify.' : '',
+                        '',
+                        (0, readiness_1.formatReadinessVerdict)(after),
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
     server.tool('intent_export', 'Export an intent spec as .cursorrules, a CLAUDE.md or AGENTS.md section, or a Claude Managed Agents Outcomes rubric for AI agent consumption. Use agents-md for Codex, Cursor, and other AGENTS.md-aware agents.', {
         format: zod_1.z.enum(['cursorrules', 'claude-md', 'agents-md', 'outcome-rubric']).describe('Export format'),
         spec: zod_1.z.object(intentSpecSchema),

package/dist/intent-compiler.d.ts

@@ -137,3 +137,18 @@ export interface OutcomeRubricOptions {
  * Docs: https://platform.claude.com/docs/en/managed-agents/define-outcomes
  */
 export declare function formatOutcomeRubric(spec: IntentFields, opts?: OutcomeRubricOptions): string;
+/**
+ * Splice a `## Confirmations` section into an existing intent.md WITHOUT regenerating the file.
+ *
+ * Regenerating through formatIntentMd is lossy by construction: LocalIntent is a projection, so
+ * a round-trip drops unknown frontmatter keys, resets `version` and `status` to their defaults,
+ * restamps `created`, and deletes any section the reader has no field for. Measured on a real
+ * spec: status approved -> draft, version 7 -> 1, and `source`, `specVersion` and a `## Evidence`
+ * section gone. A tool that records a judgment must not destroy the document it judges.
+ *
+ * So this is a text operation. It replaces an existing `## Confirmations` section in place, or
+ * appends one at the end, and touches nothing else in the file.
+ */
+export declare function spliceConfirmationsSection(original: string, section: string): string;
+/** Render confirmation records as the `## Confirmations` section body. */
+export declare function renderConfirmationsSection(records: Record<string, unknown>[]): string;

package/dist/intent-compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/intent-compiler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/intent-compiler.ts"],"names":[],"mappings":"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"}

package/dist/local-reader.d.ts

@@ -28,6 +28,28 @@ export interface LocalVerification {
     unitTests?: string[];
     e2eTests?: string[];
 }
+/**
+ * A confirmation or waiver as it sits in `## Confirmations`.
+ *
+ * `assurance` and `source` are DERIVED, never written in the file: anything read out of a local
+ * file is `local-unverified` from `file`, whatever the `by` line claims. A hand-edited block
+ * asserting `by: human` is still a human claim we cannot check, and every surface must render it
+ * as such (contract amendments C and M4).
+ */
+export interface LocalConfirmation {
+    dimension: string;
+    kind: string;
+    by: string;
+    assurance: 'local-unverified';
+    source: 'file';
+    actor?: string;
+    problem?: string;
+    outcome?: string;
+    observable?: string;
+    reason?: string;
+    anchor?: string;
+    at?: string;
+}
 export interface LocalIntent {
     id: string;
     status: string;
@@ -55,6 +77,8 @@ export interface LocalIntent {
         outOfScope?: string[];
     };
     verification: LocalVerification;
+    /** From `## Confirmations`; validated by the readiness gate, not here. */
+    confirmations: LocalConfirmation[];
     source: 'local';
 }
 /** Frontmatter identity of an existing intent.md, for non-destructive saves. */
@@ -81,9 +105,4 @@ export declare function readIntentMeta(filePath: string): LocalIntentMeta | null
  * Parse a single intent.md file with YAML frontmatter.
  */
 export declare function readIntentFile(filePath: string): LocalIntent | null;
-/**
- * Parse intent.md content (frontmatter + body) into a LocalIntent. Pure: no fs, no cwd.
- * Exported so lib/intentMdParseParity.test.ts can hold the web paste-box parser
- * (lib/intentMdParse.ts) to this implementation's behavior on gate-relevant fields.
- */
 export declare function parseIntentMarkdown(content: string, fallbackId?: string): LocalIntent;

package/dist/local-reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/local-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,QAAQ,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAE1G,MAAM,WAAW,sBAAsB;IACnC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wGAAwG;AACxG,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAC9B,MAAM,CAAC,EAAE,sBAAsB,EAAE,CAAC;IAClC,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;iDAE6C;IAC7C,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5D,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACtD,YAAY,EAAE,iBAAiB,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;6EACyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAmBhD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAevE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAUnE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,SAAW,GAAG,WAAW,CAiCvF"}
+{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/local-reader.ts"],"names":[],"mappings":"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"}

package/dist/readiness.d.ts

@@ -21,6 +21,44 @@ export declare function isObjectiveSpecific(objective: string | null | undefined
 export declare function isOutcomeMeasurable(text: string): boolean;
 export declare const READINESS_BLOCKER_DESCRIPTIONS: Record<string, string>;
 /** Display order for the gate strip (title first, matching the Preflight page). */
+/**
+ * Fold away everything that is a rewrite of the same claim, and nothing that is a change to it.
+ * NFC because one glyph has two encodings; soft hyphens because editors inject them invisibly;
+ * quote/dash folding and markdown emphasis because adding `**` around a word is formatting, not
+ * a reword. Lowercased and whitespace-collapsed last.
+ */
+export declare function normalizeAnchor(value: unknown): string;
+/**
+ * 64-bit FNV-1a over the normalized field text, as 16 lowercase hex chars.
+ *
+ * NOT sha256, and deliberately not node:crypto. lib/intentReadiness.ts is imported by
+ * 'use client' components (PreflightVerdictDemo, SpecPanel, DraftWorkspace), so the app-side
+ * half of this parity pair runs in the browser, where node crypto does not exist and
+ * crypto.subtle is async while this gate is synchronous and pure. Do not "upgrade" this to
+ * sha256 without checking that constraint first.
+ *
+ * A weak hash is adequate because this is change detection, not a security boundary: anyone
+ * who can forge a confirmation can edit the digest beside it. Accidental collision over 64 bits
+ * is negligible, and a collision only means a confirmation outlives an edit it should not have.
+ */
+export declare function fieldDigest(text: unknown): string;
+/** A confirmation or waiver as it arrives, before any structural validation. */
+export interface ConfirmationRecord {
+    dimension?: unknown;
+    kind?: unknown;
+    by?: unknown;
+    anchor?: unknown;
+    actor?: unknown;
+    problem?: unknown;
+    outcome?: unknown;
+    observable?: unknown;
+    reason?: unknown;
+}
+export interface RejectedConfirmation {
+    /** Stable machine code; nothing is ever dropped silently. */
+    code: 'unknown-dimension' | 'malformed' | 'stale' | 'waiver-requires-human' | 'nothing-to-confirm';
+    dimension: string;
+}
 export declare const READINESS_GATE_ORDER: readonly ["goal", "objective", "outcomes", "constraints", "edgeCases", "verification"];
 /** Loose spec shape: covers LocalIntent, cloud intent JSON, and hand-built specs. */
 export interface ReadinessSpecInput {
@@ -30,11 +68,43 @@ export interface ReadinessSpecInput {
     constraints?: unknown;
     edgeCases?: unknown;
     verification?: unknown;
+    /** Confirmations and waivers; see docs/READINESS_CONFIRMATION_CONTRACT.md. */
+    confirmations?: unknown;
+}
+/**
+ * Why a dimension is not passing, which is not the same question as whether it passes.
+ * MIRROR of DimensionState in lib/intentReadiness.ts; see that file for the full rationale.
+ *
+ * `absent` means nothing substantive was extracted and the blocker copy is fair.
+ * `unconfirmed` means text WAS extracted and the lexical test rejected it, which on real
+ * in-the-wild specs is usually OUR error: an audit of 80 changes found ~80% of objective
+ * failures and ~94% of outcome failures are false negatives, most of them extracted
+ * correctly and then discarded by the word lists (docs/research/openspec-corpus-audit.md).
+ */
+export type DimensionState = 'pass' | 'unconfirmed' | 'absent' | 'not_applicable';
+export interface DimensionDetail {
+    state: DimensionState;
+    /** What the reader actually read for this dimension, for quoting back. */
+    extracted?: string;
+    /** Set when a confirmation or waiver moved this dimension: who vouched, and how well we know it. */
+    confirmedBy?: 'agent' | 'human';
+    assurance?: 'authenticated' | 'local-unverified';
+    /** The waiver's stated reason, for rendering the exception rather than hiding it. */
+    reason?: string;
 }
 export interface ReadinessVerdict {
     ready: boolean;
     signals: Record<string, boolean>;
     failingBlockers: string[];
+    /** Additive: failingBlockers stays byte-identical, richer messaging is opt-in. */
+    detail: Record<string, DimensionDetail>;
+    /** Confirmations that did not apply, with a reason. Nothing is ever dropped silently. */
+    rejectedConfirmations: RejectedConfirmation[];
+    /**
+     * Ready once confirmations and waivers are counted. `ready` stays the pure lexical verdict
+     * so a surface can distinguish what was earned from what was vouched for.
+     */
+    confirmedReady: boolean;
 }
 /**
  * The preflight: six deterministic gates over an intent spec. Mirrors
@@ -50,4 +120,7 @@ export declare function computeReadinessVerdict(spec: ReadinessSpecInput): Readi
  */
 export declare function formatReadinessFrontmatter(verdict: ReadinessVerdict): string;
 /** Human/agent-readable verdict block, stable enough to parse by line prefix. */
-export declare function formatReadinessVerdict(verdict: ReadinessVerdict, specTitle?: string): string;
+export declare function formatReadinessVerdict(verdict: ReadinessVerdict, specTitle?: string, 
+/** Override the closing repair line. The default names MCP tools, which are wrong in a CLI
+ *  reading a repo that has never installed Pathmode. */
+repairHint?: string): string;

package/dist/readiness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/readiness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQjD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,EAAE,CAIjE;AAoCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAQ3E;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI5D;AAED,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAI9F;AAQD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAOjF;AAQD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD;AAID,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOjE,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,wFAAyF,CAAC;AAK3H,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC7B;AAoBD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,gBAAgB,CAkBlF;AAqBD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAM5E;AAED,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB5F"}
+{"version":3,"file":"","sourceRoot":"","sources":["file:///Users/jannelammi/code/Pathmode/packages/mcp-server/src/readiness.ts"],"names":[],"mappings":"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"}

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "pathmode",
   "display_name": "Pathmode",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "description": "Deterministic preflight for the intent you hand to a coding agent: six calibrated gates, the exact blockers named, no model call, no key needed.",
   "long_description": "Pathmode MCP Server runs a deterministic preflight before your coding agent builds: check_intent_readiness scores an intent spec against six calibrated gates (title, objective, outcomes, constraints, edge cases, verification) and names the exact blockers, with no model call and no account. Keyless local mode works out of the box; specs live in intent.md in your repo, plain markdown you own, and skills for drafting, pressure-testing, and handing off intent ride along. Connect a Pathmode workspace with an API key to sync intent and evidence across a team, analyze dependency graphs, and verify pull requests against the outcomes you agreed to.",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pathmode/mcp-server",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "publishConfig": {
     "access": "public"
   },