@pathmode/cli 2.1.4 → 2.2.0

package/dist/index.js

@@ -16416,6 +16416,44 @@ const gray_matter_1 = __importDefault(__nccwpck_require__(9599));
 const ajv_1 = __importDefault(__nccwpck_require__(2463));
 const api_client_1 = __nccwpck_require__(7475);
 const program = new commander_1.Command();
+/**
+ * The open IntentSpec schema historically described YAML frontmatter, while the
+ * local MCP writer deliberately keeps the editable specification in Markdown
+ * sections. Validate either representation through the same schema: explicit
+ * frontmatter remains authoritative (including invalid values), and parsed body
+ * sections only fill fields that were omitted from frontmatter.
+ *
+ * A body section fills a field only when it actually carried one. The parser is
+ * total — a missing `## Objective` reads back as `''` and missing `## Outcomes`
+ * as `[]` — so filling unconditionally handed the schema a present-but-empty
+ * value and `required` was satisfied by nothing. A spec with no outcomes in
+ * either representation validated clean. Absent in both must stay absent, so the
+ * schema can name the field, which is the same rule constraints, edge cases, and
+ * health metrics already follow below.
+ */
+function buildValidationSubject(content) {
+    const { data } = (0, gray_matter_1.default)(content);
+    const parsed = (0, local_reader_1.parseIntentMarkdown)(content);
+    const outcomes = parsed.outcomes.map(outcome => typeof outcome === 'string' ? outcome : outcome.text);
+    return {
+        ...data,
+        ...(!Object.prototype.hasOwnProperty.call(data, 'objective') && parsed.objective
+            ? { objective: parsed.objective }
+            : {}),
+        ...(!Object.prototype.hasOwnProperty.call(data, 'outcomes') && outcomes.length > 0
+            ? { outcomes }
+            : {}),
+        ...(!Object.prototype.hasOwnProperty.call(data, 'constraints') && parsed.constraints.length > 0
+            ? { constraints: parsed.constraints }
+            : {}),
+        ...(!Object.prototype.hasOwnProperty.call(data, 'edgeCases') && parsed.edgeCases.length > 0
+            ? { edgeCases: parsed.edgeCases }
+            : {}),
+        ...(!Object.prototype.hasOwnProperty.call(data, 'healthMetrics') && parsed.healthMetrics.length > 0
+            ? { healthMetrics: parsed.healthMetrics }
+            : {}),
+    };
+}
 // Detect the GitHub ACTION invocation specifically: action.yml runs dist/index.js with no
 // argv and passes INPUT_FILE through the environment. The old check keyed on GITHUB_ACTIONS
 // alone, which is set for EVERY step of every workflow, so `pathmode preflight <path>` inside
@@ -16442,7 +16480,7 @@ const validateIntent = async (file) => {
     }
     try {
         const content = fs_1.default.readFileSync(filePath, 'utf-8');
-        const { data } = (0, gray_matter_1.default)(content);
+        const data = buildValidationSubject(content);
         const schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, 'schema.json'), 'utf-8'));
         const ajv = new ajv_1.default({ allErrors: true });
         const validate = ajv.compile(schema);
@@ -16906,6 +16944,463 @@ else {
 }
 
 
+/***/ }),
+
+/***/ 229:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+/**
+ * serializeIntentMd — the one implementation of the intent.md file format.
+ *
+ * Two writers used to exist: `lib/agentPromptGenerator.ts` (cloud exports, browser downloads) and
+ * `packages/mcp-server/src/intent-compiler.ts` (every local, keyless write). They diverged in BOTH
+ * directions, and the divergence cost more than tidiness:
+ *
+ *   - the cloud writer emitted no `## Confirmations`, so a human's authenticated confirmation died
+ *     at the boundary and never reached the repo;
+ *   - the local writer emitted no authorization gate, so an agent proposal still pending human
+ *     judgment lost its DO-NOT-IMPLEMENT banner on the next local save.
+ *
+ * Both are the same failure: judgment recorded in one place not travelling to the other. This
+ * module emits the union, and `serializer-parity.test.ts` holds the two callers to it.
+ *
+ * ZERO IMPORTS, deliberately. The local writer is bundled by ncc into a published npm package that
+ * must run keyless and offline, and the cloud writer is reached from `'use client'` components — so
+ * a single node builtin here (`crypto`, say) would break the browser bundle. Callers compute their
+ * own environment-specific values (id minting, readiness verdicts, evidence resolution) and hand
+ * the results in as plain data.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GENERATED_CAPTIONS = exports.VERIFICATION_NOT_DEFINED_CAPTION = exports.VERIFICATION_FEEDBACK_CAPTION = void 0;
+exports.renderOutcomeMeasurementDefinition = renderOutcomeMeasurementDefinition;
+exports.toSerializableChecks = toSerializableChecks;
+exports.renderAuthorizationGateText = renderAuthorizationGateText;
+exports.renderConfirmationsBody = renderConfirmationsBody;
+exports.normalizeCaption = normalizeCaption;
+exports.isGeneratedCaption = isGeneratedCaption;
+exports.serializeIntentMd = serializeIntentMd;
+// ── Small helpers ───────────────────────────────────────────────────────────
+const VERIFICATION_KIND_LABELS = {
+    fastest: 'Fastest check',
+    'shipped-signal': 'Shipped signal',
+    'regression-guard': 'Regression guard',
+    manual: 'Manual check',
+    test: 'Automated test',
+};
+const VERIFICATION_KIND_ORDER = ['fastest', 'shipped-signal', 'regression-guard', 'manual', 'test'];
+const VERIFICATION_KIND_SET = new Set(VERIFICATION_KIND_ORDER);
+function nonEmpty(v) {
+    return typeof v === 'string' && v.trim().length > 0;
+}
+/** YAML double-quoted scalars. Both writers used to interpolate raw, so a product named `The "Real"
+ *  One` produced a file gray-matter could not parse. */
+function yamlScalar(value) {
+    if (typeof value === 'number')
+        return String(value);
+    return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function outcomeOf(o) {
+    return typeof o === 'string' ? { text: o } : o;
+}
+/** Compact, provider-neutral wording shared by every agent-facing export. */
+function renderOutcomeMeasurementDefinition(measurement) {
+    if (!measurement)
+        return '';
+    const { source, expectation, window } = measurement;
+    const target = `${expectation.operator} ${expectation.target}${expectation.unit ? ` ${expectation.unit}` : ''}`;
+    const windowValue = window.kind === 'rolling'
+        ? `${window.kind} ${window.duration}`
+        : window.kind === 'fixed'
+            ? `${window.kind} ${window.start}..${window.end}`
+            : window.kind;
+    return [
+        `measure via ${source.provider} ${source.queryRef.kind}:${source.queryRef.id}`,
+        measurement.resultSelector ? `select ${measurement.resultSelector}` : '',
+        `target ${target}`,
+        `window ${windowValue}`,
+    ].filter(Boolean).join('; ');
+}
+function constraintOf(c) {
+    return typeof c === 'string' ? { text: c } : c;
+}
+/** `backed by:` suffix on its own indented bullet. Empty when nothing resolved, so callers append
+ *  unconditionally. */
+function backedBySuffix(refs, indent = '  ') {
+    const clean = (refs || []).filter(nonEmpty);
+    if (!clean.length)
+        return '';
+    return `\n${indent}- backed by: ${clean.join('; ')}`;
+}
+/** Read verification uniformly as a check collection: canonical `checks[]` plus the legacy
+ *  {manual,unit,e2e} buckets, which are adapted rather than dropped. */
+function toSerializableChecks(v) {
+    if (!v || typeof v !== 'object')
+        return [];
+    const out = [];
+    for (const c of Array.isArray(v.checks) ? v.checks : []) {
+        if (!nonEmpty(c?.description))
+            continue;
+        out.push({
+            kind: VERIFICATION_KIND_SET.has(String(c.kind)) ? String(c.kind) : 'test',
+            description: c.description.trim(),
+            status: c.status,
+            verifies: c.verifies,
+        });
+    }
+    for (const d of Array.isArray(v.manualChecks) ? v.manualChecks : []) {
+        if (nonEmpty(d))
+            out.push({ kind: 'manual', description: d.trim() });
+    }
+    for (const d of Array.isArray(v.unitTests) ? v.unitTests : []) {
+        if (nonEmpty(d))
+            out.push({ kind: 'test', description: d.trim() });
+    }
+    for (const d of Array.isArray(v.e2eTests) ? v.e2eTests : []) {
+        if (nonEmpty(d))
+            out.push({ kind: 'test', description: d.trim() });
+    }
+    return out;
+}
+function groupChecks(v) {
+    const checks = toSerializableChecks(v);
+    return VERIFICATION_KIND_ORDER
+        .map(kind => ({ kind, label: VERIFICATION_KIND_LABELS[kind], checks: checks.filter(c => c.kind === kind) }))
+        .filter(g => g.checks.length > 0);
+}
+function checkLine(c) {
+    const verifies = nonEmpty(c.verifies) ? ` (verifies: ${c.verifies})` : '';
+    const status = nonEmpty(c.status) && c.status !== 'unknown' ? ` [${c.status}]` : '';
+    return `${c.description}${verifies}${status}`;
+}
+// ── The authorization gate ──────────────────────────────────────────────────
+/**
+ * The DO-NOT-IMPLEMENT banner for an agent proposal a human has not authorized.
+ *
+ * Lives here, not in either caller, because the local writer used to omit it entirely: a pending
+ * proposal pulled into a repo and re-saved came back without its gate, which is the one thing in
+ * the file an agent must not be able to lose.
+ *
+ * Trailing blank line included, so callers can prepend unconditionally.
+ */
+function renderAuthorizationGateText(opts) {
+    if (opts.origin !== 'agent' || opts.authorization === 'authorized')
+        return '';
+    if (opts.authorization === 'rejected') {
+        const note = nonEmpty(opts.authorizationNote) ? ` The human's note: "${opts.authorizationNote}".` : '';
+        return `> **REJECTED BY HUMAN REVIEW — DO NOT IMPLEMENT.** This spec was proposed by an agent and a human rejected it.${note} Revise the proposal per the note, or ask your operator before proceeding.\n\n`;
+    }
+    return `> **PENDING HUMAN AUTHORIZATION — DO NOT IMPLEMENT YET.** This spec was proposed by an agent and no human has authorized it. Ask your operator to review it in Pathmode before building against it.\n\n`;
+}
+// ── Confirmations ───────────────────────────────────────────────────────────
+/**
+ * Render confirmation records as the `## Confirmations` section body.
+ *
+ * Derived fields (`assurance`, `source`) are NOT written: anything read back out of a file is
+ * local-unverified by definition, so persisting a trust level would let a record vouch for itself.
+ * Records outside the dimensions the readiness gate can resolve are dropped rather than emitted,
+ * so an unwaivable dimension never leaves an empty section behind.
+ */
+function renderConfirmationsBody(records) {
+    const emittable = (records || []).filter(c => {
+        const dim = String(c?.dimension ?? '').toLowerCase();
+        const kind = String(c?.kind ?? '').toLowerCase();
+        const by = String(c?.by ?? '').toLowerCase();
+        return ['objective', 'outcomes'].includes(dim)
+            && ['confirmed', 'waived'].includes(kind)
+            && ['agent', 'human'].includes(by);
+    });
+    if (!emittable.length)
+        return '';
+    const out = ['## Confirmations'];
+    for (const c of emittable) {
+        out.push('');
+        out.push(`**${String(c.dimension).toLowerCase()}** — ${String(c.kind).toLowerCase()} by ${String(c.by).toLowerCase()}`);
+        for (const key of ['actor', 'problem', 'outcome', 'observable', 'reason', 'anchor', 'at']) {
+            const v = c[key];
+            if (!nonEmpty(v))
+                continue;
+            out.push(`- ${key}: ${v.replace(/\s+/g, ' ').trim()}`);
+        }
+    }
+    return out.join('\n');
+}
+// ── The serializer ──────────────────────────────────────────────────────────
+/**
+ * Frontmatter key order. Fixed so a file rewritten by the other implementation produces a clean
+ * diff instead of a reordering churn that hides the real change.
+ */
+const FRONTMATTER_ORDER = [
+    'id', 'version', 'status', 'readiness', 'source', 'specVersion',
+    'origin', 'authorization', 'authorizationNote', 'outcomeMeasurements',
+    'evidence', 'space', 'severity', 'created', 'updated',
+];
+/**
+ * Captions this codebase writes into an intent.md, as opposed to anything an author wrote.
+ *
+ * A caption is prose under a heading that is NOT content: it explains the section rather than
+ * recording a decision. The readers exclude exactly these strings, which is why they live here,
+ * next to the code that emits them, and are imported rather than retyped. Excluding "all italic
+ * prose" instead was wrong: an author writing `*Must not slow down page load.*` under
+ * Constraints means it, and reporting that section as absent is the accusation the four-state
+ * gate exists to stop making.
+ *
+ * Adding a caption anywhere means adding it here, or the reader will grade it as content.
+ */
+exports.VERIFICATION_FEEDBACK_CAPTION = '_A feedback loop, not just a test list._';
+/** Written by lib/scan/draftIntentMd.ts when a pre-account draft has no verification yet. */
+exports.VERIFICATION_NOT_DEFINED_CAPTION = '_Not defined yet. Nothing in this spec has been checked against a running system._';
+exports.GENERATED_CAPTIONS = [
+    exports.VERIFICATION_FEEDBACK_CAPTION,
+    exports.VERIFICATION_NOT_DEFINED_CAPTION,
+];
+/** Trim, drop one layer of surrounding `_` or `*`, casefold. Both emphasis spellings match. */
+function normalizeCaption(line) {
+    return line
+        .trim()
+        .replace(/^([_*])(.*)\1$/s, '$2')
+        .trim()
+        .toLowerCase();
+}
+const NORMALIZED_CAPTIONS = new Set(exports.GENERATED_CAPTIONS.map(normalizeCaption));
+/** True only for a caption this codebase generated. Author prose, italic or not, is content. */
+function isGeneratedCaption(line) {
+    return NORMALIZED_CAPTIONS.has(normalizeCaption(line));
+}
+function serializeIntentMd(spec, opts = {}) {
+    const outcomeMeasurements = (spec.outcomes || [])
+        .map(outcomeOf)
+        .map((outcome, index) => outcome.measurement ? { outcome: index, ...outcome.measurement } : null)
+        .filter((entry) => entry !== null);
+    const values = {
+        id: spec.id,
+        version: opts.version && opts.version >= 1 ? opts.version : 1,
+        status: opts.status || 'draft',
+        readiness: opts.readiness,
+        source: opts.source,
+        specVersion: opts.specVersion,
+        origin: opts.origin,
+        // Only meaningful for agent-originated specs; human-authored ones are authorized by
+        // authorship and carrying a key here would imply a gate that does not exist.
+        authorization: opts.origin === 'agent' ? (opts.authorization ?? 'pending') : undefined,
+        // The banner renders the note as prose, but prose is not recoverable: a reader cannot tell
+        // the reviewer's words from the sentence around them. Persisting it here is what stops a
+        // local rewrite from keeping the REJECTED verdict while erasing the correction it asked
+        // for. Single-line by contract, like a confirmation value; flattened rather than escaped.
+        authorizationNote: opts.origin === 'agent' && nonEmpty(opts.authorizationNote)
+            ? opts.authorizationNote.replace(/\s+/g, ' ').trim()
+            : undefined,
+        // Body outcomes stay plain, interoperable list items. The optional recipe is a generic
+        // extension in frontmatter, keyed by outcome position so old readers simply ignore it.
+        outcomeMeasurements: outcomeMeasurements.length ? outcomeMeasurements : undefined,
+        evidence: opts.evidence?.length || undefined,
+        space: opts.space?.name,
+        severity: opts.severity,
+        created: opts.created,
+        updated: opts.updated,
+    };
+    // null, not just undefined: the cloud mapper reads absent columns as null (`problemSeverity`,
+    // `currentState`, a product with no name), and an unguarded null reached the quoter as a
+    // crash rather than an omitted key.
+    const yamlLines = FRONTMATTER_ORDER
+        .filter(key => values[key] !== undefined && values[key] !== null && values[key] !== '')
+        .map(key => {
+        const value = values[key];
+        return `${key}: ${typeof value === 'object' ? JSON.stringify(value) : yamlScalar(value)}`;
+    })
+        .join('\n');
+    const sections = ['---', yamlLines, '---', ''];
+    // Directly under the frontmatter: the `authorization` key is machine-readable, but the body
+    // must also say DO NOT IMPLEMENT before any instruction an agent might act on.
+    const gate = renderAuthorizationGateText(opts).trim();
+    if (gate) {
+        sections.push(gate);
+        sections.push('');
+    }
+    sections.push(`# ${spec.title || 'Untitled Intent'}`);
+    const space = opts.space;
+    if (space && (nonEmpty(space.productVision) || nonEmpty(space.northStar) || nonEmpty(space.targetAudience)
+        || space.constraints?.length || space.principles?.length)) {
+        sections.push('');
+        sections.push('## Space Context');
+        if (nonEmpty(space.productVision))
+            sections.push(`**Product Vision**: ${space.productVision}`);
+        if (nonEmpty(space.northStar))
+            sections.push(`**North Star**: ${space.northStar}`);
+        if (nonEmpty(space.targetAudience))
+            sections.push(`**Target Audience**: ${space.targetAudience}`);
+        if (space.constraints?.length)
+            sections.push('**Constraints**: ' + space.constraints.join(', '));
+        if (space.principles?.length)
+            sections.push('**Principles**: ' + space.principles.join(', '));
+    }
+    if (nonEmpty(spec.objective)) {
+        sections.push('');
+        sections.push('## Objective');
+        sections.push(spec.objective);
+    }
+    // Heading text is the round-trip key (the reader keys sections by exact heading) — keep it
+    // plain, exactly like Objective above.
+    if (nonEmpty(spec.currentState)) {
+        sections.push('');
+        sections.push('## Current State');
+        sections.push(spec.currentState.trim());
+    }
+    // Sits next to Current State on purpose: one is what the author says is true today, the other
+    // is what the repo says. Same heading in both modes, so a handoff reads identically either way.
+    const icBody = implementationContextBody(spec);
+    if (icBody.length) {
+        sections.push('');
+        sections.push('## Implementation Context');
+        sections.push(...icBody);
+    }
+    const decisions = (spec.decisions || []).filter(d => d && nonEmpty(d.choice) && typeof d.reason === 'string');
+    if (decisions.length) {
+        sections.push('');
+        sections.push('## Decisions & Ruled-Out Alternatives');
+        for (const d of decisions) {
+            sections.push(`- **${d.choice}**${nonEmpty(d.ruledOut) ? ` (instead of: ${d.ruledOut})` : ''} — ${d.reason}`);
+            if (nonEmpty(d.reopenTrigger))
+                sections.push(`  - reopen if: ${d.reopenTrigger.trim()}`);
+        }
+    }
+    const outcomes = (spec.outcomes || []).map(outcomeOf).filter(o => nonEmpty(o.text));
+    if (outcomes.length) {
+        sections.push('');
+        sections.push('## Outcomes');
+        // No priority prefix. The writer used to emit `[MUST] `, which is in neither SPEC.md nor the
+        // normalization corpus, and neither parser strips it — so it read back as part of the
+        // outcome text. Emitting a label the format cannot read back is worse than omitting it.
+        for (const o of outcomes) {
+            sections.push(`- [ ] ${o.text}${backedBySuffix(o.backedBy)}`);
+        }
+    }
+    if (spec.scope?.inScope?.length || spec.scope?.outOfScope?.length) {
+        sections.push('');
+        sections.push('## Scope');
+        if (spec.scope.inScope?.length) {
+            sections.push('**In scope:**');
+            for (const s of spec.scope.inScope)
+                sections.push(`- ${s}`);
+        }
+        if (spec.scope.outOfScope?.length) {
+            sections.push('**Out of scope:**');
+            for (const s of spec.scope.outOfScope)
+                sections.push(`- ${s}`);
+        }
+    }
+    const constraints = (spec.constraints || []).map(constraintOf).filter(c => nonEmpty(c.text));
+    if (constraints.length) {
+        sections.push('');
+        sections.push('## Constraints');
+        for (const c of constraints)
+            sections.push(`- ${c.text}${backedBySuffix(c.backedBy)}`);
+    }
+    const edgeCases = (spec.edgeCases || []).filter(ec => ec && nonEmpty(ec.scenario));
+    if (edgeCases.length) {
+        sections.push('');
+        sections.push('## Edge Cases');
+        for (const ec of edgeCases) {
+            sections.push(`- **${ec.scenario}**: ${ec.expectedBehavior}${backedBySuffix(ec.backedBy)}`);
+        }
+    }
+    const evidenceBody = renderCompactEvidence(opts.evidence);
+    if (evidenceBody.length) {
+        sections.push('');
+        sections.push('## Supporting Evidence');
+        sections.push(...evidenceBody);
+    }
+    if (spec.healthMetrics?.length) {
+        sections.push('');
+        sections.push('## Health Metrics');
+        for (const metric of spec.healthMetrics)
+            sections.push(`- ${metric}`);
+    }
+    const checkGroups = groupChecks(spec.verification);
+    if (checkGroups.length) {
+        sections.push('');
+        sections.push('## Verification');
+        sections.push(exports.VERIFICATION_FEEDBACK_CAPTION);
+        for (const g of checkGroups) {
+            sections.push(`**${g.label}**:`);
+            for (const c of g.checks)
+                sections.push(`- [ ] ${checkLine(c)}`);
+        }
+    }
+    // `## Confirmations` is emitted LAST so it never sits between the fields a reader is comparing,
+    // and so appending one cannot shift any other section's parse.
+    const confirmationsBody = renderConfirmationsBody(spec.confirmations);
+    if (confirmationsBody) {
+        sections.push('');
+        sections.push(confirmationsBody);
+    }
+    return sections.join('\n');
+}
+/**
+ * The body of `## Implementation Context`.
+ *
+ * Two sources, one section. Local mode carries prose the agent gathered; cloud intents carry the
+ * analyzer's structured object. Rendering both under the same heading is what lets a spec move
+ * between modes without the section disappearing on the way through.
+ */
+function implementationContextBody(spec) {
+    if (nonEmpty(spec.implementationContextText))
+        return [spec.implementationContextText.trim()];
+    const ic = spec.implementationContext;
+    if (!ic)
+        return [];
+    const lines = [];
+    if (ic.relevantAreas?.length) {
+        lines.push('### Relevant areas');
+        for (const a of ic.relevantAreas) {
+            if (nonEmpty(a?.path))
+                lines.push(`- \`${a.path}\`${nonEmpty(a.reason) ? ` — ${a.reason}` : ''}`);
+        }
+    }
+    if (nonEmpty(ic.currentBehavior)) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Current behavior');
+        lines.push(ic.currentBehavior.trim());
+    }
+    if (ic.risks?.length) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Risks');
+        for (const r of ic.risks)
+            if (nonEmpty(r))
+                lines.push(`- ${r.trim()}`);
+    }
+    if (ic.verificationSuggestions?.length) {
+        if (lines.length)
+            lines.push('');
+        lines.push('### Verification suggestions');
+        for (const v of ic.verificationSuggestions)
+            if (nonEmpty(v))
+                lines.push(`- ${v.trim()}`);
+    }
+    return lines;
+}
+/** Compact evidence list — one truncated line per item, quotes as blockquotes. Lighter than the
+ *  execution prompt's full rendering so a committed intent.md stays readable. */
+function renderCompactEvidence(evidence) {
+    const items = (evidence || []).filter(e => nonEmpty(e?.content));
+    if (!items.length)
+        return [];
+    const lines = [];
+    const truncate = (s) => (s.length > 160 ? `${s.slice(0, 160)}…` : s);
+    for (const q of items.filter(e => e.type === 'quote')) {
+        lines.push(`> "${truncate(q.content)}"${nonEmpty(q.source) ? ` — ${q.source}` : ''}`);
+    }
+    for (const e of items.filter(e => e.type !== 'quote')) {
+        const severity = nonEmpty(e.severity) ? ` (${e.severity})` : '';
+        lines.push(`- [${e.type}]${severity} ${truncate(e.content)}${nonEmpty(e.source) ? ` — ${e.source}` : ''}`);
+    }
+    return lines;
+}
+
+
 /***/ }),
 
 /***/ 8963:
@@ -16936,6 +17431,7 @@ const fs_1 = __importDefault(__nccwpck_require__(9896));
 const path_1 = __importDefault(__nccwpck_require__(6928));
 const gray_matter_1 = __importDefault(__nccwpck_require__(2702));
 const measurement_schema_1 = __nccwpck_require__(2642);
+const serializeIntentMd_1 = __nccwpck_require__(229);
 const CONFIRMATION_HEADER_RE = /^\*\*(objective|outcomes)\*\*\s*[—–-]\s*(confirmed|waived)\s+by\s+(agent|human)\s*$/i;
 const CONFIRMATION_FIELD_RE = /^\s*[-*]\s+(actor|problem|outcome|observable|reason|anchor|at)\s*:\s*(.+)$/i;
 /**
@@ -17109,7 +17605,6 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
     const { data, content: rawBody } = (0, gray_matter_1.default)(content);
     const body = stripHtmlComments(stripFencedBlocks(rawBody));
     const sections = splitSections(body);
-    const parsedVerification = extractVerification(sections);
     // The public schema allows verification as a flat string array; read it as manual checks
     // rather than silently producing {} (the same adapter normalizeSpecForReadiness applies).
     const frontmatterVerification = Array.isArray(data.verification)
@@ -17117,9 +17612,16 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
         : data.verification && typeof data.verification === 'object'
             ? data.verification
             : null;
-    const verification = hasVerificationContent(parsedVerification)
-        ? parsedVerification
-        : (frontmatterVerification || {});
+    // Same precedence as every other section: body list, then frontmatter, then body prose.
+    const verificationAll = extractVerification(sections);
+    const verificationHasList = hasVerificationContent(extractVerification(sections, { includeProse: false }));
+    const verification = verificationHasList
+        ? verificationAll
+        : frontmatterVerification && hasVerificationContent(frontmatterVerification)
+            ? frontmatterVerification
+            : hasVerificationContent(verificationAll)
+                ? verificationAll
+                : (frontmatterVerification || {});
     const version = Number(data.version);
     return {
         id: data.id || fallbackId,
@@ -17131,11 +17633,19 @@ function parseIntentMarkdown(content, fallbackId = 'intent') {
         title: data.title || data.userGoal || extractTitle(body) || 'Untitled Intent',
         stageName: data.stage || undefined,
         severity: data.severity || undefined,
-        outcomes: attachOutcomeMeasurements(preferSection(extractListSection(sections, 'Outcomes'), data.outcomes), data.outcomeMeasurements),
+        outcomes: attachOutcomeMeasurements(preferListThenFrontmatter(sections, 'Outcomes', data.outcomes), data.outcomeMeasurements),
         decisions: extractDecisions(sections),
-        constraints: preferSection(extractListSection(sections, 'Constraints'), data.constraints),
-        edgeCases: (() => { const fromBody = extractEdgeCases(sections); return fromBody.length ? fromBody : frontmatterEdgeCases(data.edgeCases); })(),
-        healthMetrics: preferSection(extractListSection(sections, 'Health Metrics'), data.healthMetrics),
+        constraints: preferListThenFrontmatter(sections, 'Constraints', data.constraints),
+        edgeCases: (() => {
+            const all = extractEdgeCases(sections);
+            if (extractEdgeCases(sections, { includeProse: false }).length)
+                return all;
+            const fromFrontmatter = frontmatterEdgeCases(data.edgeCases);
+            if (fromFrontmatter.length)
+                return fromFrontmatter;
+            return all;
+        })(),
+        healthMetrics: preferListThenFrontmatter(sections, 'Health Metrics', data.healthMetrics),
         scope: extractScope(sections) || undefined,
         verification,
         confirmations: extractConfirmations(sections),
@@ -17249,17 +17759,115 @@ function stripListMarker(line) {
 function isListItem(line) {
     return /^\s*[-*]\s/.test(line);
 }
-function extractListSection(sections, heading) {
-    return sectionLines(sections, heading)
-        .filter(isListItem)
-        .map(stripListMarker)
-        .filter(Boolean);
+/**
+ * Structure and generated captions are not content; everything else under a heading is.
+ *
+ * Two distinct exclusions, and they are not the same rule:
+ *
+ * A heading line is structure. `splitSections` only opens a section on `^## `, so a `### Regression
+ * checks` subheading falls through as a body line, and treating it as prose made the HEADING an
+ * executable check: a `## Verification` containing nothing but subheadings passed the gate.
+ *
+ * A generated caption is ours, not the author's, and the registry in serializeIntentMd.ts names
+ * exactly which strings those are. This deliberately does NOT exclude all italic prose: an author
+ * writing `*Must not slow down page load.*` under Constraints means it, and reporting that section
+ * as absent is the accusation the four-state gate exists to stop making.
+ */
+function isNotContent(line) {
+    return /^#{1,6}\s/.test(line.trim()) || (0, serializeIntentMd_1.isGeneratedCaption)(line);
+}
+/**
+ * Items in a section, preserving what the author actually wrote.
+ *
+ * List items keep their existing boundaries: one item per marker, with an indented
+ * continuation line folded into the item it wraps. A run of unindented non-list lines is one
+ * paragraph, and one paragraph is one item; blank lines separate paragraphs. Prose is never
+ * split into sentences, so an author who writes two independently checkable outcomes as two
+ * paragraphs gets two items and one who writes them as a single block gets one.
+ *
+ * Before this, a `.filter(isListItem)` dropped every prose line here and the gates then
+ * reported the section as `absent`, which told an author who had written a constraint in prose
+ * that they had written nothing. Preserving the text is what lets readiness say `unconfirmed`
+ * and quote it back instead. The gates themselves are unchanged: nothing about the parse
+ * relaxes a threshold, and a formatting choice never earns a pass it would not otherwise get.
+ */
+function extractItemsSection(sections, heading, { includeProse = true } = {}) {
+    const items = [];
+    let paragraph = [];
+    let lastWasListItem = false;
+    const flushParagraph = () => {
+        const text = paragraph.join(' ').replace(/\s+/g, ' ').trim();
+        if (text)
+            items.push(text);
+        paragraph = [];
+    };
+    for (const line of sectionLines(sections, heading)) {
+        if (!line.trim()) {
+            flushParagraph();
+            lastWasListItem = false;
+            continue;
+        }
+        // Structure and generated captions are checked FIRST, so neither can be folded into the
+        // item above it or accumulated into a paragraph. A subheading is not a wrapped bullet.
+        if (isNotContent(line)) {
+            flushParagraph();
+            lastWasListItem = false;
+            continue;
+        }
+        if (isListItem(line)) {
+            flushParagraph();
+            const text = stripListMarker(line);
+            lastWasListItem = Boolean(text);
+            if (text)
+                items.push(text);
+            continue;
+        }
+        // A non-blank line straight after a list item is that item's wrapped text, not a new
+        // item. Markdown lazy continuation does not require indentation, and requiring it let a
+        // hard-wrapped bullet split into two items: wrapping must never manufacture an outcome
+        // that clears the two-outcome gate. A blank line is what ends an item. This runs
+        // whatever `includeProse` says, because wrapped text belongs to the list item, not to
+        // the prose the flag governs.
+        if (lastWasListItem && items.length) {
+            items[items.length - 1] = `${items[items.length - 1]} ${line.trim()}`.replace(/\s+/g, ' ');
+            continue;
+        }
+        if (!includeProse) {
+            flushParagraph();
+            lastWasListItem = false;
+            continue;
+        }
+        lastWasListItem = false;
+        paragraph.push(line.trim());
+    }
+    flushParagraph();
+    return items;
 }
 /**
  * Parse `## Decisions & Ruled-Out Alternatives` entries written by `decisionLines()`:
  *   - **choice** (instead of: ruledOut) — reason
  * The separator is an em dash when written by us; a plain hyphen is accepted for hand-edited files.
  */
+/**
+ * A section that has list items owns the field, prose included. A section that is prose only
+ * yields to frontmatter, and is read only when there is no frontmatter to yield to.
+ *
+ * The middle step is the published normalization rule, conformance case "list fallback: a
+ * section with no list items does not override frontmatter": prose under a heading must not
+ * erase a structured frontmatter value. It is a rule about OVERRIDE, not about ignoring prose,
+ * so a section mixing a bullet and a paragraph keeps both. The last step is the defect this
+ * change exists for: with nothing in frontmatter either, prose used to vanish and the gate
+ * reported the section as `absent`, telling the author they had written nothing.
+ */
+function preferListThenFrontmatter(sections, heading, fromFrontmatter) {
+    const all = extractItemsSection(sections, heading);
+    if (extractItemsSection(sections, heading, { includeProse: false }).length)
+        return all;
+    const frontmatter = preferSection([], fromFrontmatter);
+    if (frontmatter.length)
+        return frontmatter;
+    return all;
+}
 function extractDecisions(sections) {
     const out = [];
     for (const line of sectionLines(sections, DECISIONS_HEADING)) {
@@ -17278,12 +17886,11 @@ function extractDecisions(sections) {
     }
     return out;
 }
-function extractEdgeCases(sections) {
+function extractEdgeCases(sections, opts = {}) {
     const cases = [];
-    for (const line of sectionLines(sections, 'Edge Cases')) {
-        if (!isListItem(line))
-            continue;
-        const clean = stripListMarker(line);
+    // Items come from the shared reader, so a prose paragraph is an item exactly as a bullet is
+    // and the pair patterns below are applied to both. Nothing here depends on the formatting.
+    for (const clean of extractItemsSection(sections, 'Edge Cases', opts)) {
         // Pattern: **scenario**: expected behavior
         const match = clean.match(/^\*\*(.+?)\*\*:\s*(.+)$/);
         if (match) {
@@ -17297,7 +17904,13 @@ function extractEdgeCases(sections) {
         const arrowMatch = clean.match(/^(.+?)\s*(?:->|→|:)\s*(.+)$/);
         if (arrowMatch) {
             cases.push({ scenario: arrowMatch[1].trim(), expectedBehavior: arrowMatch[2].trim() });
+            continue;
         }
+        // No pair in it. Keep the scenario so readiness can quote it back and ask for the
+        // expected behavior, and leave `expectedBehavior` empty: the gate requires both, so an
+        // unpaired item cannot pass, and no behavior is invented for the author. Dropping it,
+        // which is what happened before, reported the section as absent instead.
+        cases.push({ scenario: clean, expectedBehavior: '' });
     }
     return cases;
 }
@@ -17381,7 +17994,7 @@ function parseVerificationLabel(line) {
  * ("E2E Tests", "Unit Tests", "Manual Checks") keep their string-array buckets, which
  * `toVerificationChecks()` in intent-compiler.ts adapts on read.
  */
-function extractVerification(sections) {
+function extractVerification(sections, { includeProse = true } = {}) {
     const lines = sectionLines(sections, 'Verification');
     if (lines.length === 0)
         return {};
@@ -17389,9 +18002,55 @@ function extractVerification(sections) {
     let currentKind = null;
     let currentLegacy = null;
     let sawLabel = false;
+    // Prose is preserved here on the same terms as everywhere else: a run of unindented
+    // non-list lines is one paragraph and one check, attributed to the bucket it was written
+    // under, and an indented wrap folds into the check above it rather than becoming a check of
+    // its own. A bullet parses exactly as it did before.
+    const paragraph = [];
+    // A holder, not a bare `let`: TypeScript narrows a variable assigned only inside
+    // closures down to its initializer, and the call below then reads as `never`.
+    const last = { append: null };
+    const pushText = (text) => {
+        if (currentKind) {
+            const { description, status, verifies } = parseCheckLine(text);
+            if (!description) {
+                last.append = null;
+                return;
+            }
+            const check = { kind: currentKind, description };
+            if (status)
+                check.status = status;
+            if (verifies)
+                check.verifies = verifies;
+            (result.checks ||= []).push(check);
+            last.append = (extra) => { check.description = `${check.description} ${extra}`.replace(/\s+/g, ' '); };
+            return;
+        }
+        const bucket = currentLegacy
+            ? (result[currentLegacy] ||= [])
+            // IntentSpec labels are optional. Treat an ungrouped item as a manual check so a
+            // valid flat `## Verification` section survives adoption instead of disappearing.
+            : sawLabel ? null : (result.manualChecks ||= []);
+        if (!bucket) {
+            last.append = null;
+            return;
+        }
+        bucket.push(text);
+        last.append = (extra) => { bucket[bucket.length - 1] = `${bucket[bucket.length - 1]} ${extra}`.replace(/\s+/g, ' '); };
+    };
+    const flushParagraph = () => {
+        const text = paragraph.join(' ').replace(/\s+/g, ' ').trim();
+        paragraph.length = 0;
+        if (text)
+            pushText(text);
+    };
     for (const line of lines) {
         const label = parseVerificationLabel(line);
         if (label) {
+            // Flush before switching buckets so the paragraph lands under the label it was
+            // written beneath, not the next one.
+            flushParagraph();
+            last.append = null;
             sawLabel = true;
             const kind = VERIFICATION_LABEL_TO_KIND[label.toLowerCase()];
             if (kind) {
@@ -17412,31 +18071,41 @@ function extractVerification(sections) {
             currentLegacy = null;
             continue;
         }
-        if (!isListItem(line))
+        if (!line.trim()) {
+            flushParagraph();
+            last.append = null;
             continue;
-        const text = stripListMarker(line);
-        if (!text)
+        }
+        // Structure first, so a `### Regression checks` subheading under `## Verification` can
+        // neither become a check of its own nor be folded into the check above it. It used to
+        // become one, and a Verification section holding nothing but subheadings passed.
+        if (isNotContent(line)) {
+            flushParagraph();
+            last.append = null;
             continue;
-        if (currentKind) {
-            const { description, status, verifies } = parseCheckLine(text);
-            if (!description)
+        }
+        if (isListItem(line)) {
+            flushParagraph();
+            const text = stripListMarker(line);
+            if (!text) {
+                last.append = null;
                 continue;
-            const check = { kind: currentKind, description };
-            if (status)
-                check.status = status;
-            if (verifies)
-                check.verifies = verifies;
-            (result.checks ||= []).push(check);
+            }
+            pushText(text);
+            continue;
         }
-        else if (currentLegacy) {
-            result[currentLegacy].push(text);
+        // Lazy continuation, as above: a wrapped check is one check.
+        if (last.append) {
+            last.append(line.trim());
+            continue;
         }
-        else if (!sawLabel) {
-            // IntentSpec labels are optional. Treat an ungrouped list as manual checks so a valid
-            // flat `## Verification` section survives adoption instead of silently disappearing.
-            (result.manualChecks ||= []).push(text);
+        if (!includeProse) {
+            flushParagraph();
+            continue;
         }
+        paragraph.push(line.trim());
     }
+    flushParagraph();
     return result;
 }
 function hasVerificationContent(v) {
@@ -17753,7 +18422,7 @@ function readOpenSpecChangeForPathmode(ref, io = {}) {
  * https://preflight.pathmode.io, so keep it true.
  */
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.READINESS_GATE_ORDER = exports.READINESS_BLOCKER_DESCRIPTIONS = void 0;
+exports.READINESS_GATE_ORDER = exports.READINESS_OUTCOMES_TOO_FEW_BLOCKER = exports.READINESS_BLOCKER_DESCRIPTIONS = void 0;
 exports.coerceText = coerceText;
 exports.asArray = asArray;
 exports.isTitleMeaningful = isTitleMeaningful;
@@ -17761,6 +18430,7 @@ exports.isConstraintConcrete = isConstraintConcrete;
 exports.isVerificationCheckSubstantive = isVerificationCheckSubstantive;
 exports.isObjectiveSpecific = isObjectiveSpecific;
 exports.isOutcomeMeasurable = isOutcomeMeasurable;
+exports.readinessBlockerFor = readinessBlockerFor;
 exports.normalizeAnchor = normalizeAnchor;
 exports.fieldDigest = fieldDigest;
 exports.computeReadinessVerdict = computeReadinessVerdict;
@@ -17880,6 +18550,18 @@ exports.READINESS_BLOCKER_DESCRIPTIONS = {
     edgeCases: 'No edge case with a defined expected behavior.',
     verification: 'No concrete verification — describe at least one check specific enough to run.',
 };
+/**
+ * MIRROR of `OUTCOMES_TOO_FEW_BLOCKER` in lib/intentReadiness.ts; see its comment for why the
+ * outcomes gate needs two messages. The threshold is unchanged.
+ */
+exports.READINESS_OUTCOMES_TOO_FEW_BLOCKER = 'Fewer than two outcomes. Name at least two, one per line or paragraph, so each can be checked on its own.';
+function readinessBlockerFor(key, spec) {
+    if (key !== 'outcomes')
+        return exports.READINESS_BLOCKER_DESCRIPTIONS[key];
+    return asArray(spec.outcomes).map(o => outcomeText(o).trim()).filter(Boolean).length < 2
+        ? exports.READINESS_OUTCOMES_TOO_FEW_BLOCKER
+        : exports.READINESS_BLOCKER_DESCRIPTIONS.outcomes;
+}
 /** Display order for the gate strip (title first, matching the Preflight page). */
 // ── Confirmation anchoring ──────────────────────────────────────────────────
 /**
@@ -18059,7 +18741,7 @@ function computeReadinessVerdict(spec) {
     };
     const failingBlockers = BLOCKER_ORDER
         .filter(k => !signals[k])
-        .map(k => exports.READINESS_BLOCKER_DESCRIPTIONS[k]);
+        .map(k => readinessBlockerFor(k, spec));
     // What the reader read, per dimension, independent of whether the heuristic accepted it.
     // Placeholder text is deliberately not extracted: no path from a blank spec to confirmable.
     const objectiveText = coerceText(spec.objective).trim();
@@ -18077,11 +18759,14 @@ function computeReadinessVerdict(spec) {
     const detail = {};
     for (const key of exports.READINESS_GATE_ORDER) {
         const text = extractedBy[key] ?? '';
+        // Only when it OVERRIDES the static message, so the common shape is untouched.
+        const resolved = readinessBlockerFor(key, spec);
+        const override = resolved && resolved !== exports.READINESS_BLOCKER_DESCRIPTIONS[key] ? { blocker: resolved } : {};
         detail[key] = signals[key]
             ? { state: 'pass', ...(text ? { extracted: text } : {}) }
             : text
-                ? { state: 'unconfirmed', extracted: text }
-                : { state: 'absent' };
+                ? { state: 'unconfirmed', extracted: text, ...override }
+                : { state: 'absent', ...override };
     }
     // Confirmations only ever move a dimension the heuristics already failed; `signals` is never
     // mutated, so the lexical verdict stays visible underneath.
@@ -18139,15 +18824,36 @@ function formatReadinessFrontmatter(verdict) {
  * The extra line an `unconfirmed` dimension earns: what was read, and an honest statement of
  * what the check could not find in it.
  *
- * Only objective and outcomes appear here, and that scoping is the finding, not caution. The
- * audit measured that most failures on those two are false negatives from a fixed English
- * vocabulary. Verification's measured misses were all extraction failures, so quoting text
- * back there would imply a confidence the evidence does not support.
+ * Objective and outcomes get the SOFTENED copy, and that scoping is the finding, not caution:
+ * the audit measured that most failures on those two are false negatives from a fixed English
+ * vocabulary, so telling those authors the text may be fine is honest.
+ *
+ * Constraints, edge cases and verification get a hint too, but a plainer one. Their measured
+ * misses were extraction failures, and the audit never measured their lexical recall, so the
+ * copy states what was read and what is missing from it and stops there. It does not say the
+ * check is probably wrong, because for these three there is no evidence that it is. They earn
+ * a hint at all only because the parser now preserves prose: before that, an unread section
+ * reached this code as `absent`, there was nothing extracted to quote, and the reader was told
+ * it had written nothing.
  */
 const UNCONFIRMED_HINT = {
     objective: 'Read this, but could not confirm an affected actor and a concrete problem in it. If it already names them, this check reads a fixed vocabulary and may be missing valid phrasing:',
     outcomes: 'Read these, but could not confirm an observable threshold in enough of them. If they are already observable, this check reads a fixed vocabulary and may be missing valid phrasing:',
+    constraints: 'Read this, but could not confirm a hard limit in it. A constraint names something that must never happen:',
+    edgeCases: 'Read this, but no expected behavior was paired with it. Write the case as "situation: what should happen", one per line or paragraph:',
+    verification: 'Read this, but could not confirm a check specific enough to run. A check names a command or a stated expected result:',
 };
+/**
+ * The hint has to follow the blocker that was actually chosen. When outcomes failed on COUNT,
+ * the measurability hint contradicted the line directly above it and accused wording the
+ * detector had accepted.
+ */
+function unconfirmedHintFor(key, d) {
+    if (key === 'outcomes' && d?.blocker === exports.READINESS_OUTCOMES_TOO_FEW_BLOCKER) {
+        return 'Read this. If it holds more than one outcome, separate them so each can be checked on its own:';
+    }
+    return UNCONFIRMED_HINT[key];
+}
 /** Keep a quoted extraction to one readable line; the full text is in verdict.detail. */
 function truncateForQuote(text, max = 160) {
     const flat = text.replace(/\s+/g, ' ').trim();
@@ -18199,10 +18905,11 @@ repairHint) {
         for (const key of BLOCKER_ORDER) {
             if (verdict.signals[key] || resolved(key) === 'pass' || resolved(key) === 'not_applicable')
                 continue;
-            lines.push(`  ✗ ${exports.READINESS_BLOCKER_DESCRIPTIONS[key]}`);
+            lines.push(`  ✗ ${verdict.detail?.[key]?.blocker ?? exports.READINESS_BLOCKER_DESCRIPTIONS[key]}`);
             const d = verdict.detail?.[key];
-            if (d?.state === 'unconfirmed' && d.extracted && UNCONFIRMED_HINT[key]) {
-                lines.push(`    ↳ ${UNCONFIRMED_HINT[key]}`);
+            const hint = unconfirmedHintFor(key, d);
+            if (d?.state === 'unconfirmed' && d.extracted && hint) {
+                lines.push(`    ↳ ${hint}`);
                 lines.push(`      "${truncateForQuote(d.extracted)}"`);
             }
         }
@@ -29964,7 +30671,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"$schema":"http://json-schema.org/dra
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"2.1.4"};
+module.exports = {"rE":"2.2.0"};
 
 /***/ })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pathmode/cli",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "publishConfig": {
     "access": "public"
   },