@pathmode/mcp-server 1.15.1 → 1.16.1

package/dist/index.js

@@ -34135,6 +34135,7 @@ async function runInstallSkills() {
  * the personality prompt and file format generators. No AI API calls happen here.
  */
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.toVerificationChecks = toVerificationChecks;
 exports.getCompileIntentPrompt = getCompileIntentPrompt;
 exports.formatIntentMd = formatIntentMd;
 exports.formatCursorRules = formatCursorRules;
@@ -34142,6 +34143,7 @@ exports.formatClaudeMdSection = formatClaudeMdSection;
 exports.formatOutcomeRubric = formatOutcomeRubric;
 exports.spliceConfirmationsSection = spliceConfirmationsSection;
 exports.renderConfirmationsSection = renderConfirmationsSection;
+exports.writeConfirmationRecord = writeConfirmationRecord;
 // 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);
@@ -34953,6 +34955,31 @@ function renderConfirmationsSection(records) {
     }
     return out.join('\n');
 }
+function writeConfirmationRecord(opts) {
+    let raw = opts.read();
+    for (let attempt = 0; attempt < 2; attempt++) {
+        if ((raw.match(/^##[ \t]+Confirmations[ \t]*$/gm) ?? []).length > 1) {
+            return { ok: false, code: 'DUPLICATE_SECTION' };
+        }
+        if (opts.anchorOf(raw) !== opts.anchor) {
+            return { ok: false, code: 'FIELD_CHANGED' };
+        }
+        // One live record per dimension: a re-confirmation replaces rather than accumulates.
+        // Rebuilt from the SAME bytes being spliced. The defect was building this list from a
+        // parse taken earlier and splicing it into freshly-read bytes, so a record written in
+        // between was deleted by whoever wrote second.
+        const kept = opts.confirmationsOf(raw).filter(c => c.dimension !== opts.dimension);
+        const content = spliceConfirmationsSection(raw, renderConfirmationsSection([...kept, opts.record]));
+        const fresh = opts.read();
+        if (fresh !== raw) {
+            raw = fresh;
+            continue;
+        }
+        opts.write(content);
+        return { ok: true, kept };
+    }
+    return { ok: false, code: 'FILE_CHANGED' };
+}
 
 
 /***/ }),
@@ -35542,6 +35569,511 @@ function outcomeSelectorError(input) {
 }
 
 
+/***/ }),
+
+/***/ 8388:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * OpenSpec change -> IntentFields: the import half of the bridge whose emit half is
+ * openspec-writer.ts.
+ *
+ * This exists for the OpenSpec-first user, who arrives with changes already written. Without it,
+ * signing up means re-typing judgment that already exists in their repo — the exact activation
+ * wall for the persona the acquisition story is aimed at. With it, adopting a change is one tool
+ * call, and the text is DETERMINISTICALLY EXTRACTED — never paraphrased by a model. That is a
+ * weaker claim than byte-verbatim and deliberately so: the reader strips markdown structure and
+ * HTML comments, and joins multi-line prose. What it never does is reword. The distinction that
+ * matters is the digest: normalizeAnchor collapses whitespace, so the extracted text hashes to
+ * the same digest as the author's, and a confirmation made after import survives exactly as long
+ * as the imported claim does.
+ *
+ * The projection is openSpecChangeToSpec — the SAME reader the preflight grades with, so an
+ * imported intent's verdict matches the preflight verdict of the change it came from on FIVE of
+ * six gates. `goal` is the exception, by design: see the title note below. Pinned in
+ * openspec-import.test.ts rather than asserted here.
+ *
+ * The one place import deliberately reads MORE than the grading projection: the title. The
+ * reader derives title from the directory name (hyphens to spaces), because as an instrument it
+ * must not reward pretty H1s — the corpus numbers depend on it staying frozen. An import is not a
+ * measurement: if proposal.md opens with an H1, that is the author's own name for the change and
+ * the intent should carry it. The grading projection is NOT changed for this; recalibrating the
+ * corpus over a title heuristic would contaminate recorded numbers for zero judgment value.
+ *
+ * That is where the `goal` gate can diverge, and the divergence is reachable rather than
+ * theoretical: a change directory named `wip`, `fix`, `update`, or `v2` fails the title gate as a
+ * title while its H1 passes. The import is the more useful reading of the same change; the
+ * preflight is the frozen instrument. Both are right for their job.
+ *
+ * What does not import, said out loud rather than silently dropped: design.md prose (their
+ * technical context and decisions stay in the change folder, where their workflow owns them) and
+ * tasks.md task lists (implementation state belongs to their flow; only the verification contract
+ * is judgment and travels). The tool receipt names both.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.importOpenSpecChange = importOpenSpecChange;
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+const openspec_product_reader_1 = __nccwpck_require__(80);
+const intent_compiler_1 = __nccwpck_require__(6488);
+/** First `# ` heading in proposal.md, if the author gave the change a name of their own. */
+function proposalTitle(dir) {
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(path_1.default.join(dir, 'proposal.md'), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    let inFence = false;
+    for (const line of raw.split('\n')) {
+        if (/^\s*```/.test(line)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const h1 = line.match(/^#\s+(.+?)\s*$/);
+        if (h1)
+            return h1[1].trim();
+        // Stop at the first section heading: an H1 below `## Why` is body content, not a name.
+        if (/^##\s/.test(line))
+            break;
+    }
+    return null;
+}
+function importOpenSpecChange(ref) {
+    // Routed through the product adapter so import and preflight agree about which document
+    // carries the judgment. A change written with the pathmode-intent schema has a change-local
+    // intent.md, and that file wins; a standard OpenSpec change is read exactly as before.
+    const read = (0, openspec_product_reader_1.readOpenSpecChangeForPathmode)(ref);
+    if ((0, openspec_product_reader_1.isProductReadError)(read)) {
+        return { fields: {}, notes: [], hasContent: false, error: read.error };
+    }
+    const projection = read.spec;
+    const fromIntentMd = read.source === 'intent.md';
+    const notes = [...read.notes];
+    if (fromIntentMd) {
+        // Named rather than silently dropped, per the evidence-reference decision: we do not
+        // manufacture Pathmode EvidenceItems out of a text reference yet, because an anchor to
+        // evidence that does not exist in the workspace is a broken promise, not provenance.
+        notes.push('Evidence References in intent.md were preserved as text in the source file, not converted into linked evidence. Anchoring them to workspace evidence is a later step.');
+    }
+    if (!fromIntentMd && fs_1.default.existsSync(path_1.default.join(ref.dir, 'design.md'))) {
+        notes.push('design.md prose (context, decisions) stays in the change folder; only its Non-Goals and verification headings were read.');
+    }
+    if (!fromIntentMd && fs_1.default.existsSync(path_1.default.join(ref.dir, 'tasks.md'))) {
+        notes.push('tasks.md task lists stay with the OpenSpec workflow; only the verification contract was imported.');
+    }
+    const fields = {
+        // intent.md carries its own H1, which the adapter already preferred; the proposal's H1 is
+        // the fallback only when the artifacts are the source.
+        title: fromIntentMd ? projection.title : (proposalTitle(ref.dir) ?? projection.title),
+        objective: projection.objective,
+        outcomes: projection.outcomes,
+        constraints: projection.constraints,
+        edgeCases: projection.edgeCases,
+        // Kinds are preserved, not flattened. An OpenSpec change projects only `test`-shaped
+        // checks because that is all its artifacts distinguish, but an intent.md records the
+        // feedback loop it meant (fastest check, manual check, shipped signal, regression
+        // guard), and rewriting all of those to `test` on import would lose the author's meaning
+        // in the one direction where we control both ends.
+        verification: {
+            checks: (0, intent_compiler_1.toVerificationChecks)(projection.verification).map((c, i) => ({
+                id: `vc${i}`,
+                kind: c.kind,
+                status: c.status ?? 'unknown',
+                description: c.description,
+                ...(c.verifies ? { verifies: c.verifies } : {}),
+            })),
+        },
+    };
+    // Confirmations ride along so a dimension confirmed in the file stays confirmed in the
+    // imported intent, rather than being re-asked as if the author had never answered.
+    if (projection.confirmations) {
+        fields.confirmations = projection.confirmations;
+    }
+    return { fields, notes, hasContent: projection.hasContent };
+}
+
+
+/***/ }),
+
+/***/ 80:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * The product-judgment adapter for an OpenSpec change.
+ *
+ * WHY THIS IS A SEPARATE LAYER. `scripts/openspec-corpus/openspec-reader.ts` is a frozen
+ * instrument: the corpus measurements in docs/research/openspec-corpus-audit.md are only
+ * reproducible while it keeps reading exactly what it read then (that is also why it derives the
+ * title from the directory name rather than an H1, and why `openspec-import.ts` layers the nicer
+ * title on top instead of editing it). Teaching that file about `intent.md` would silently
+ * invalidate every recorded rate. So preference lives here, above it, and the reader stays
+ * untouched.
+ *
+ * WHAT THIS FIXES. The `pathmode-intent` schema writes the product judgment to a change-local
+ * `intent.md`, ahead of the proposal. The corpus reader has never heard of that file, so before
+ * this adapter existed, a change authored faithfully through our own schema graded as
+ * "nothing found" on five of six dimensions: we would have shipped a schema whose output our own
+ * gate accused of having no product judgment. That is the false-accusation failure the whole
+ * unconfirmed-not-absent program exists to remove, so it must not be reintroduced by two of our
+ * own tools disagreeing about where judgment lives.
+ *
+ * THE PRECEDENCE RULES, and each one is a decision rather than a default:
+ *
+ *  1. A recognized change-local `intent.md` is AUTHORITATIVE for the product fields. It was
+ *     written to answer exactly these questions, in a format built for them.
+ *  2. No `intent.md` -> fall back to `openSpecChangeToSpec()` unchanged, so a standard OpenSpec
+ *     repo grades exactly as it did before this file existed. Pinned by test.
+ *  3. An `intent.md` that exists but cannot be read is an ERROR, never a silent fallback. Quietly
+ *     grading proposal.md instead would report a verdict about a document the author did not
+ *     write, and hide the broken file that caused it.
+ *  4. Blank fields are NEVER backfilled from proposal.md. A missing objective in an intent.md is
+ *     an unfinished product judgment, and the gate saying so is the product working. Merging the
+ *     proposal's `## Why` over the gap would manufacture a pass out of a document written to
+ *     answer a different question.
+ *
+ * Read-only throughout: nothing here writes, moves, or creates a file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CHANGE_LOCAL_INTENT_FILE = void 0;
+exports.isProductReadError = isProductReadError;
+exports.readOpenSpecChangeForPathmode = readOpenSpecChangeForPathmode;
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+const openspec_reader_1 = __nccwpck_require__(7290);
+const local_reader_1 = __nccwpck_require__(3518);
+/** The file the `pathmode-intent` schema's `product-intent` artifact generates. */
+exports.CHANGE_LOCAL_INTENT_FILE = 'intent.md';
+function isProductReadError(r) {
+    return r.error !== undefined;
+}
+/**
+ * Does a verification object hold anything?
+ *
+ * A deliberately tiny local predicate rather than `toVerificationChecks` from the intent
+ * compiler: importing that pulled roughly a thousand generated lines of the compiler into the
+ * published CLI bundle, and nothing here needs to normalize checks. The verification object
+ * travels verbatim, so all this has to answer is "is there content".
+ */
+function hasVerificationContent(v) {
+    if (!v || typeof v !== 'object')
+        return false;
+    const src = v;
+    return Boolean(src.checks?.length || src.manualChecks?.length || src.unitTests?.length || src.e2eTests?.length);
+}
+/**
+ * Does this parse carry any product judgment at all?
+ *
+ * Title alone does not count: `parseIntentMarkdown` defaults it to 'Untitled Intent', so a file
+ * of pure comments would otherwise read as "recognized" and grade as five empty gates.
+ */
+function carriesJudgment(intent) {
+    return Boolean((intent.objective || '').trim() ||
+        (intent.outcomes || []).length ||
+        (intent.constraints || []).length ||
+        (intent.edgeCases || []).length ||
+        hasVerificationContent(intent.verification));
+}
+/** Project a parsed intent.md onto the six-gate shape, keeping what makes it an intent.md. */
+function intentToProjection(intent) {
+    const spec = {
+        // The title is taken as written, with NO fallback to the change-directory name. An
+        // earlier version substituted the directory name whenever it saw the 'Untitled Intent'
+        // placeholder, which quietly handed a passing title gate to a scaffold nobody had filled
+        // in: the directory is always named something, so the gate could never report an
+        // unnamed change. `parseIntentMarkdown` already defaults a title-less file to 'Untitled
+        // Intent', and the gate knows that string is a placeholder, so passing it through is
+        // what makes an unfinished file read as unfinished.
+        title: intent.title || '',
+        objective: (intent.objective || '').trim(),
+        outcomes: (intent.outcomes || []).map(o => (typeof o === 'string' ? o : String(o?.text ?? ''))).filter(Boolean),
+        constraints: (intent.constraints || []).map(c => (typeof c === 'string' ? c : String(c ?? ''))).filter(Boolean),
+        edgeCases: (intent.edgeCases || [])
+            .map(ec => ({ scenario: String(ec?.scenario ?? '').trim(), expectedBehavior: String(ec?.expectedBehavior ?? '').trim() }))
+            .filter(ec => ec.scenario || ec.expectedBehavior),
+        // Verbatim: kinds are semantics, not decoration.
+        verification: intent.verification ?? {},
+        hasContent: true,
+    };
+    // Only set the key when the file actually carried one, so a spec with no Confirmations
+    // section is indistinguishable from one that never had the concept.
+    if (intent.confirmations?.length)
+        spec.confirmations = intent.confirmations;
+    return spec;
+}
+/**
+ * Read a change's product judgment, preferring a change-local intent.md.
+ *
+ * `readFile` is injectable so tests can simulate an unreadable file (a permissions error, a
+ * directory where a file belongs) without depending on the filesystem to misbehave on cue.
+ */
+function readOpenSpecChangeForPathmode(ref, io = {}) {
+    const exists = io.exists ?? ((p) => { try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    } });
+    const readFile = io.readFile ?? ((p) => fs_1.default.readFileSync(p, 'utf-8'));
+    const intentPath = path_1.default.join(ref.dir, exports.CHANGE_LOCAL_INTENT_FILE);
+    if (!exists(intentPath)) {
+        // Rule 2: a standard OpenSpec repo is graded exactly as before.
+        return { spec: (0, openspec_reader_1.openSpecChangeToSpec)(ref), source: 'openspec-artifacts', notes: [] };
+    }
+    let raw;
+    try {
+        raw = readFile(intentPath);
+    }
+    catch (e) {
+        // Rule 3. Name the file and the reason; do not grade something else instead.
+        return { error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but could not read it: ${e instanceof Error ? e.message : String(e)}`, intentPath };
+    }
+    let intent;
+    try {
+        intent = (0, local_reader_1.parseIntentMarkdown)(raw, ref.id);
+    }
+    catch (e) {
+        // gray-matter throws on malformed frontmatter. Same rule: an explicit failure beats a
+        // verdict about a different document.
+        return { error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but could not parse it: ${e instanceof Error ? e.message : String(e)}`, intentPath };
+    }
+    if (!carriesJudgment(intent)) {
+        return {
+            error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but read no product judgment from it. Expected at least one of ## Objective, ## Outcomes, ## Constraints, ## Edge Cases, or ## Verification. Renaming a heading makes its section invisible.`,
+            intentPath,
+        };
+    }
+    const notes = [
+        `Product judgment read from ${exports.CHANGE_LOCAL_INTENT_FILE}; proposal.md, design.md, spec deltas, and tasks.md were not merged into these fields.`,
+    ];
+    // Rule 4, said out loud rather than inferred from an empty verdict line.
+    const blank = [
+        !(intent.objective || '').trim() && 'objective',
+        !(intent.outcomes || []).length && 'outcomes',
+        !(intent.constraints || []).length && 'constraints',
+        !(intent.edgeCases || []).length && 'edge cases',
+        !hasVerificationContent(intent.verification) && 'verification',
+    ].filter(Boolean);
+    if (blank.length) {
+        notes.push(`${exports.CHANGE_LOCAL_INTENT_FILE} left ${blank.join(', ')} empty. These are reported as missing rather than filled in from proposal.md, because an unfinished product judgment is the thing worth seeing.`);
+    }
+    return { spec: intentToProjection(intent), source: 'intent.md', intentPath, notes };
+}
+
+
+/***/ }),
+
+/***/ 1726:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+/**
+ * OpenSpec change writer: the inverse of scripts/openspec-corpus/openspec-reader.ts.
+ *
+ * Pathmode emits a change folder that OpenSpec's own workflow can pick up: proposal.md,
+ * tasks.md, and a spec delta. The write is judged by TWO contracts, and the scenario-placement
+ * episode is why both are named: an emission can satisfy either one alone and still be wrong.
+ *
+ *  1. Round-trip fidelity, held by scripts/openspec-corpus/openspec-write-roundtrip.test.ts:
+ *     reading the emitted change back through the OpenSpec reader reproduces the original spec's
+ *     readiness verdict, dimension by dimension, with field digests intact. Digest intactness is
+ *     what keeps a confirmation minted in Pathmode LIVE on the emitted change — the anchor is a
+ *     digest of the field text, so the field must survive verbatim (whitespace collapse aside,
+ *     which the digest normalizes anyway).
+ *  2. Structural acceptance by OpenSpec's own tooling, verified empirically against 1.11.0:
+ *     `openspec validate` accepts a structurally complete emission (the first version passed
+ *     contract 1 while failing this one — every requirement must carry at least one scenario).
+ *
+ * Every placement below is dictated by where the reader looks, measured on 80 public repos:
+ *  - objective  -> `## Why` in proposal.md (prose, read verbatim minus comment lines)
+ *  - outcomes   -> `### Requirement:` bodies in the spec delta (requirements win over
+ *                  `## What Changes` when both exist; What Changes is still emitted because
+ *                  that is what a human skims)
+ *  - constraints-> `## Non-Goals` bullets in proposal.md. OpenSpec has no first-class
+ *                  constraints; prohibitions inside requirement prose are the other native form,
+ *                  but prefixing SHALL NOT onto the author's text would rewrite it and kill its
+ *                  digest. Non-Goals round-trips verbatim.
+ *  - edge cases -> `#### Scenario:` blocks (scenario = header, expectedBehavior = the THEN line).
+ *                  The reader takes THEN/AND clauses only, so WHEN is emitted for human readers
+ *                  and ignored on the way back.
+ *  - verification -> `## Verification` checklist in tasks.md, because that is where the corpus
+ *                  showed real authors put it (the finding the whole audit started from).
+ *
+ * What is deliberately NOT emitted: evidence anchors and confirmations (they live in Pathmode's
+ * record, and a file in someone's repo cannot vouch for itself), and fabricated implementation
+ * tasks (their /opsx workflow authors those; we contribute the verification contract only).
+ *
+ * Known seams, asserted in the round-trip test rather than hidden:
+ *  - An outcome containing "never"/"no writes" reads back as BOTH an outcome and a constraint,
+ *    because the reader mines requirement prose for prohibition sentences.
+ *  - Scenarios are distributed across requirements in sequential chunks to satisfy OpenSpec's
+ *    scenario-per-requirement rule; the assignment is mechanical, not a claimed linkage, and
+ *    requirements left bare (fewer edge cases than outcomes) are reported, never papered over.
+ *  - A multi-line objective containing its own `## ` heading would split the Why section. Real
+ *    objectives are prose; this is documented, not defended against.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.openSpecChangeId = openSpecChangeId;
+exports.formatOpenSpecChange = formatOpenSpecChange;
+const intent_compiler_1 = __nccwpck_require__(6488);
+/** Kebab a title into a change id: diacritics folded, non-alphanumerics collapsed to hyphens. */
+function openSpecChangeId(title) {
+    const kebab = (title || 'change')
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64)
+        .replace(/-+$/g, '');
+    return kebab || 'change';
+}
+const PROVENANCE = '<!-- Emitted by Pathmode (intent_export, format: openspec). Read-only origin: re-exporting refuses to write into an existing change directory. -->';
+const oneLine = (s) => (s || '').replace(/\s+/g, ' ').trim();
+const outcomeText = (o) => oneLine(typeof o === 'string' ? o : String(o?.text ?? ''));
+/** First words of an outcome as a requirement name; the body carries the verbatim text. */
+function requirementName(text, index) {
+    const words = oneLine(text).split(' ').slice(0, 8).join(' ').replace(/[.,;:!?]+$/, '');
+    return words || `Outcome ${index + 1}`;
+}
+function formatOpenSpecChange(fields) {
+    const changeId = openSpecChangeId(fields.title);
+    const outcomes = (fields.outcomes ?? []).map(outcomeText).filter(Boolean);
+    const constraints = (fields.constraints ?? []).map(oneLine).filter(Boolean);
+    const edgeCases = (fields.edgeCases ?? [])
+        .map(ec => ({ scenario: oneLine(ec?.scenario ?? ''), expectedBehavior: oneLine(ec?.expectedBehavior ?? '') }))
+        .filter(ec => ec.scenario);
+    const checks = (0, intent_compiler_1.toVerificationChecks)(fields.verification).map(c => oneLine(c.description)).filter(Boolean);
+    const files = [];
+    let uncoveredRequirements = [];
+    // ── proposal.md ─────────────────────────────────────────────────────────
+    const proposal = [PROVENANCE, '', `# ${oneLine(fields.title) || changeId}`, '', '## Why', ''];
+    // Verbatim, not oneLine'd: Why is a prose section and the reader returns it whole. The
+    // digest collapses whitespace, so paragraph structure is free.
+    proposal.push((fields.objective ?? '').trim() || '(not yet stated)');
+    if (outcomes.length) {
+        proposal.push('', '## What Changes', '');
+        for (const o of outcomes)
+            proposal.push(`- ${o}`);
+    }
+    if (constraints.length) {
+        proposal.push('', '## Non-Goals', '');
+        for (const c of constraints)
+            proposal.push(`- ${c}`);
+    }
+    files.push({ path: 'proposal.md', content: proposal.join('\n') + '\n' });
+    // ── specs/<capability>/spec.md ──────────────────────────────────────────
+    if (outcomes.length || edgeCases.length) {
+        const spec = [PROVENANCE, '', '## ADDED Requirements'];
+        /**
+         * OpenSpec's validator (verified against 1.11.0) errors on any requirement without at
+         * least one `#### Scenario:` block. Edge cases are assigned to requirements in
+         * SEQUENTIAL CHUNKS: the first outcomes get one each, the last gets the remainder. Two
+         * properties hang on that: document order of scenarios equals the original edge-case
+         * order, so the round-trip reads them back exactly (the reader scans linewise); and the
+         * assignment is visibly mechanical, so a reviewer re-homes a scenario in their own
+         * editing pass rather than trusting an inferred linkage we never had. When there are
+         * fewer edge cases than outcomes, the tail requirements stay bare and are reported in
+         * `uncoveredRequirements` — a fabricated scenario would satisfy the validator by lying.
+         */
+        const uncovered = [];
+        if (outcomes.length) {
+            const perReq = outcomes.map(() => []);
+            edgeCases.forEach((ec, i) => {
+                perReq[Math.min(i, outcomes.length - 1)].push(ec);
+            });
+            outcomes.forEach((o, i) => {
+                const name = requirementName(o, i);
+                spec.push('', `### Requirement: ${name}`, '', o);
+                if (!perReq[i].length)
+                    uncovered.push(name);
+                for (const ec of perReq[i]) {
+                    spec.push('', `#### Scenario: ${ec.scenario}`, '');
+                    spec.push(`- **WHEN** ${ec.scenario}`);
+                    if (ec.expectedBehavior)
+                        spec.push(`- **THEN** ${ec.expectedBehavior}`);
+                }
+            });
+        }
+        else {
+            // Edge cases with no outcomes: no requirement to hang them on. The reader still
+            // finds them; OpenSpec's validator will ask for a requirement, which is the honest
+            // message — this spec is missing its outcomes.
+            for (const ec of edgeCases) {
+                spec.push('', `#### Scenario: ${ec.scenario}`, '');
+                spec.push(`- **WHEN** ${ec.scenario}`);
+                if (ec.expectedBehavior)
+                    spec.push(`- **THEN** ${ec.expectedBehavior}`);
+            }
+        }
+        files.push({ path: `specs/${changeId}/spec.md`, content: spec.join('\n') + '\n' });
+        uncoveredRequirements = uncovered;
+    }
+    // ── tasks.md ────────────────────────────────────────────────────────────
+    if (checks.length) {
+        const tasks = [
+            PROVENANCE,
+            '',
+            '# Tasks',
+            '',
+            '<!-- Implementation tasks are authored in your OpenSpec workflow; Pathmode contributes the verification contract below. -->',
+            '',
+            '## Verification',
+            '',
+        ];
+        for (const c of checks)
+            tasks.push(`- [ ] ${c}`);
+        files.push({ path: 'tasks.md', content: tasks.join('\n') + '\n' });
+    }
+    // ── design.md — human context the reader deliberately does not grade ────
+    const decisions = (fields.decisions ?? []).filter(d => d && (d.choice || d.reason));
+    const scopeIn = (fields.scope?.inScope ?? []).map(oneLine).filter(Boolean);
+    const scopeOut = (fields.scope?.outOfScope ?? []).map(oneLine).filter(Boolean);
+    const health = (fields.healthMetrics ?? []).map(oneLine).filter(Boolean);
+    const currentState = (fields.currentState ?? '').trim();
+    if (decisions.length || scopeIn.length || scopeOut.length || health.length || currentState) {
+        const design = [PROVENANCE, '', '# Design notes'];
+        if (currentState)
+            design.push('', '## Context', '', currentState);
+        if (decisions.length) {
+            design.push('', '## Decisions', '');
+            for (const d of decisions) {
+                const ruled = d.ruledOut ? ` (ruled out: ${oneLine(d.ruledOut)})` : '';
+                design.push(`- ${oneLine(d.choice)}: ${oneLine(d.reason)}${ruled}`);
+            }
+        }
+        if (scopeIn.length || scopeOut.length) {
+            design.push('', '## Scope', '');
+            for (const s of scopeIn)
+                design.push(`- In scope: ${s}`);
+            for (const s of scopeOut)
+                design.push(`- Out of scope: ${s}`);
+        }
+        if (health.length) {
+            design.push('', '## Health Metrics', '');
+            for (const h of health)
+                design.push(`- ${h}`);
+        }
+        files.push({ path: 'design.md', content: design.join('\n') + '\n' });
+    }
+    return { changeId, files, uncoveredRequirements };
+}
+
+
 /***/ }),
 
 /***/ 4681:
@@ -35850,20 +36382,38 @@ exports.READINESS_BLOCKER_DESCRIPTIONS = {
 };
 /** Display order for the gate strip (title first, matching the Preflight page). */
 // ── Confirmation anchoring ──────────────────────────────────────────────────
+/**
+ * Remove PAIRED markdown emphasis markers and nothing else.
+ *
+ * The earlier version replaced every asterisk in the text with nothing. That
+ * was wrong in both directions at once: dropping a literal wildcard (`search * patterns` ->
+ * `search patterns`) is a substantive edit that kept its confirmation live, while `_italic_` was
+ * left alone so a formatting-only edit invalidated one. Emphasis needs an opening marker followed
+ * by non-space and a matching closer, so a lone `*` or `_` survives. Looped because markers nest.
+ */
+function stripEmphasis(text) {
+    let prev;
+    let out = text;
+    do {
+        prev = out;
+        out = out.replace(/(\*\*|__|\*|_)(?=\S)([\s\S]*?\S)\1/g, '$2');
+    } while (out !== prev);
+    return out;
+}
 /**
  * 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.
+ * quote/dash folding and PAIRED markdown emphasis because adding `**` around a word is
+ * formatting, not a reword. An unpaired `*` or `_` is left alone: it is content (a wildcard),
+ * and deleting it silently kept confirmations alive across a real change to the claim. Lowercased and whitespace-collapsed last.
  */
 function normalizeAnchor(value) {
-    return coerceText(value)
+    return stripEmphasis(coerceText(value))
         .normalize('NFC')
         .replace(/­/g, '')
         .replace(/[‘’ʼ]/g, "'")
         .replace(/[“”]/g, '"')
         .replace(/[–—]/g, '-')
-        .replace(/\*/g, '')
         .replace(/\s+/g, ' ')
         .trim()
         .toLowerCase();
@@ -36520,6 +37070,598 @@ async function runSetup() {
 }
 
 
+/***/ }),
+
+/***/ 7290:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * OpenSpec project reader.
+ *
+ * A lot of the people who launch the keyless first run already plan with OpenSpec: they have a
+ * change proposal sitting in the repo and no answer to "did this change deserve to be built".
+ * OpenSpec answers whether the code matches the agreed change; this reads that change and puts
+ * the deterministic Pathmode readiness gate on the product judgment behind it.
+ *
+ * Contract, enforced by openspec-reader.test.ts:
+ *   - READ ONLY. Nothing in this file writes, creates, or deletes. Not under `openspec/`, not in
+ *     a registered store, not anywhere.
+ *   - NO SUBPROCESS. The `openspec` CLI may not be installed, and spawning a binary off PATH
+ *     during a first run is not something a greeting gets to do. Everything comes off disk.
+ *   - NO NETWORK. Keyless stays keyless.
+ *   - SILENT ON FAILURE. Every read is individually wrapped and returns null. A malformed,
+ *     unreadable, or unrecognized layout falls back to the normal first run with no error
+ *     output and no stack trace. Nothing here writes to stderr — this runs at startup on the
+ *     stdio transport.
+ *   - `tasks.md` IS READ, BUT ONLY UNDER A VERIFICATION HEADING. Implementation work items are
+ *     the plan, not the judgment behind it, and stay out of every field. A section headed
+ *     Verification / Tests / Acceptance is where these authors actually record their checks.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.readStorePointer = readStorePointer;
+exports.storeRegistryPath = storeRegistryPath;
+exports.resolveStorePath = resolveStorePath;
+exports.detectOpenSpec = detectOpenSpec;
+exports.openSpecChangeToSpec = openSpecChangeToSpec;
+exports.formatOpenSpecFirstRun = formatOpenSpecFirstRun;
+exports.localFirstRunInstructions = localFirstRunInstructions;
+exports.resolveOpenSpecSubject = resolveOpenSpecSubject;
+/**
+ * PROJECTION FIX, 2026-08-28. An earlier version of this file read verification only from
+ * `proposal.md` and `design.md`, on the reasoning that `tasks.md` is an execution plan rather
+ * than a judgment artifact. Measured against 80 real changes from 80 distinct repositories,
+ * that reasoning was wrong about how people use the file. The gate fired on 94% of real changes
+ * because of this file, not because those authors skipped verification. Reading `tasks.md`, and
+ * matching a bare `## Tests`, moves it from 6% to 63%.
+ *
+ * Two different counts of "where authors put verification" exist and must not be conflated,
+ * because the distance between them is this reader's blind spot:
+ *
+ *   what THIS READER CAN SOURCE   h2 headings only, VERIFICATION_HEADING_RE below
+ *                                 tasks.md 47/80 | proposal.md 5/80 | design.md 5/80
+ *   what a SURVEY FINDS           any heading depth h1-h6, plus `qa` and `success criteria`
+ *                                 tasks.md 51/80 | proposal.md 12/80 | design.md 12/80
+ *
+ * `grade.ts` reports the survey row, since its job is to say where the reader should look. The
+ * gap is not noise: 7 of 12 changes that record verification in `design.md` do it under an h3
+ * this reader cannot enter, and 5 proposals use a heading word it does not match. An earlier
+ * revision of this comment cited 43 and 10; those came from a superseded regex and reproduce
+ * from no current code path.
+ *
+ * WIDENING: REJECTED, 2026-08-28, by the blinded audit (`audit-prepare.ts`, `audit-score.ts`,
+ * `audit-results.json`; a verdict-blinded single-model review — see the research doc for the
+ * protocol). Matching h1-h6 with the survey's wider regex was priced at 63% -> 70%. The audit
+ * read 40 changes blind and found six verification false negatives; the widening fixes NONE of
+ * them, and this part rests on where verification physically sits in the artifacts, not on a
+ * judgment call — not one is a heading-depth problem:
+ *
+ *   three record verification under a Chinese heading (`## 3. 验证`, `## 5. 驗證與 witness`,
+ *   `### 2. 测试验证`) — VERIFICATION_HEADING_RE is English-only, at any depth;
+ *   one puts it under the name of the work (`## 2. Automated hygiene gate`);
+ *   one uses bold text, not a heading at all (`**Quality Gate:** PASSED`);
+ *   one has no `tasks.md`, and records the check in `design.md`'s migration plan.
+ *
+ * The audit also found the widening's own failure mode already firing at the current width: the
+ * one verification FALSE POSITIVE in the sample is a section titled `## 1. Validation Module`,
+ * where "validation" names the module being built, not a check being run. The reader scored its
+ * "Create src/cli/import-validator.ts" work items as verification checks. Matching more heading
+ * shapes makes that class worse, not better. Recovering these six needs a different mechanism
+ * than a wider heading regex — the heading is not where the signal is.
+ *
+ * Do not narrow the verification sources again without re-running `grade.ts`. Grading someone
+ * else's change against a gate we cannot correctly read is worse than not grading it.
+ */
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const os_1 = __importDefault(__nccwpck_require__(857));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+/** The judgment-bearing artifacts. `tasks.md` is deliberately not in this list. */
+const PROPOSAL_FILE = 'proposal.md';
+const DESIGN_FILE = 'design.md';
+const SPECS_DIR = 'specs';
+// ── Filesystem primitives: every one of these swallows its own failure ──────
+function safeExists(p) {
+    try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+function safeIsDir(p) {
+    try {
+        return fs_1.default.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function safeReadFile(p) {
+    try {
+        return fs_1.default.readFileSync(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function safeReadDirNames(p) {
+    try {
+        return fs_1.default.readdirSync(p, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .filter((n) => !n.startsWith('.'))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+// ── config.yaml `store:` pointer ────────────────────────────────────────────
+/**
+ * Pull a top-level `store:` scalar out of `openspec/config.yaml`.
+ *
+ * Deliberately not a YAML parse. The package declares three runtime dependencies and a YAML
+ * parser is only available transitively; depending on a transitive package is how a bundle
+ * breaks on someone else's install. One top-level scalar does not justify a new dependency.
+ * Anything that is not a plain top-level `store: <id>` returns null, which reads as "no store
+ * pointer" and falls back to local artifacts.
+ */
+function readStorePointer(configYaml) {
+    if (!configYaml)
+        return null;
+    for (const rawLine of configYaml.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (/^\s*#/.test(line))
+            continue;
+        // Top level only: no leading whitespace, so a `store:` nested under some other key
+        // is not mistaken for the pointer.
+        const m = line.match(/^store:\s*(.*)$/);
+        if (!m)
+            continue;
+        let value = m[1].trim();
+        // Strip a trailing comment on an unquoted scalar.
+        if (!/^["']/.test(value))
+            value = value.replace(/\s+#.*$/, '').trim();
+        const quoted = value.match(/^["'](.*)["']$/);
+        if (quoted)
+            value = quoted[1].trim();
+        if (!value)
+            return null;
+        return value;
+    }
+    return null;
+}
+// ── Store registry ──────────────────────────────────────────────────────────
+/** Where OpenSpec 1.11.0 registers stores. XDG override honoured, home fallback otherwise. */
+function storeRegistryPath(env = process.env) {
+    const base = env.XDG_DATA_HOME && env.XDG_DATA_HOME.trim()
+        ? env.XDG_DATA_HOME
+        : path_1.default.join(os_1.default.homedir(), '.local', 'share');
+    return path_1.default.join(base, 'openspec', 'stores', 'registry.yaml');
+}
+/** Keys a store's local path has been seen under, or plausibly could be. Beta shape, so the
+ *  documented snake_case (store family) and camelCase (workflow family) spellings both count. */
+const STORE_PATH_KEYS = new Set(['local_path', 'localPath', 'path', 'root']);
+/**
+ * Resolve a store id to a local path by scanning the registry's indentation.
+ *
+ * A bounded scanner rather than a YAML parse, for the dependency reason above and because the
+ * shape is documented as beta: this looks for the block whose key is the store id, then returns
+ * the first scalar beneath it whose key looks like a local path, at any depth. A rename of the
+ * intervening `backend:` level does not break it. Anything unexpected returns null and the
+ * caller reports the store as unresolved rather than claiming there is no OpenSpec project.
+ */
+function resolveStorePath(registryYaml, storeId) {
+    if (!registryYaml || !storeId)
+        return null;
+    const lines = registryYaml.split('\n').map((l) => l.replace(/\r$/, ''));
+    const indentOf = (l) => l.length - l.trimStart().length;
+    let storesIndent = -1;
+    let storeIndent = -1;
+    let inStore = false;
+    for (const line of lines) {
+        if (!line.trim() || /^\s*#/.test(line))
+            continue;
+        const indent = indentOf(line);
+        const keyMatch = line.trim().match(/^([A-Za-z0-9_.\/-]+)\s*:\s*(.*)$/);
+        if (!keyMatch)
+            continue;
+        const key = keyMatch[1];
+        const value = keyMatch[2].trim();
+        if (storesIndent === -1) {
+            if (key === 'stores' && !value)
+                storesIndent = indent;
+            continue;
+        }
+        if (!inStore) {
+            if (indent <= storesIndent) {
+                // Left the `stores:` block without finding the id.
+                storesIndent = -1;
+                continue;
+            }
+            if (key === storeId) {
+                inStore = true;
+                storeIndent = indent;
+            }
+            continue;
+        }
+        // Inside the store block: dedent to or past the id means the block ended.
+        if (indent <= storeIndent)
+            return null;
+        if (!STORE_PATH_KEYS.has(key) || !value)
+            continue;
+        const unquoted = value.replace(/^["'](.*)["']$/, '$1').trim();
+        return unquoted || null;
+    }
+    return null;
+}
+// ── Detection ───────────────────────────────────────────────────────────────
+/**
+ * Detect an OpenSpec project in `cwd`, or return null.
+ *
+ * The no-OpenSpec path is a single `existsSync`. Nothing else is stat'ed, opened, or walked, so
+ * a repo without OpenSpec cannot pay measurable cost for this.
+ */
+function detectOpenSpec(cwd = process.cwd(), env = process.env) {
+    const openspecDir = path_1.default.join(cwd, 'openspec');
+    if (!safeExists(openspecDir))
+        return null;
+    if (!safeIsDir(openspecDir))
+        return null;
+    const storeId = readStorePointer(safeReadFile(path_1.default.join(openspecDir, 'config.yaml'))) || undefined;
+    let storeRoot;
+    let storeUnresolved = false;
+    if (storeId) {
+        const resolved = resolveStorePath(safeReadFile(storeRegistryPath(env)), storeId);
+        // A registered store whose directory is gone is as unresolved as an unregistered one.
+        if (resolved && safeIsDir(path_1.default.join(resolved, 'openspec'))) {
+            storeRoot = path_1.default.join(resolved, 'openspec');
+        }
+        else if (resolved && safeIsDir(resolved)) {
+            storeRoot = resolved;
+        }
+        else {
+            storeUnresolved = true;
+        }
+    }
+    // Local artifacts win when they exist: a repo can carry a pointer and still hold changes.
+    const localChangesDir = path_1.default.join(openspecDir, 'changes');
+    const localChanges = listChanges(localChangesDir);
+    let planningHome = openspecDir;
+    let changes = localChanges;
+    if (localChanges.length === 0 && storeRoot) {
+        const storeChanges = listChanges(path_1.default.join(storeRoot, 'changes'));
+        if (storeChanges.length > 0) {
+            planningHome = storeRoot;
+            changes = storeChanges;
+        }
+    }
+    return { openspecDir, storeId, storeRoot, storeUnresolved, planningHome, changes };
+}
+function listChanges(changesDir) {
+    if (!safeIsDir(changesDir))
+        return [];
+    return safeReadDirNames(changesDir)
+        // `archive/` holds shipped changes; it is not an active change.
+        .filter((name) => name !== 'archive')
+        .map((name) => ({ id: name, dir: path_1.default.join(changesDir, name) }));
+}
+// ── Markdown extraction ─────────────────────────────────────────────────────
+/** Collect the body lines under every `## Heading` matching `test`. */
+/**
+ * Remove fenced code blocks before any structural parsing.
+ *
+ * FIXED 2026-08-29. This reader was left deliberately unfixed while the blinded audit's numbers
+ * stood on it, because changing it would have moved the corpus buckets the audit's stratified
+ * sample was drawn from. It is fixed now because the product CLI reads OpenSpec changes through
+ * this same function, and shipping a known false-positive generator to other people's repos is
+ * not defensible. The audit artifacts are a dated record against the reader as it was; see
+ * docs/research/openspec-corpus-audit.md for what the fix changed.
+ *
+ * The defect: `sectionsMatching` is line-based and `bulletsIn` matches a leading `-`/`*`, so a C
+ * comment line (` * @brief ...`) or a YAML list inside a fence parsed as an outcome. One corpus
+ * change contributed 21 Doxygen `@brief` lines that way and passed a gate three reviewers fail
+ * it on. Mirrors lib/intentMdParse.stripFencedBlocks; same rules, same reasons.
+ */
+function stripFencedBlocks(markdown) {
+    const out = [];
+    let fence = null;
+    for (const line of markdown.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 sectionsMatching(markdown, test) {
+    const out = [];
+    let current = null;
+    for (const line of stripFencedBlocks(markdown).split('\n')) {
+        const h2 = line.match(/^##\s+(.+?)\s*$/);
+        if (h2) {
+            current = test(h2[1]) ? [] : null;
+            if (current)
+                out.push(current);
+            continue;
+        }
+        if (/^#\s+/.test(line)) {
+            current = null;
+            continue;
+        }
+        if (current)
+            current.push(line);
+    }
+    return out;
+}
+function stripComments(lines) {
+    // Template scaffolds ship HTML comments as placeholder prompts. They are not content.
+    return lines.filter((l) => !/^\s*<!--/.test(l) && !/-->\s*$/.test(l));
+}
+function bulletsIn(lines) {
+    return stripComments(lines)
+        .filter((l) => /^\s*[-*]\s/.test(l))
+        .map((l) => l.replace(/^\s*[-*]\s+(\[.\]\s+)?/, '').trim())
+        .filter(Boolean);
+}
+function proseIn(lines) {
+    return stripComments(lines).join('\n').trim();
+}
+const VERIFICATION_HEADING_RE = /verif|\btests?\b|testing|test plan|validation|acceptance|how we(?:'ll)? know/i;
+/**
+ * Map a change's judgment-bearing artifacts onto the six readiness gates.
+ *
+ * Scenarios feed `edgeCases` and deliberately NOT `verification`. A scenario states what must be
+ * true; it does not say how you would observe it after shipping. Feeding one source into two
+ * gates would make both pass off a single artifact and hollow out the verdict.
+ *
+ * RECALL IS UNVALIDATED. This is heading-matching over four filenames, so a change with checks
+ * under an unfamiliar heading, nested deeper, or written as prose outside any section is invisible
+ * to it. When the gate fires, the honest statement is "this reader found no check", never "the
+ * author recorded none" — the difference between those two is exactly the mistake this file
+ * already made once at scale. Same caution on `objective`, which is an exact `## Why` match, and
+ * on `outcomes`, which maps OpenSpec requirements (system behaviour) onto Pathmode outcomes
+ * (observable product change). Those are related but not the same field, and a low pass rate
+ * there is a hypothesis, not a measurement.
+ */
+function openSpecChangeToSpec(change) {
+    const proposal = safeReadFile(path_1.default.join(change.dir, PROPOSAL_FILE)) || '';
+    const design = safeReadFile(path_1.default.join(change.dir, DESIGN_FILE)) || '';
+    const specDocs = readDeltaSpecs(path_1.default.join(change.dir, SPECS_DIR));
+    const objective = proseIn(sectionsMatching(proposal, (h) => /^why\b/i.test(h)).flat());
+    const requirements = specDocs.flatMap(extractRequirements);
+    const whatChanges = sectionsMatching(proposal, (h) => /what changes/i.test(h)).flatMap(bulletsIn);
+    const outcomes = requirements.length > 0 ? requirements.map((r) => r.statement).filter(Boolean) : whatChanges;
+    const constraints = [
+        ...requirements.flatMap((r) => r.prohibitions),
+        ...sectionsMatching(design, (h) => /non-?goals/i.test(h)).flatMap(bulletsIn),
+        ...sectionsMatching(proposal, (h) => /non-?goals/i.test(h)).flatMap(bulletsIn),
+    ];
+    const edgeCases = specDocs.flatMap(extractScenarios);
+    const tasks = safeReadFile(path_1.default.join(change.dir, 'tasks.md')) || '';
+    const verificationLines = [
+        ...sectionsMatching(proposal, (h) => VERIFICATION_HEADING_RE.test(h)),
+        ...sectionsMatching(design, (h) => VERIFICATION_HEADING_RE.test(h)),
+        ...sectionsMatching(tasks, (h) => VERIFICATION_HEADING_RE.test(h)),
+    ];
+    const verificationItems = verificationLines.flatMap((lines) => {
+        const bullets = bulletsIn(lines);
+        return bullets.length > 0 ? bullets : (proseIn(lines) ? [proseIn(lines)] : []);
+    });
+    return {
+        title: change.id.replace(/[-_]+/g, ' ').trim(),
+        objective,
+        outcomes,
+        constraints,
+        edgeCases,
+        verification: { checks: verificationItems.map((description) => ({ kind: 'test', description })) },
+        hasContent: !!(objective || outcomes.length || edgeCases.length),
+    };
+}
+function readDeltaSpecs(specsDir) {
+    if (!safeIsDir(specsDir))
+        return [];
+    const out = [];
+    const walk = (dir, depth) => {
+        if (depth > 6)
+            return;
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path_1.default.join(dir, e.name);
+            if (e.isDirectory())
+                walk(full, depth + 1);
+            else if (e.isFile() && e.name.endsWith('.md')) {
+                const content = safeReadFile(full);
+                if (content)
+                    out.push(content);
+            }
+        }
+    };
+    walk(specsDir, 0);
+    return out;
+}
+/** `### Requirement: <name>` followed by normative prose, until the next `###`/`##`. */
+function extractRequirements(markdown) {
+    const out = [];
+    let body = null;
+    const flush = () => {
+        if (!body)
+            return;
+        const text = stripComments(body).join(' ').replace(/\s+/g, ' ').trim();
+        if (text) {
+            const prohibitions = text
+                .split(/(?<=\.)\s+/)
+                .map((s) => s.trim())
+                .filter((s) => /\b(SHALL NOT|MUST NOT|never|no writes?)\b/i.test(s));
+            out.push({ statement: text, prohibitions });
+        }
+        body = null;
+    };
+    for (const line of markdown.split('\n')) {
+        if (/^###\s+Requirement:/i.test(line)) {
+            flush();
+            body = [];
+            continue;
+        }
+        if (/^#{1,4}\s/.test(line)) {
+            flush();
+            continue;
+        }
+        if (body)
+            body.push(line);
+    }
+    flush();
+    return out;
+}
+/** `#### Scenario: <name>` with `- **WHEN**` / `- **THEN**` / `- **AND**` clauses. */
+function extractScenarios(markdown) {
+    const out = [];
+    let name = null;
+    let thens = [];
+    const flush = () => {
+        if (name && thens.length > 0)
+            out.push({ scenario: name, expectedBehavior: thens.join('; ') });
+        name = null;
+        thens = [];
+    };
+    for (const line of markdown.split('\n')) {
+        const header = line.match(/^####\s+Scenario:\s*(.+?)\s*$/i);
+        if (header) {
+            flush();
+            name = header[1].trim();
+            continue;
+        }
+        if (/^#{1,4}\s/.test(line)) {
+            flush();
+            continue;
+        }
+        if (!name)
+            continue;
+        const clause = line.match(/^\s*[-*]\s+\*\*(THEN|AND)\*\*\s*(.+?)\s*$/i);
+        if (clause) {
+            const text = clause[2].trim();
+            // A bare `**AND**` before any `**THEN**` is still part of the condition.
+            if (/^THEN$/i.test(clause[1]) || thens.length > 0)
+                thens.push(text);
+        }
+    }
+    flush();
+    return out;
+}
+// ── First-run copy ──────────────────────────────────────────────────────────
+/**
+ * The OpenSpec-aware replacement for the generic first-run guidance. Names the change instead of
+ * welcoming the user to an empty repo, and never guesses when there is more than one change.
+ */
+function formatOpenSpecFirstRun(ctx) {
+    const parts = [];
+    const ids = ctx.changes.map((c) => c.id);
+    if (ctx.storeUnresolved && ctx.storeId) {
+        parts.push(`This repo plans with OpenSpec, and its planning lives in store "${ctx.storeId}", which is not registered or not readable on this machine. ` +
+            `Preflight whatever is readable here.`);
+    }
+    else if (ctx.storeId && ctx.storeRoot) {
+        parts.push(`This repo plans with OpenSpec; its planning lives in store "${ctx.storeId}".`);
+    }
+    else {
+        parts.push('This repo plans with OpenSpec.');
+    }
+    if (ids.length === 1) {
+        parts.push(`Active change: ${ids[0]}. ` +
+            `First move: call check_intent_readiness with intentId "${ids[0]}" to preflight the product judgment behind it — ` +
+            `six deterministic gates over the proposal and its specs, no model call and nothing leaves the machine. ` +
+            `OpenSpec already answers whether the code matches the agreed change; this answers whether the change deserved to be built. ` +
+            `A failing verdict names the exact blockers; repair them one targeted question at a time. Never block work on a failing verdict.`);
+    }
+    else if (ids.length > 1) {
+        parts.push(`Changes found: ${ids.join(', ')}. ` +
+            `Ask the user which one to preflight — do not pick for them — then call check_intent_readiness with that change id as intentId. ` +
+            `It runs six deterministic gates over the proposal and its specs, no model call and nothing leaves the machine. ` +
+            `A failing verdict names the exact blockers; repair them one targeted question at a time. Never block work on a failing verdict.`);
+    }
+    else {
+        parts.push(`No active change yet. Offer to preflight the intent behind the next one: draft it from the conversation, mark inferred fields as assumptions, ` +
+            `then call check_intent_readiness with the spec inline. Nothing leaves the machine and no account is needed.`);
+    }
+    parts.push('Pathmode reads OpenSpec read-only and never writes under openspec/ or into a store. Specs you save go to intent.md in this repo.');
+    parts.push('To sync with a shared Pathmode workspace later, run: npx @pathmode/mcp-server setup pm_live_xxx');
+    return parts.join(' ');
+}
+/**
+ * Pick the first-run guidance. With no OpenSpec project this returns the caller's own constant
+ * unchanged — by reference, so a repo without `openspec/` provably gets byte-identical guidance
+ * to the one it got before this change.
+ */
+function localFirstRunInstructions(fallback, ctx) {
+    return ctx ? formatOpenSpecFirstRun(ctx) : fallback;
+}
+/**
+ * Resolve what `check_intent_readiness` should preflight when no local intent answered.
+ *
+ * Never guesses between changes: with more than one and no id, it hands back the list. An
+ * `intentId` that matches no change returns `none`, so the caller's own "no intent with that id"
+ * message still wins rather than being replaced by an OpenSpec-flavoured near-miss.
+ */
+function resolveOpenSpecSubject(ctx, intentId) {
+    if (!ctx)
+        return { kind: 'none' };
+    if (intentId) {
+        const match = ctx.changes.find((c) => c.id === intentId);
+        if (!match)
+            return { kind: 'none' };
+        return projectionOrMessage(match);
+    }
+    if (ctx.changes.length === 0) {
+        const where = ctx.storeUnresolved && ctx.storeId
+            ? ` Its planning lives in store "${ctx.storeId}", which is not registered or not readable on this machine.`
+            : '';
+        return {
+            kind: 'message',
+            text: `This repo plans with OpenSpec and has no active change.${where} Nothing to preflight yet — draft the intent behind the next change from the conversation, mark inferred fields as assumptions, and pass it inline to preflight it before anyone builds it.`,
+        };
+    }
+    if (ctx.changes.length > 1) {
+        return {
+            kind: 'message',
+            text: `This repo plans with OpenSpec and has ${ctx.changes.length} changes: ${ctx.changes.map((c) => c.id).join(', ')}. Ask which one to preflight, then pass its id as intentId.`,
+        };
+    }
+    return projectionOrMessage(ctx.changes[0]);
+}
+function projectionOrMessage(change) {
+    const spec = openSpecChangeToSpec(change);
+    if (!spec.hasContent) {
+        // Every judgment-bearing artifact was missing or unreadable. A verdict computed from
+        // nothing would be six failures that say more about the parse than about the change.
+        return {
+            kind: 'message',
+            text: `OpenSpec change "${change.id}" has no readable proposal, design, or spec content, so there is no product judgment to preflight. Describe the change and pass the spec inline instead.`,
+        };
+    }
+    return { kind: 'spec', spec, sourceNote: `OpenSpec change ${change.id} (proposal, design, and delta specs; tasks.md is not read)` };
+}
+
+
 /***/ }),
 
 /***/ 2613:
@@ -66098,7 +67240,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.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"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@pathmode/mcp-server","version":"1.16.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"}}');
 
 /***/ })
 
@@ -66198,6 +67340,9 @@ const api_client_1 = __nccwpck_require__(7475);
 const local_reader_1 = __nccwpck_require__(3518);
 const readiness_1 = __nccwpck_require__(3079);
 const save_policy_1 = __nccwpck_require__(6137);
+const openspec_writer_1 = __nccwpck_require__(1726);
+const openspec_import_1 = __nccwpck_require__(8388);
+const openspec_reader_1 = __nccwpck_require__(7290);
 const intent_compiler_1 = __nccwpck_require__(6488);
 const pathmode_section_1 = __nccwpck_require__(4681);
 const setup_1 = __nccwpck_require__(8294);
@@ -67392,6 +68537,7 @@ function startMcpServer() {
             e2eTests: zod_1.z.array(zod_1.z.string()).optional(),
         }).optional().describe('How to confirm it works'),
     };
+    const intentSpecObject = zod_1.z.object(intentSpecSchema);
     server.prompt('compile-intent', 'Start a Socratic conversation to build a structured intent spec from user feedback or a problem description. No Pathmode account needed.', {}, async () => {
         return {
             messages: [{
@@ -67480,131 +68626,253 @@ function startMcpServer() {
         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.'),
-    }, async ({ spec, path, overwrite }) => {
-        const filePath = resolveWithinProject(path || 'intent.md');
-        const existing = (0, local_reader_1.readIntentMeta)(filePath);
-        const decision = (0, save_policy_1.decideSave)({
-            existing,
-            incomingId: spec.id,
-            overwrite,
-            mintId: () => (0, crypto_1.randomUUID)(),
-        });
-        if (decision.action === 'refuse') {
+    }, async ({ spec, path, overwrite }) => performIntentSave(spec, path, overwrite));
+    /**
+     * The whole save path — collision policy, verdict stamp, confirmation carry-forward, cloud push
+     * with identity settlement — extracted so intent_import can reuse it EXACTLY. Import must not be
+     * a second save implementation: the list-projection defect family taught what a second copy of a
+     * write path costs, and the confirmation carry-forward here is load-bearing (M1's tool boundary
+     * assumes every writer goes through this).
+     */
+    async function performIntentSave(spec, path, overwrite, retryTool = 'intent_save') {
+        {
+            const filePath = resolveWithinProject(path || 'intent.md');
+            const existing = (0, local_reader_1.readIntentMeta)(filePath);
+            const decision = (0, save_policy_1.decideSave)({
+                existing,
+                incomingId: spec.id,
+                overwrite,
+                mintId: () => (0, crypto_1.randomUUID)(),
+            });
+            if (decision.action === 'refuse') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                `✗ Refusing to overwrite ${filePath}`,
+                                '',
+                                `It already holds a different intent (id: ${existing.id ?? 'unknown'}, status: ${existing.status}, version: ${existing.version}), and this spec is "${decision.id}".`,
+                                '',
+                                'Save to another path (pass `path`), or pass overwrite=true to replace it deliberately.',
+                            ].join('\n'),
+                        }],
+                };
+            }
+            const { id, version, status, created } = decision;
+            // 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 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) => {
+                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.
+                // ONLY on an update. A create means this is a different intent, and the previous
+                // file's confirmations vouch for a different intent's field text. They would be inert
+                // (their anchors cannot match) but present, which misattributes who confirmed what.
+                const prior = decision.action === 'update' && (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) {
+                writeSpecFile({ canonicalId: id });
+            }
+            else {
+                const result = await (0, push_spec_1.pushSpec)({
+                    client: requireCloudClient(),
+                    id,
+                    // Only an UPDATE may claim the previous record. On a create — including an
+                    // explicit overwrite of a different intent — passing the old specVersion sends
+                    // pushSpec down its updateIntent branch, which would rewrite the unrelated
+                    // workspace intent with this spec's content. The local decision says create; the
+                    // cloud call has to agree, or the two halves disagree about identity.
+                    existingSpecVersion: decision.action === 'update' ? existing?.specVersion : undefined,
+                    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 ${retryTool} 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
+                ? ''
+                : `\n\n${(0, readiness_1.formatReadinessVerdict)(verdict, spec.title)}`;
             return {
                 content: [{
                         type: 'text',
                         text: [
-                            `✗ Refusing to overwrite ${filePath}`,
-                            '',
-                            `It already holds a different intent (id: ${existing.id ?? 'unknown'}, status: ${existing.status}, version: ${existing.version}), and this spec is "${decision.id}".`,
-                            '',
-                            'Save to another path (pass `path`), or pass overwrite=true to replace it deliberately.',
+                            `✓ ${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'),
                     }],
             };
         }
-        const { id, version, status, created } = decision;
-        // 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 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) => {
-            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));
+    }
+    server.tool('intent_import', 'Adopt an existing OpenSpec change as the Pathmode intent record. Reads the change folder exactly as the preflight does (proposal.md, spec deltas, design non-goals, verification in tasks.md) and saves it as intent.md — with a workspace key, also as a workspace intent. The change folder is NEVER modified, and field text travels verbatim, so never retype fields from the change yourself. After importing, resolve any unconfirmed dimensions with confirm_intent_dimension.', {
+        path: zod_1.z.string().optional().describe('OpenSpec change directory, e.g. openspec/changes/add-export. When omitted the repo is scanned: exactly one active change imports directly; several returns the list to pick from.'),
+        intentPath: zod_1.z.string().optional().describe('Where the intent file is written. Defaults to intent.md.'),
+        overwrite: zod_1.z.boolean().optional().describe('Replace the intent file even when it already holds a DIFFERENT intent. Default false — refused instead.'),
+        productId: zod_1.z.string().optional().describe('Cloud mode: the product this intent belongs to, when the workspace asks for one.'),
+    }, async ({ path, intentPath, overwrite, productId }) => {
+        let ref;
+        if (path) {
+            const dir = resolveWithinProject(path);
+            if (!(0, fs_1.existsSync)(dir)) {
+                return { content: [{ type: 'text', text: `✗ Nothing at ${path}. Pass the change directory, e.g. openspec/changes/<change-id>.` }] };
             }
-            (0, fs_1.writeFileSync)(filePath, content, 'utf-8');
-        };
-        if (isLocalMode) {
-            writeSpecFile({ canonicalId: id });
+            ref = { id: (0, path_1.basename)(dir), dir };
         }
         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) {
+            const ctx = (0, openspec_reader_1.detectOpenSpec)(process.cwd());
+            if (!ctx || ctx.changes.length === 0) {
+                const resolution = (0, openspec_reader_1.resolveOpenSpecSubject)(ctx);
                 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'),
+                            text: resolution.kind === 'message'
+                                ? `✗ ${resolution.text}`
+                                : '✗ No OpenSpec project detected here. Pass the change directory as path, e.g. openspec/changes/<change-id>.',
                         }],
-                    isError: true,
                 };
             }
-            canonicalId = result.canonicalId;
-            specVersion = result.specVersion;
-            sourceUrl = result.sourceUrl;
-            didNotTravel = result.didNotTravel;
+            if (ctx.changes.length > 1) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✗ This repo has ${ctx.changes.length} OpenSpec changes: ${ctx.changes.map(c => c.id).join(', ')}. Ask which one to import, then pass it as path.`,
+                        }],
+                };
+            }
+            ref = ctx.changes[0];
+        }
+        /**
+         * Import NEVER updates an existing intent. intent_save treats a spec without an id as
+         * "the same intent, bump the version", which is right for an agent iterating on its own
+         * spec and wrong here: an import cannot know that whatever intent.md already holds
+         * corresponds to this change, and the first smoke run of this tool proved the failure
+         * mode by silently morphing an unrelated v3 intent into the imported change.
+         */
+        const targetRel = intentPath || 'intent.md';
+        const targetAbs = resolveWithinProject(targetRel);
+        if ((0, fs_1.existsSync)(targetAbs) && !overwrite) {
+            const existingMeta = (0, local_reader_1.readIntentMeta)(targetAbs);
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            `✗ ${targetRel} already holds an intent${existingMeta?.id ? ` (id: ${existingMeta.id}, version: ${existingMeta.version})` : ''}.`,
+                            'Import never updates an existing intent: it cannot know that file corresponds to this change.',
+                            'Write the import elsewhere (pass intentPath), or pass overwrite:true to replace it deliberately.',
+                        ].join('\n'),
+                    }],
+            };
         }
-        const action = decision.action === 'update' ? `Updated intent spec (v${version})` : 'Saved intent spec';
-        const readinessNote = verdict.ready
-            ? ''
-            : `\n\n${(0, readiness_1.formatReadinessVerdict)(verdict, spec.title)}`;
+        const imported = (0, openspec_import_1.importOpenSpecChange)(ref);
+        if (!imported.hasContent) {
+            return {
+                content: [{
+                        type: 'text',
+                        // The adapter's own reason wins when it has one: a change whose intent.md is
+                        // unreadable must not be described as having no proposal content, which
+                        // points the author at files that were never the problem.
+                        text: imported.error
+                            ? `✗ ${imported.error}`
+                            : `✗ OpenSpec change "${ref.id}" has no readable proposal, design, or spec content — there is no judgment to import. Describe the change in conversation and save it with intent_save instead.`,
+                    }],
+            };
+        }
+        /**
+         * Import always mints a NEW identity. decideSave treats a spec with no id as "the same
+         * intent, bump the version", so without this an overwrite would hand the imported change
+         * the previous intent's id, version, and status — the silent morph the refusal above
+         * blocks on the non-overwrite path, still reachable through the flag.
+         *
+         * Consequence, stated because it is a real trade: re-importing the same change produces a
+         * new intent rather than a new version of the old one. We cannot prove that an existing
+         * intent.md corresponds to this change, and inventing that continuity is the more
+         * expensive mistake.
+         */
+        const saved = await performIntentSave({ ...imported.fields, id: (0, crypto_1.randomUUID)(), ...(productId ? { productId } : {}) }, intentPath, overwrite, 'intent_import');
+        // A refusal or workspace error from the save layer stands on its own; wrapping it in an
+        // import banner would put a checkmark above a failure.
+        const savedText = saved.content[0]?.text ?? '';
+        if (saved.isError || savedText.startsWith('✗'))
+            return saved;
         return {
             content: [{
                     type: 'text',
                     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']
-                            : []),
+                        `✓ Imported OpenSpec change "${ref.id}" — the change folder was not modified.`,
+                        ...imported.notes.map(n => `  · ${n}`),
+                        '',
+                        savedText,
                     ].join('\n'),
                 }],
         };
@@ -67625,9 +68893,9 @@ function startMcpServer() {
      */
     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. ' +
+        description: 'Resolve an "unconfirmed" readiness dimension, in a local intent.md or in a connected workspace. 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. ' +
+            '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. Waivers are local-mode only: a workspace will not accept one over an API key, which authenticates as a machine. ' +
             '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.'),
@@ -67638,13 +68906,61 @@ function startMcpServer() {
             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.'),
+            path: zod_1.z.string().optional().describe('Local mode only: path to the intent file. Defaults to intent.md.'),
+            intentId: zod_1.z.string().optional().describe('Cloud mode: confirm on a specific saved intent. Defaults to the current intent.'),
         },
-    }, async ({ dimension, action, actor, problem, outcome, observable, reason, humanApproved, path }) => {
+    }, async ({ dimension, action, actor, problem, outcome, observable, reason, humanApproved, path, intentId }) => {
+        /**
+         * Local and cloud differ ONLY in where the spec is read from and where the record is
+         * written. Everything between — which states are confirmable, what a record must name,
+         * how it is anchored — is computed once, so the two modes cannot drift into disagreeing
+         * about what a confirmation means.
+         */
         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.` }] };
+        let existing;
+        let cloudTargetId;
+        if (isLocalMode) {
+            const fromFile = (0, local_reader_1.readIntentFile)(filePath);
+            if (!fromFile) {
+                return { content: [{ type: 'text', text: `✗ No intent file at ${filePath}. Save one with intent_save first, then confirm.` }] };
+            }
+            existing = fromFile;
+        }
+        else {
+            const cloud = requireCloudClient();
+            // Re-read the FULL record. The list projection is a different shape, and grading a
+            // listed row is how the cloud preflight could never pass (mcp-server 1.14.1).
+            const listed = intentId ? undefined : pickCurrentIntent(await cloud.listIntents());
+            cloudTargetId = intentId || listed?.id;
+            const record = cloudTargetId
+                ? await cloud.getIntent(cloudTargetId).catch(() => undefined)
+                : undefined;
+            if (!record) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: intentId
+                                ? `✗ No intent with id "${intentId}" in this workspace.`
+                                : '✗ No intents found in this workspace. Create one first, then confirm.',
+                        }],
+                };
+            }
+            existing = { ...record, confirmations: (record.confirmations ?? []) };
+        }
+        /**
+         * A waiver is a human decision (amendment A), and in cloud mode this process holds an API
+         * KEY. The API refuses `by: 'human'` from a key precisely so an agent cannot mint the
+         * strongest-looking record there is, and a cloud record renders as `authenticated`, so a
+         * forged one would carry weight a local file's never does. Refuse here with the reason
+         * rather than letting the agent discover it as a 422 it cannot act on.
+         */
+        if (!isLocalMode && action === 'waive') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✗ A waiver cannot be recorded through an API key. It is a human decision, and this connection authenticates as a machine, so the workspace will not accept one from it. Confirm ${dimension} instead if the text is there, or waive it from the spec in Pathmode.`,
+                    }],
+            };
         }
         const verdict = (0, readiness_1.computeReadinessVerdict)({ ...existing, confirmations: existing.confirmations });
         const state = verdict.detail[dimension]?.state;
@@ -67677,22 +68993,85 @@ function startMcpServer() {
                     ? { 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');
+        /**
+         * 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.
+         *
+         * READ-MODIFY-WRITE GUARD. The earlier version built the replacement list from the parse
+         * taken at the top of this handler and then spliced it into bytes re-read at write time.
+         * Two agents confirming different dimensions concurrently would each write a list missing
+         * the other's record, so the later writer silently deleted the earlier one. The list is
+         * now rebuilt from the SAME bytes being spliced, and the file is re-read immediately
+         * before writing: if it moved, we start over from the new bytes, once, then refuse.
+         *
+         * This narrows the window rather than closing it. There is no atomic
+         * compare-and-swap on a plain file, and a lockfile is not worth the failure modes it
+         * brings to a local dev tool. The remaining race needs a write landing inside the gap
+         * between the final read and the write itself.
+         */
+        let kept;
+        let where;
+        if (!isLocalMode) {
+            /**
+             * Replace-all column, so the whole list is sent and the caller carries forward what it
+             * read. Fenced on specVersion: a concurrent edit is a 409 rather than a silent
+             * overwrite, which is the same lost-update shape the local splice guard exists for.
+             *
+             * The API independently re-checks the anchor against the stored text and refuses a
+             * confirmation for a field the same request edits. This call sends no field edits at
+             * all, so those checks should pass; if one fails, the spec moved under us and the
+             * message says so rather than retrying into whatever is there now.
+             */
+            kept = existing.confirmations.filter(c => c.dimension !== dimension);
+            const cloud = requireCloudClient();
+            try {
+                await cloud.updateIntent(cloudTargetId, {
+                    confirmations: [...kept, record],
+                    ...(typeof existing.specVersion === 'string' ? { expectedVersion: existing.specVersion } : {}),
+                });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: /409|conflict|changed/i.test(msg)
+                                ? `✗ The intent changed while this confirmation was being written. Re-read it and confirm against the current text.`
+                                : `✗ Could not record the confirmation: ${msg}`,
+                        }],
+                };
+            }
+            where = `intent ${cloudTargetId}`;
+        }
+        else {
+            const writeResult = (0, intent_compiler_1.writeConfirmationRecord)({
+                read: () => (0, fs_1.readFileSync)(filePath, 'utf-8'),
+                write: (content) => (0, fs_1.writeFileSync)(filePath, content, 'utf-8'),
+                dimension,
+                record: record,
+                anchor,
+                anchorOf: (bytes) => (0, readiness_1.fieldDigest)((0, readiness_1.computeReadinessVerdict)((0, local_reader_1.parseIntentMarkdown)(bytes, 'intent')).detail[dimension]?.extracted ?? ''),
+                confirmationsOf: (bytes) => ((0, local_reader_1.parseIntentMarkdown)(bytes, 'intent').confirmations ?? []),
+            });
+            if (!writeResult.ok) {
+                const why = {
+                    DUPLICATE_SECTION: `${filePath} has more than one "## Confirmations" section. The reader takes the last and this writer replaces the first, so a record written now would be invisible. Merge them into one section, then confirm.`,
+                    FIELD_CHANGED: `${dimension} in ${filePath} changed while this confirmation was being written. Re-read the file and confirm against the current text.`,
+                    FILE_CHANGED: `${filePath} kept changing while this confirmation was being written. Nothing was saved. Retry, or check whether another agent is writing the same file.`,
+                }[writeResult.code];
+                return { content: [{ type: 'text', text: `✗ ${why}` }] };
+            }
+            kept = writeResult.kept;
+            where = filePath;
+        }
         const after = (0, readiness_1.computeReadinessVerdict)({ ...existing, confirmations: [...kept, record] });
         return {
             content: [{
                     type: 'text',
                     text: [
-                        `✓ ${dimension} ${action === 'waive' ? 'waived' : 'confirmed'} in ${filePath}`,
+                        `✓ ${dimension} ${action === 'waive' ? 'waived' : 'confirmed'} in ${where}`,
                         `  ${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.' : '',
                         '',
@@ -67701,12 +69080,52 @@ function startMcpServer() {
                 }],
         };
     });
-    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'),
+    server.tool('intent_export', 'Export an intent spec as .cursorrules, a CLAUDE.md or AGENTS.md section, a Claude Managed Agents Outcomes rubric, or an OpenSpec change folder. Use agents-md for Codex, Cursor, and other AGENTS.md-aware agents. Use openspec to hand the intent to an OpenSpec workflow: it writes proposal.md, a spec delta, and the verification contract in tasks.md, placed where the preflight reader finds them, and never writes into an existing change.', {
+        format: zod_1.z.enum(['cursorrules', 'claude-md', 'agents-md', 'outcome-rubric', 'openspec']).describe('Export format'),
         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'),
+        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, AGENTS.md, or openspec/changes/<change-id>'),
     }, async ({ format, spec, path }) => {
         const fields = toIntentFields(spec);
+        if (format === 'openspec') {
+            const change = (0, openspec_writer_1.formatOpenSpecChange)(fields);
+            const baseRel = path || `openspec/changes/${change.changeId}`;
+            const baseAbs = resolveWithinProject(baseRel);
+            /**
+             * Refuse, never merge. A change folder is authored territory: their workflow may have
+             * tasks half-checked and specs mid-review, and "merge" here would mean guessing which
+             * of two proposals is the real one. The refusal names the way out.
+             */
+            if ((0, fs_1.existsSync)(baseAbs)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✗ ${baseRel} already exists. This tool never writes into an existing change. Pass a different path, or archive/remove the old change first.`,
+                        }],
+                };
+            }
+            for (const f of change.files) {
+                const abs = (0, path_1.join)(baseAbs, f.path);
+                (0, fs_1.mkdirSync)((0, path_1.dirname)(abs), { recursive: true });
+                (0, fs_1.writeFileSync)(abs, f.content, 'utf-8');
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            `✓ Exported OpenSpec change "${change.changeId}" to ${baseRel}`,
+                            ...change.files.map(f => `  ${f.path}`),
+                            ...(change.uncoveredRequirements.length ? [
+                                '',
+                                `⚠ OpenSpec requires at least one scenario per requirement, and ${change.uncoveredRequirements.length} requirement(s) have none: ${change.uncoveredRequirements.join('; ')}.`,
+                                '  Their validator will flag these. Add an edge case for each (scenario + expected behavior) rather than inventing one to satisfy the check.',
+                            ] : []),
+                            '',
+                            'The change is readable by the OpenSpec workflow as-is. Verify the emit preserved the verdict:',
+                            `  npx -y @pathmode/cli preflight ${baseRel}`,
+                        ].join('\n'),
+                    }],
+            };
+        }
         if (format === 'cursorrules') {
             const content = (0, intent_compiler_1.formatCursorRules)(fields);
             const filePath = resolveWithinProject(path || '.cursorrules');