@xulthekl/team-flow 0.22.4

package/agents/prototype-reviewer.md

@@ -0,0 +1,226 @@
+---
+name: prototype-reviewer
+description: >-
+  原型 vs PRD 一致性自动评审。在原型产出后、人工评审前，独立检查原型与 PRD
+  的结构化一致性（6 维度），输出分级一致性报告。只读审查，不修改任何文件。
+  Examples:
+
+<example>
+Context: 原型刚产出，orchestrator 需要在人工评审前做自动一致性检查。
+user: "原型做好了，帮我检查一下和 PRD 是否一致"
+assistant: "我来启动 prototype-reviewer agent，独立审查原型与 PRD 的 6 维度一致性。"
+<commentary>
+原型自动评审是 orchestrator S2 阶段的关键门禁。prototype-reviewer 在独立上下文中运行，
+未参与 PRD/原型产出，规避锚定效应。审查报告写在 response 中，由编排层落盘。
+</commentary>
+</example>
+
+<example>
+Context: 原型经过修正后需要重新评审（第 2 轮）。
+user: "原型修正完了，重新跑一下一致性检查"
+assistant: "我启动 prototype-reviewer agent 进行第 2 轮自动评审，对比修正前后不一致项是否收敛。"
+<commentary>
+FAIL 后修正→重新评审，最多 3 轮。连续两轮不一致项集合无缩小则转人工，避免死循环。
+</commentary>
+</example>
+
+<example>
+Context: 用户想确认原型是否覆盖了 PRD 中定义的所有页面和功能。
+user: "PRD 里定义了 8 个页面，原型是不是都有了？"
+assistant: "让 prototype-reviewer agent 做一次 D1 页面完整性 + D2 功能覆盖的结构化检查。"
+<commentary>
+D1/D4 走 Pre-check（Bash 结构化预检），机械化验证页面文件存在性和导航链接完整性。
+</commentary>
+</example>
+
+<example>
+Context: 人工评审前想先过一遍术语和字段是否对齐。
+user: "帮我看看原型里的字段名称和 PRD 定义的是否一致"
+assistant: "我启动 prototype-reviewer agent 做 D3 字段一致性 + D5 术语一致性的语义对比。"
+<commentary>
+D3/D5 走 Deep-check（LLM 语义对比），标注为建议级，误报可被人工推翻。
+</commentary>
+</example>
+
+model: inherit
+color: green
+tools: ["Read", "Bash", "Grep", "Glob"]
+---
+
+You are an independent Prototype Consistency Reviewer. You check whether an HTML prototype is structurally and semantically consistent with its PRD. You produce a graded consistency report across 6 dimensions. You NEVER modify any file — your role is strictly read-only analysis.
+
+## The Iron Law
+
+You are an independent reviewer. You did NOT participate in producing the PRD or the prototype. You read both artifacts fresh, compare them structurally, and report findings. You must NEVER write, edit, create, or delete any file. Your report is delivered in your response — the orchestration layer persists it to `prd/vN/prototype-auto-review.md`.
+
+## Inputs
+
+| Parameter | Description |
+|-----------|-------------|
+| `prd_path` | PRD 文件路径（e.g., `prd/v1/prd.md`） |
+| `prototype_path` | 原型目录路径（e.g., `prototype/`） |
+
+If either path is missing or unreadable, report `FAIL` with reason `INPUT_ERROR`.
+
+## 6-Dimension Checklist
+
+| Dim | Name | PRD Source | Check Content | Severity |
+|-----|------|-----------|---------------|----------|
+| D1 | 页面完整性 | §4 画面原型 | 每个 PRD 定义的页面是否有对应 HTML 文件 + 导航链接可达 | Critical |
+| D2 | 功能覆盖 | §7 系统功能清单 | 每个 UI 功能是否有对应交互元素（按钮/表单/链接） | Critical |
+| D3 | 字段一致性 | §8.4 功能模块 | PRD 定义的字段是否在对应表单/表格中体现 | Important |
+| D4 | 导航一致性 | §8.2.2 画面交互 | 页面跳转关系是否与 PRD 定义的流程一致 | Important |
+| D5 | 术语一致性 | §6 业务术语 + CONCEPTS.md | 原型中的标签/术语是否与 PRD 和 CONCEPTS.md 一致 | Minor |
+| D6 | 状态覆盖 | §8.2.3 异常状态 | 空态/错误态/加载态是否在原型中体现 | Important |
+
+**D6 N/A 机制**：自包含 HTML 原型用静态 mock，加载/空状态结构性无法体现时，标 `N/A` 并注明理由。N/A 不计入 Important，不阻断判定。
+
+## Review Process
+
+### Phase 1: Pre-check（Bash 结构化预检，D1/D4 + P0 工艺 grep）
+
+机械化验证，无需 LLM 语义判断：
+
+1. **D1 页面完整性**：
+   - 从 PRD §4 提取所有页面名称列表
+   - `ls` / `find` 扫描 `prototype/` 下所有 `.html` 文件
+   - 逐页匹配：PRD 页面 → HTML 文件存在性
+   - `grep` 检查导航文件（index.html / nav 组件）中是否包含每个页面的链接
+   - 未匹配页面 = Critical finding
+
+2. **D4 导航一致性**：
+   - 从 PRD §8.2.2 提取页面跳转关系（A→B）
+   - `grep` 原型 HTML 中的 `<a href>` / `onclick` 跳转
+   - 比对：PRD 定义的跳转路径是否在原型中存在
+   - 缺失跳转 = Important finding
+
+3. **P0 工艺机械检查（v0.18.0，参照 `references/checklist.md`）**——**P0 违规 = Critical finding**：
+   - 裸 hex：grep `#[0-9a-fA-F]{3,8}` 在 `:root{}` 块外 → 命中 = Critical
+   - 靛蓝黑名单：grep `#6366f1\|#4f46e5\|#4338ca\|#3730a3\|#8b5cf6\|#7c3aed\|#a855f7` → 命中 = Critical
+   - emoji 图标：grep `✨\|🚀\|🎯\|⚡\|🔥\|💡` 在 h*/button/li 元素中 → 命中 = Critical
+   - 填充文案：grep -i `lorem\|功能一\|功能二\|功能三\|placeholder text\|示例文本` → 命中 = Critical
+   - scrollIntoView：grep `scrollIntoView` → 命中 = Critical
+   - data-testid 缺失：每个顶层 `<section>` 无 `data-testid` = Critical
+   - accent 超限：每屏 `var(--accent)` 可见使用 ≥3 处 = Critical
+
+### Phase 2: Deep-check（LLM 语义对比，D2/D3/D5/D6）
+
+需要语义理解的维度，标注为"建议级，误报可被人工推翻"：
+
+3. **D2 功能覆盖**：读 PRD §7 功能清单，逐项在原型 HTML 中查找对应交互元素（button/form/input/link）。未覆盖 = Critical。
+4. **D3 字段一致性**：读 PRD §8.4 字段定义，在对应页面 HTML 中查找表单字段（label/input/select）。缺失 = Important。
+5. **D5 术语一致性**：读 PRD §6 + CONCEPTS.md，与原型中的中文标签/英文命名比对。不一致 = Minor。
+6. **D6 状态覆盖（v0.18.0 五状态契约）**：读 PRD §8.2.3 异常状态定义，逐页面检查 **Loading / Empty / Error / Populated / Edge** 五状态覆盖（参照 `references/craft/state-coverage.md`）。每态必含物：Loading=骨架/进度指示；Empty=说明+主操作；Error=what/why/what-to-do；Populated=正常数据；Edge=极端值/长文本/零结果。缺失 = Important，结构性不可实现 = N/A（附理由）。测试矩阵填入报告。
+
+### Phase 3: Craft Quality Review（工艺质量 4 席 rubric，v0.18.0）
+
+独立于 PRD 6 维度的**工艺质量评审**。4 席独立打分（0-10），每席输出 must-fix 列表（位置 + 问题 + 修复建议）：
+
+| 席 | 权重 | 评审内容 |
+|----|------|---------|
+| **工艺席** | 0.4 | checklist P1 合规 + anti-ai-slop 七宗罪 + 80/20 灵魂法则（参照 `references/craft/anti-ai-slop.md`） |
+| **品牌席** | 0.2 | `.team-flow/design-system/` token 合规 + 视觉一致性（无内联漂移） |
+| **无障碍席** | 0.2 | accessibility-baseline 合规（参照 `references/craft/accessibility-baseline.md`） |
+| **文案席** | 0.2 | 无填充 / CTA 说明动作 / 标题 ≤14 词 / 术语一致 |
+
+加权合成：`工艺×0.4 + 品牌×0.2 + 无障碍×0.2 + 文案×0.2`
+
+### Phase 4: 汇总判定
+
+按判定标准输出最终 verdict。
+
+## Judgment Criteria
+
+| Verdict | Condition | Action |
+|---------|-----------|--------|
+| **PASS** | Critical=0 且 Important=0 且 craft 合成 ≥6.0 | 进入人工评审 |
+| **PASS_WITH_WARNINGS** | Critical=0 且（Important>0 或 craft 合成 <6.0），无未清 must-fix | 警告项交人工裁定，不阻断 |
+| **FAIL** | Critical>0（含 P0 违规）或有未清 must-fix | 必须修正后重新评审 |
+
+**FAIL 由 Critical 或未清 must-fix 触发**。Important 误报不触发 FAIL。
+
+## Output Format
+
+```markdown
+# Prototype Auto-Review Report
+
+## Metadata
+- **PRD**: {prd_path}
+- **Prototype**: {prototype_path}
+- **Review round**: {N}
+- **Reviewer**: prototype-reviewer agent (independent, read-only)
+- **Timestamp**: {ISO 8601}
+
+## Verdict: {PASS | PASS_WITH_WARNINGS | FAIL}
+
+| Severity | Count |
+|----------|-------|
+| Critical | {n} |
+| Important | {n} |
+| Minor | {n} |
+| N/A | {n} |
+
+## Dimension Details
+
+### D1 页面完整性 — {PASS/FAIL} ({m}/{n} pages)
+[逐页检查结果表格：PRD 页面 | HTML 文件 | 导航可达 | 结果]
+
+### D2 功能覆盖 — {PASS/FAIL} ({m}/{n} functions)
+[逐功能检查结果：PRD 功能 | 原型元素 | 位置 | 结果]
+
+### D3 字段一致性 — {PASS/WARN} ({m}/{n} fields)
+[逐字段检查结果]
+
+### D4 导航一致性 — {PASS/WARN} ({m}/{n} routes)
+[逐跳转检查结果]
+
+### D5 术语一致性 — {PASS/WARN}
+[不一致术语列表]
+
+### D6 状态覆盖 — {PASS/WARN/N/A}
+[逐页面五状态检查结果表格：页面 | Loading | Empty | Error | Populated | Edge | N/A 项附理由]
+
+## Craft Quality（v0.18.0）
+
+| 席 | 分数 (0-10) | must-fix 数 |
+|----|------------|------------|
+| 工艺（×0.4） | {n} | {m} |
+| 品牌（×0.2） | {n} | {m} |
+| 无障碍（×0.2） | {n} | {m} |
+| 文案（×0.2） | {n} | {m} |
+| **加权合成** | **{weighted}** | **{total}** |
+
+### Must-Fix Details
+| # | 席 | 位置 | 问题 | 修复建议 |
+|---|-----|------|------|---------|
+| 1 | 工艺 | pages/dashboard.html:42 | accent 使用 4 处超限 | 去掉 2 处 accent，改用 --muted |
+
+## Inconsistency Summary
+| # | Dim | Severity | PRD Source | Prototype Location | Description |
+|---|-----|----------|-----------|-------------------|-------------|
+| 1 | D1 | Critical | §4.2 用户管理页 | — (missing) | PRD 定义的用户管理页无对应 HTML |
+| ... | | | | | |
+
+## Coverage Statistics
+- Pages: {m}/{n} ({percent}%)
+- Functions: {m}/{n} ({percent}%)
+- Fields: {m}/{n} ({percent}%)
+- Routes: {m}/{n} ({percent}%)
+```
+
+## Red Lines
+
+**DO:**
+- Read the PRD BEFORE reading the prototype — establish the baseline first
+- Cite PRD source section (§X.X) AND prototype location (file:line) for every finding
+- Mark D6 as N/A with explicit justification when structurally inapplicable
+- Give a clear, unambiguous verdict
+- Distinguish Pre-check (mechanical) from Deep-check (semantic, advisory) findings
+
+**DON'T:**
+- Modify any file — you are read-only, report goes in your response
+- Guess or infer PRD content that is not explicitly written — if PRD doesn't define it, it's not a finding
+- Mark style/aesthetics/UX issues — those are for human review only
+- Trigger FAIL on Important findings — FAIL is Critical-only
+- Skip the Pre-check phase and jump straight to semantic analysis
+- Omit the PRD source reference for any finding

package/assets/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <rect width="64" height="64" rx="14" fill="#2563EB"/>
+  <path d="M20 44V20l14 12-14 12z" fill="#fff" opacity="0.9"/>
+  <path d="M32 44V20l14 12-14 12z" fill="#fff" opacity="0.6"/>
+  <path d="M18 42h28M18 22h28" stroke="#fff" stroke-width="1.5" opacity="0.3"/>
+</svg>

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { Scenario, Requirement } from './schema/base.js';
+export type { DeltaOperationType, Rename, Delta, Change } from './schema/change.js';
+export type { Spec } from './schema/spec.js';
+export type { ValidationLevel, ValidationIssue, ValidationReport } from './validation/types.js';
+export type { VerificationDimension, VerificationStatus, VerificationFinding, VerificationReport } from './validation/types.js';
+export type { ConflictReport, SyncConflict } from './validation/types.js';
+export { VALIDATION_MESSAGES, MIN_WHY_SECTION_LENGTH, MIN_PURPOSE_LENGTH, MAX_WHY_SECTION_LENGTH, MAX_REQUIREMENT_TEXT_LENGTH, MAX_DELTAS_PER_CHANGE, VERIFICATION_DIMENSIONS, VERIFICATION_MESSAGES, MIN_ABANDONMENT_REASON_LENGTH } from './validation/constants.js';
+export { Validator } from './validation/validator.js';
+export type { RequirementBlock, RequirementsSectionParts, DeltaPlan } from './parsing/requirement-blocks.js';
+export { REQUIREMENT_HEADER_REGEX, normalizeRequirementName, extractRequirementsSection, parseDeltaSpec } from './parsing/requirement-blocks.js';
+export type { ParsedDelta, ParsedChange } from './parsing/change-parser.js';
+export { parseChangeMarkdown } from './parsing/change-parser.js';
+export { tokenize, detectLanguage } from './validation/tokenizer.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { VALIDATION_MESSAGES, MIN_WHY_SECTION_LENGTH, MIN_PURPOSE_LENGTH, MAX_WHY_SECTION_LENGTH, MAX_REQUIREMENT_TEXT_LENGTH, MAX_DELTAS_PER_CHANGE, VERIFICATION_DIMENSIONS, VERIFICATION_MESSAGES, MIN_ABANDONMENT_REASON_LENGTH } from './validation/constants.js';
+export { Validator } from './validation/validator.js';
+export { REQUIREMENT_HEADER_REGEX, normalizeRequirementName, extractRequirementsSection, parseDeltaSpec } from './parsing/requirement-blocks.js';
+export { parseChangeMarkdown } from './parsing/change-parser.js';
+export { tokenize, detectLanguage } from './validation/tokenizer.js';

package/dist/parsing/change-parser.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedDelta {
+    spec: string;
+    operation: string;
+    description: string;
+}
+export interface ParsedChange {
+    name: string;
+    why: string;
+    whatChanges: string;
+    deltas: ParsedDelta[];
+}
+export declare function parseChangeMarkdown(content: string, changeName: string): ParsedChange;

package/dist/parsing/change-parser.js

@@ -0,0 +1,54 @@
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+function extractSection(content, heading) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    // Match headings that contain the English keyword — supports both
+    // "## Why" and "## 背景（Why）" style bilingual headings.
+    const headingRegex = new RegExp(`^##\\s+.*\\b${heading.replace(/\s+/g, '\\s+')}\\b.*$`, 'i');
+    const idx = lines.findIndex((l) => headingRegex.test(l));
+    if (idx === -1)
+        return '';
+    let endIdx = lines.length;
+    for (let i = idx + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    return lines.slice(idx + 1, endIdx).join('\n').trim();
+}
+export function parseChangeMarkdown(content, changeName) {
+    const why = extractSection(content, 'Why');
+    const whatChanges = extractSection(content, 'What Changes');
+    const deltas = [];
+    const deltaSectionRegex = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\s*$/im;
+    const sections = content.split(/(?=^##\s)/m);
+    for (const section of sections) {
+        const match = section.match(deltaSectionRegex);
+        if (match) {
+            const operation = match[1].toUpperCase();
+            const body = section.substring(match[0].length).trim();
+            const descLines = [];
+            for (const line of body.split('\n')) {
+                if (/^###\s+/.test(line))
+                    break;
+                const trimmed = line.trim();
+                if (trimmed)
+                    descLines.push(trimmed);
+            }
+            deltas.push({
+                spec: '',
+                operation,
+                description: descLines.join('\n'),
+            });
+        }
+    }
+    return {
+        name: changeName,
+        why,
+        whatChanges,
+        deltas,
+    };
+}

package/dist/parsing/requirement-blocks.d.ts

@@ -0,0 +1,31 @@
+export interface RequirementBlock {
+    headerLine: string;
+    name: string;
+    raw: string;
+}
+export interface RequirementsSectionParts {
+    before: string;
+    headerLine: string;
+    preamble: string;
+    bodyBlocks: RequirementBlock[];
+    after: string;
+}
+export declare function normalizeRequirementName(name: string): string;
+export declare const REQUIREMENT_HEADER_REGEX: RegExp;
+export declare function extractRequirementsSection(content: string): RequirementsSectionParts;
+export interface DeltaPlan {
+    added: RequirementBlock[];
+    modified: RequirementBlock[];
+    removed: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+    sectionPresence: {
+        added: boolean;
+        modified: boolean;
+        removed: boolean;
+        renamed: boolean;
+    };
+}
+export declare function parseDeltaSpec(content: string): DeltaPlan;

package/dist/parsing/requirement-blocks.js

@@ -0,0 +1,192 @@
+export function normalizeRequirementName(name) {
+    return name.trim();
+}
+export const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const reqHeaderIndex = lines.findIndex((l) => /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    while (cursor < sectionBodyLines.length &&
+        !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor])) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerLineCandidate = sectionBodyLines[cursor];
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        if (!headerMatch) {
+            cursor++;
+            continue;
+        }
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length &&
+            !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]) &&
+            !/^##\s+/.test(sectionBodyLines[cursor])) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function splitTopLevelSections(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            const level = m[1].length;
+            indices.push({ title: m[2].trim(), index: i, level });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const body = lines
+            .slice(current.index + 1, next ? next.index : lines.length)
+            .join('\n');
+        result[current.title] = body;
+    }
+    return result;
+}
+function getSectionCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    for (const [title, body] of Object.entries(sections)) {
+        if (title.toLowerCase() === target)
+            return { body, found: true };
+    }
+    return { body: '', found: false };
+}
+function parseRequirementBlocksFromSection(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]))
+            i++;
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length &&
+            !REQUIREMENT_HEADER_REGEX.test(lines[i]) &&
+            !/^##\s+/.test(lines[i])) {
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    return blocks;
+}
+function parseRemovedNames(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const names = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    for (const line of lines) {
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+function parseRenamedPairs(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const pairs = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    let current = {};
+    for (const line of lines) {
+        const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (fromMatch) {
+            current.from = normalizeRequirementName(fromMatch[1]);
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    return pairs;
+}
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const sections = splitTopLevelSections(normalized);
+    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const added = parseRequirementBlocksFromSection(addedLookup.body);
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body);
+    const removedNames = parseRemovedNames(removedLookup.body);
+    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}

package/dist/schema/base.d.ts

@@ -0,0 +1,7 @@
+export interface Scenario {
+    rawText: string;
+}
+export interface Requirement {
+    text: string;
+    scenarios: Scenario[];
+}

package/dist/schema/base.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/change.d.ts

@@ -0,0 +1,25 @@
+import { Requirement } from './base.js';
+export type DeltaOperationType = 'ADDED' | 'MODIFIED' | 'REMOVED' | 'RENAMED';
+export interface Rename {
+    from: string;
+    to: string;
+}
+export interface Delta {
+    spec: string;
+    operation: DeltaOperationType;
+    description: string;
+    requirement?: Requirement;
+    requirements?: Requirement[];
+    rename?: Rename;
+}
+export interface Change {
+    name: string;
+    why: string;
+    whatChanges: string;
+    deltas: Delta[];
+    metadata?: {
+        version?: string;
+        format?: string;
+        sourcePath?: string;
+    };
+}

package/dist/schema/change.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/index.d.ts

@@ -0,0 +1,3 @@
+export type { Scenario, Requirement } from './base.js';
+export type { DeltaOperationType, Rename, Delta, Change } from './change.js';
+export type { Spec } from './spec.js';

package/dist/schema/index.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/spec.d.ts

@@ -0,0 +1,11 @@
+import { Requirement } from './base.js';
+export interface Spec {
+    name: string;
+    overview: string;
+    requirements: Requirement[];
+    metadata?: {
+        version?: string;
+        format?: string;
+        sourcePath?: string;
+    };
+}

package/dist/schema/spec.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/constants.d.ts

@@ -0,0 +1,42 @@
+export declare const MIN_WHY_SECTION_LENGTH = 50;
+export declare const MIN_PURPOSE_LENGTH = 50;
+export declare const MAX_WHY_SECTION_LENGTH = 1000;
+export declare const MAX_REQUIREMENT_TEXT_LENGTH = 500;
+export declare const MAX_DELTAS_PER_CHANGE = 10;
+export declare const VALIDATION_MESSAGES: {
+    readonly SCENARIO_EMPTY: "Scenario text cannot be empty";
+    readonly REQUIREMENT_EMPTY: "Requirement text cannot be empty";
+    readonly REQUIREMENT_NO_SHALL: "Requirement must contain SHALL or MUST keyword";
+    readonly REQUIREMENT_NO_SCENARIOS: "Requirement must have at least one scenario";
+    readonly SPEC_NAME_EMPTY: "Spec name cannot be empty";
+    readonly SPEC_PURPOSE_EMPTY: "Purpose section cannot be empty";
+    readonly SPEC_NO_REQUIREMENTS: "Spec must have at least one requirement";
+    readonly CHANGE_NAME_EMPTY: "Change name cannot be empty";
+    readonly CHANGE_WHY_TOO_SHORT: "Why section must be at least 50 characters";
+    readonly CHANGE_WHY_TOO_LONG: "Why section should not exceed 1000 characters";
+    readonly CHANGE_WHAT_EMPTY: "What Changes section cannot be empty";
+    readonly CHANGE_NO_DELTAS: "Change must have at least one delta";
+    readonly CHANGE_TOO_MANY_DELTAS: "Consider splitting changes with more than 10 deltas";
+    readonly DELTA_SPEC_EMPTY: "Spec name cannot be empty";
+    readonly DELTA_DESCRIPTION_EMPTY: "Delta description cannot be empty";
+    readonly PURPOSE_TOO_BRIEF: "Purpose section is too brief (less than 50 characters)";
+    readonly REQUIREMENT_TOO_LONG: "Requirement text is very long (>500 characters). Consider breaking it down.";
+    readonly DELTA_DESCRIPTION_TOO_BRIEF: "Delta description is too brief";
+    readonly DELTA_MISSING_REQUIREMENTS: "Delta should include requirements";
+    readonly GUIDE_NO_DELTAS: "No deltas found. Ensure your change has a specs/ directory with capability folders (e.g. specs/http-server/spec.md) containing .md files that use delta headers (## ADDED/MODIFIED/REMOVED/RENAMED Requirements) and that each requirement includes at least one \"#### Scenario:\" block. Tip: run \"openspec change show <change-id> --json --deltas-only\" to inspect parsed deltas.";
+    readonly GUIDE_MISSING_SPEC_SECTIONS: "Missing required sections. Expected headers: \"## Purpose\" and \"## Requirements\". Example:\n## Purpose\n[brief purpose]\n\n## Requirements\n### Requirement: Clear requirement statement\nUsers SHALL ...\n\n#### Scenario: Descriptive name\n- **WHEN** ...\n- **THEN** ...";
+    readonly GUIDE_MISSING_CHANGE_SECTIONS: "Missing required sections. Expected headers: \"## Why\" and \"## What Changes\". Ensure deltas are documented in specs/ using delta headers.";
+    readonly GUIDE_SCENARIO_FORMAT: "Scenarios must use level-4 headers. Convert bullet lists into:\n#### Scenario: Short name\n- **WHEN** ...\n- **THEN** ...\n- **AND** ...";
+};
+export declare const VERIFICATION_DIMENSIONS: readonly ["Completeness", "Correctness", "Coherence"];
+export declare const VERIFICATION_MESSAGES: {
+    readonly COMPLETENESS_MISSING_TASK: "Task in tasks.md has no corresponding code change in diff summary";
+    readonly COMPLETENESS_MISSING_REQUIREMENT: "SHALL/MUST requirement in spec has no matching implementation in diff summary: {requirement}";
+    readonly CORRECTNESS_TEST_FAILURE: "Test suite has failures";
+    readonly CORRECTNESS_MISSING_SCENARIO: "Spec scenario has no corresponding test assertion";
+    readonly COHERENCE_NAMING_MISMATCH: "Design decision naming does not match implementation naming";
+    readonly COHERENCE_PATTERN_MISSING: "Architecture pattern from design.md not found in implementation: {pattern}";
+    readonly VERIFICATION_PLACEHOLDER_DETECTED: "Diff summary contains placeholder markers (TODO, FIXME, HACK)";
+    readonly CONFLICT_DETECTED: "Requirement \"{requirement}\" is modified by multiple changes: {changes}";
+};
+export declare const MIN_ABANDONMENT_REASON_LENGTH = 50;