@zhuan-ai/zhuanspec 2.10.0 → 2.11.2

package/dist/core/validation/strict-rules.js

@@ -17,6 +17,15 @@ const VALID_COMPLETION_MARKERS = [
     /no\s+clarification\s+needed/i,
     /status:\s*completed/i,
 ];
+// Test Case Source Log patterns
+const TEST_CASE_SOURCE_LOG_PATTERN = /^##\s+(Test\s+Case\s+Source\s+Log|测试\s*[Cc]ase\s*来源日志?)\s*$/im;
+const TDD_MODE_DECLARED_PATTERNS = [
+    /TDD\s*模式[：:]\s*(启用|禁用)/i,
+    /TDD\s*mode[：:]?\s*(enabled|disabled)/i,
+    /用户回答[：:]\s*\S/i,
+    /暂不提供|已跳过|skipped/i,
+    /@test-case:/i,
+];
 // Skill mapping section header pattern
 const SKILL_MAPPING_SECTION_PATTERN = /^##\s+Skill\s+Mapping\s*$/im;
 // Table data row pattern (starts with |, not a separator row like |---|---|)
@@ -24,6 +33,54 @@ const TABLE_DATA_ROW_PATTERN = /^\|(?![-:|\s]+\|$)[^\n]+\|/gm;
 const SKILL_TAG_PATTERN = /@skill:([^\s@]+)/g;
 // Wave header pattern
 const WAVE_HEADER_PATTERN = /^###\s+Wave\s+(\d+)/im;
+/**
+ * Rule 0: test-case-inquiry-logged
+ *
+ * Validates that tasks.md has a "## Test Case Source Log" section with non-empty content.
+ * This rule fires UNCONDITIONALLY — whether or not TDD mode is used.
+ * The AI must always ask the user about test cases and record the outcome before writing
+ * any spec/task content. Absence of this section means the inquiry was skipped.
+ */
+export function checkTestCaseInquiryLogged(tasksContent) {
+    const result = {
+        ruleId: 'test-case-inquiry-logged',
+        ruleName: 'Test case inquiry logged',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    const sectionMatch = tasksContent.match(TEST_CASE_SOURCE_LOG_PATTERN);
+    if (!sectionMatch) {
+        result.errors.push('Missing "## Test Case Source Log" section — the AI must ask the user about test cases ' +
+            'at the start of the proposal phase and record the result here before writing any spec/task content. ' +
+            'Add a section with at least: "用户回答: 提供/跳过" and "TDD 模式: 启用/禁用".');
+        return result;
+    }
+    const sectionStartIndex = sectionMatch.index + sectionMatch[0].length;
+    const nextSectionMatch = tasksContent.slice(sectionStartIndex).match(/^##\s+/m);
+    const sectionEndIndex = nextSectionMatch
+        ? sectionStartIndex + nextSectionMatch.index
+        : tasksContent.length;
+    const sectionContent = tasksContent.slice(sectionStartIndex, sectionEndIndex);
+    const contentWithoutComments = sectionContent.replace(HTML_COMMENT_PATTERN, '').trim();
+    if (!contentWithoutComments) {
+        result.errors.push('"## Test Case Source Log" is empty — record the inquiry outcome (user answer + TDD mode status)');
+        return result;
+    }
+    if (UNRESOLVED_MARKERS.test(contentWithoutComments)) {
+        result.errors.push('"## Test Case Source Log" contains unresolved markers (TODO / TBD / PENDING)');
+        return result;
+    }
+    const hasDeclaredStatus = TDD_MODE_DECLARED_PATTERNS.some(p => p.test(contentWithoutComments));
+    const hasSubstantiveContent = contentWithoutComments.length > 10;
+    if (hasDeclaredStatus || hasSubstantiveContent) {
+        result.passed = true;
+    }
+    else {
+        result.errors.push('"## Test Case Source Log" is too brief — include at least the user\'s answer and TDD mode status');
+    }
+    return result;
+}
 /**
  * Rule 1: pre-clarification-completed
  *
@@ -418,11 +475,96 @@ export function detectPhase(changeDir) {
         return 'propose';
     }
 }
+/**
+ * Search for a keyword in project files of a specific type.
+ * Uses synchronous file system operations for simplicity.
+ */
+function searchCode(projectRoot, keyword, fileType, touchedFiles) {
+    const result = {
+        dimension: fileType,
+        keyword,
+        fileType,
+        found: false,
+    };
+    const extensionMap = {
+        java: ['.java'],
+        tsx: ['.tsx', '.jsx', '.ts', '.js'],
+        xml: ['.xml'],
+        sql: ['.sql'],
+    };
+    const extensions = extensionMap[fileType] || [`.${fileType}`];
+    const keywordLower = keyword.toLowerCase();
+    for (const file of touchedFiles) {
+        const ext = path.extname(file).toLowerCase();
+        if (!extensions.includes(ext))
+            continue;
+        try {
+            const fullPath = path.isAbsolute(file) ? file : path.join(projectRoot, file);
+            if (!existsSync(fullPath))
+                continue;
+            const content = readFileSync(fullPath, 'utf-8').toLowerCase();
+            if (content.includes(keywordLower)) {
+                result.found = true;
+                result.matchedFile = file;
+                return result;
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return result;
+}
+/**
+ * Calculate coverage rate from scenario results.
+ */
+function calculateCoverageRate(results) {
+    if (results.length === 0)
+        return 100;
+    const covered = results.filter(r => r.covered).length;
+    return Math.round((covered / results.length) * 100);
+}
+/**
+ * Extract multi-dimensional keywords from a scenario/requirement description.
+ * Parses common patterns like class names, API paths, table names, UI actions.
+ */
+function extractScenarioDimensions(name, description) {
+    const combined = `${name} ${description}`;
+    const scenario = {
+        name,
+        keywords: [],
+    };
+    // Dimension 1: Class/method name (PascalCase or camelCase identifiers)
+    const classMatch = combined.match(/\b([A-Z][a-zA-Z0-9]{2,}(?:Service|Controller|Mapper|Repository|Handler|Manager|Impl|DTO|VO|Entity))\b/);
+    if (classMatch) {
+        scenario.mentionsClass = classMatch[1];
+    }
+    // Dimension 2: API path (e.g., /api/xxx or /v1/xxx)
+    const apiMatch = combined.match(/(\/(?:api|v\d+)\/[\w\-/]+)/);
+    if (apiMatch) {
+        scenario.mentionsApiPath = apiMatch[1];
+    }
+    // Dimension 3: Database table (e.g., t_xxx or table xxx)
+    const tableMatch = combined.match(/\b(t_[a-z][a-z0-9_]+)\b/i) ||
+        combined.match(/(?:表|table)[：:\s]+([a-z][a-z0-9_]+)/i);
+    if (tableMatch) {
+        scenario.mentionsTable = tableMatch[1];
+    }
+    // Dimension 4: UI action (e.g., 点击xxx, onClick, onSubmit)
+    const uiMatch = combined.match(/(?:点击|click|onClick|onSubmit|按钮|button)[\s:：]*([\u4e00-\u9fa5a-zA-Z]+)/i);
+    if (uiMatch) {
+        scenario.mentionsUIAction = uiMatch[1];
+    }
+    // Fallback keywords: extract meaningful words (length > 3)
+    const words = name.toLowerCase().split(/[\s\-_/]+/).filter(w => w.length > 3);
+    scenario.keywords = words;
+    return scenario;
+}
 /**
  * Rule 8: spec-code-consistent
  *
  * Validates that Requirements in delta specs have corresponding code changes.
- * Uses weak signal matching: requirement name keywords should appear in touched files.
+ * Uses multi-dimensional semantic matching: class names, API paths, table names, UI actions.
  *
  * SKIPPED in Propose phase (no code changes yet).
  */
@@ -445,8 +587,8 @@ function checkSpecCodeConsistent(specsDir, repoRoot, phase) {
         result.passed = true;
         return result;
     }
-    // Collect requirements from delta specs
-    const requirements = [];
+    // Collect requirements with scenario-level detail from delta specs
+    const parsedScenarios = [];
     try {
         const specDirs = readdirSync(specsDir, { withFileTypes: true });
         for (const entry of specDirs) {
@@ -456,29 +598,71 @@ function checkSpecCodeConsistent(specsDir, repoRoot, phase) {
             if (!existsSync(specFile))
                 continue;
             const content = readFileSync(specFile, 'utf-8');
-            // Parse ADDED/MODIFIED Requirements (not REMOVED)
-            const addedMatches = content.matchAll(/^###\s+(Requirement|需求)[：:]\s+(.+)$/gm);
-            const inAddedSection = content.includes('## ADDED Requirements') || content.includes('## 新增要求');
-            const inModifiedSection = content.includes('## MODIFIED Requirements') || content.includes('## 修改要求');
-            // Simple parsing: check if requirement is in ADDED or MODIFIED section
+            // Parse ADDED/MODIFIED Requirements and their Scenarios
             const lines = content.split('\n');
             let currentSection = '';
+            let currentReqName = '';
+            let currentReqDescription = '';
+            let inScenarioBlock = false;
+            let scenarioName = '';
+            let scenarioDescription = '';
+            const flushScenario = () => {
+                if (scenarioName && (currentSection === 'ADDED' || currentSection === 'MODIFIED')) {
+                    parsedScenarios.push(extractScenarioDimensions(scenarioName, scenarioDescription));
+                }
+                scenarioName = '';
+                scenarioDescription = '';
+            };
+            const flushRequirement = () => {
+                flushScenario();
+                // If requirement has no scenarios, treat the requirement itself as a scenario
+                if (currentReqName && (currentSection === 'ADDED' || currentSection === 'MODIFIED')) {
+                    const hasScenarios = parsedScenarios.some(s => s.name.startsWith(currentReqName));
+                    if (!hasScenarios) {
+                        parsedScenarios.push(extractScenarioDimensions(currentReqName, currentReqDescription));
+                    }
+                }
+                currentReqName = '';
+                currentReqDescription = '';
+            };
             for (const line of lines) {
-                if (line.match(/^##\s+(ADDED|Added|新增)/i))
+                if (line.match(/^##\s+(ADDED|Added|新增)/i)) {
+                    flushRequirement();
                     currentSection = 'ADDED';
-                else if (line.match(/^##\s+(MODIFIED|Modified|修改)/i))
+                }
+                else if (line.match(/^##\s+(MODIFIED|Modified|修改)/i)) {
+                    flushRequirement();
                     currentSection = 'MODIFIED';
-                else if (line.match(/^##\s+(REMOVED|Removed|删除)/i))
+                }
+                else if (line.match(/^##\s+(REMOVED|Removed|删除)/i)) {
+                    flushRequirement();
                     currentSection = 'REMOVED';
-                else if (line.match(/^##\s+(RENAMED|Renamed|重命名)/i))
+                }
+                else if (line.match(/^##\s+(RENAMED|Renamed|重命名)/i)) {
+                    flushRequirement();
                     currentSection = 'RENAMED';
+                }
                 else if (line.match(/^###\s+(Requirement|需求)[：:]/i)) {
-                    const reqName = line.replace(/^###\s+(Requirement|需求)[：:]\s+/i, '').trim();
-                    if (currentSection === 'ADDED' || currentSection === 'MODIFIED') {
-                        requirements.push({ name: reqName, operation: currentSection });
-                    }
+                    flushRequirement();
+                    currentReqName = line.replace(/^###\s+(Requirement|需求)[：:]\s+/i, '').trim();
+                }
+                else if (line.match(/^####\s+(Scenario|场景)[：:]/i)) {
+                    flushScenario();
+                    scenarioName = line.replace(/^####\s+(Scenario|场景)[：:]\s+/i, '').trim();
+                    inScenarioBlock = true;
+                }
+                else if (inScenarioBlock && !line.match(/^#{1,4}\s/)) {
+                    scenarioDescription += ' ' + line;
+                }
+                else if (line.match(/^#{1,3}\s/)) {
+                    inScenarioBlock = false;
+                }
+                // Accumulate requirement description for fallback
+                if (currentReqName && !scenarioName && !line.match(/^#{1,4}\s/)) {
+                    currentReqDescription += ' ' + line;
                 }
             }
+            flushRequirement();
         }
     }
     catch {
@@ -486,8 +670,8 @@ function checkSpecCodeConsistent(specsDir, repoRoot, phase) {
         result.passed = true;
         return result;
     }
-    // If no requirements found, consider passed
-    if (requirements.length === 0) {
+    // If no scenarios/requirements found, consider passed
+    if (parsedScenarios.length === 0) {
         result.passed = true;
         return result;
     }
@@ -498,33 +682,68 @@ function checkSpecCodeConsistent(specsDir, repoRoot, phase) {
         result.passed = true;
         return result;
     }
-    // Check each requirement against touched files
-    for (const req of requirements) {
-        const normalized = req.name.toLowerCase();
-        const keywords = normalized.split(/\s+/).filter(w => w.length > 3);
-        const matched = touchedFiles.some(file => {
-            const basename = path.basename(file).toLowerCase();
-            const filePathLower = file.toLowerCase();
-            const filenameMatched = keywords.some((kw) => basename.includes(kw) || filePathLower.includes(kw));
-            if (filenameMatched) {
-                return true;
-            }
-            try {
-                // Support both absolute paths (from GitRepoDetector) and relative paths
-                const fullPath = path.isAbsolute(file) ? file : path.join(repoRoot, file);
-                if (!existsSync(fullPath))
+    // Multi-dimensional matching for each scenario
+    const scenarioResults = [];
+    for (const scenario of parsedScenarios) {
+        const checks = [];
+        // Dimension 1: Class/method name matching
+        if (scenario.mentionsClass) {
+            checks.push(searchCode(repoRoot, scenario.mentionsClass, 'java', touchedFiles));
+        }
+        // Dimension 2: API path matching
+        if (scenario.mentionsApiPath) {
+            checks.push(searchCode(repoRoot, scenario.mentionsApiPath, 'java', touchedFiles));
+        }
+        // Dimension 3: Database table matching
+        if (scenario.mentionsTable) {
+            checks.push(searchCode(repoRoot, scenario.mentionsTable, 'java', touchedFiles));
+        }
+        // Dimension 4: UI action matching
+        if (scenario.mentionsUIAction) {
+            checks.push(searchCode(repoRoot, scenario.mentionsUIAction, 'tsx', touchedFiles));
+        }
+        // Fallback: keyword-based matching (backward compatible with original logic)
+        if (checks.length === 0 && scenario.keywords.length > 0) {
+            const keywordMatched = touchedFiles.some(file => {
+                const basename = path.basename(file).toLowerCase();
+                const filePathLower = file.toLowerCase();
+                if (scenario.keywords.some(kw => basename.includes(kw) || filePathLower.includes(kw))) {
+                    return true;
+                }
+                try {
+                    const fullPath = path.isAbsolute(file) ? file : path.join(repoRoot, file);
+                    if (!existsSync(fullPath))
+                        return false;
+                    const content = readFileSync(fullPath, 'utf-8').toLowerCase();
+                    return scenario.keywords.some(kw => content.includes(kw));
+                }
+                catch {
                     return false;
-                const content = readFileSync(fullPath, 'utf-8').toLowerCase();
-                return keywords.some((kw) => content.includes(kw));
-            }
-            catch {
-                return false;
-            }
-        });
-        if (!matched && touchedFiles.length > 0) {
-            result.errors.push(`Requirement "${req.name}" (${req.operation}) 未找到对应代码改动`);
+                }
+            });
+            checks.push({
+                dimension: 'keyword-fallback',
+                keyword: scenario.keywords.join(', '),
+                fileType: '*',
+                found: keywordMatched,
+            });
+        }
+        // Comprehensive judgment: covered if no checks or any check passes
+        const covered = checks.length === 0 || checks.some(c => c.found);
+        scenarioResults.push({ scenario: scenario.name, covered, checks });
+    }
+    const coverageRate = calculateCoverageRate(scenarioResults);
+    // Report uncovered scenarios as errors
+    for (const sr of scenarioResults) {
+        if (!sr.covered) {
+            const dimensions = sr.checks.map(c => `${c.dimension}:"${c.keyword}"`).join(', ');
+            result.errors.push(`Scenario "${sr.scenario}" 未找到对应代码改动 (checked: ${dimensions})`);
         }
     }
+    // Add coverage rate to warnings for visibility
+    if (scenarioResults.length > 0) {
+        result.warnings.push(`Spec-Code coverage: ${coverageRate}% (${scenarioResults.filter(s => s.covered).length}/${scenarioResults.length} scenarios)`);
+    }
     result.passed = result.errors.length === 0;
     return result;
 }
@@ -642,12 +861,331 @@ export function checkTestCaseCoverage(tasksContent, hasTestCase = false) {
     }
     return result;
 }
+/**
+ * Rule: tech-spec-coverage
+ *
+ * When a tech-spec document exists, validates that the technical spec
+ * adequately covers the proposal's requirements.
+ * This is a basic framework - full logic will be implemented in Task 7's Skill.
+ *
+ * Tech spec document lookup order:
+ *   1. techDesign/tech-spec.md (standard path)
+ *   2. tech-spec.md in the proposal root directory
+ *   3. 用户提供本地技术方案路径
+ *
+ * Checks:
+ *   - tech-spec.md file exists and is non-empty
+ *   - tech-spec.md contains substantive content (not just placeholder)
+ */
+export function checkTechSpecCoverage(changeDir) {
+    const result = {
+        ruleId: 'tech-spec-coverage',
+        ruleName: 'Tech Spec Coverage',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // Look for tech-spec.md from multiple sources
+    const candidatePaths = [
+        join(changeDir, 'techDesign', 'tech-spec.md'), // Standard path
+        join(changeDir, 'tech-spec.md'), // Proposal root directory
+    ];
+    let techSpecPath = null;
+    for (const candidate of candidatePaths) {
+        if (existsSync(candidate)) {
+            techSpecPath = candidate;
+            break;
+        }
+    }
+    if (!techSpecPath) {
+        // No tech-spec.md found anywhere — skip check gracefully
+        result.passed = true;
+        result.warnings.push('No tech-spec.md found (checked techDesign/tech-spec.md and proposal root) — skipping coverage check');
+        return result;
+    }
+    let content;
+    try {
+        content = readFileSync(techSpecPath, 'utf-8');
+    }
+    catch {
+        result.errors.push(`Failed to read ${path.relative(changeDir, techSpecPath)}`);
+        return result;
+    }
+    // Check if content is just the placeholder template
+    const stripped = content.replace(/^#.*$/gm, '').replace(/^>.*$/gm, '').replace(/^(created|source):.*$/gm, '').trim();
+    if (stripped.length < 50) {
+        result.warnings.push('techDesign/tech-spec.md appears to be a placeholder — populate with actual technical spec content');
+        result.passed = true;
+        return result;
+    }
+    // --- Full coverage validation logic ---
+    // 1. Extract key elements from tech-spec.md
+    const elements = extractTechSpecElements(content);
+    const totalElements = elements.length;
+    if (totalElements === 0) {
+        result.warnings.push('No structured elements (tables, APIs, classes, configs) detected in tech-spec.md — skipping coverage check');
+        result.passed = true;
+        return result;
+    }
+    // 2. Read proposal files for coverage matching
+    const proposalContent = readProposalFiles(changeDir);
+    // 3. Check coverage of each element
+    const uncovered = [];
+    for (const el of elements) {
+        const covered = isElementCovered(el, proposalContent);
+        if (!covered) {
+            uncovered.push(el);
+        }
+    }
+    // 4. Calculate coverage rate
+    const coveredCount = totalElements - uncovered.length;
+    const coverageRate = Math.round((coveredCount / totalElements) * 1000) / 10; // one decimal
+    // 5. Generate structured auto-fix suggestions report
+    if (uncovered.length > 0) {
+        // Map element type to suggested target file
+        const targetFileMap = {
+            database: 'specs/ 对应 spec.md（新增 Requirement）或 tasks.md（新增建表任务）',
+            api: 'specs/ 对应 spec.md（新增 API Scenario）',
+            class: 'tasks.md（新增实现任务）',
+            config: 'design.md 基础设施章节',
+            es: 'design.md 基础设施章节或 tasks.md（新增 ES 索引任务）',
+            mq: 'design.md 基础设施章节或 tasks.md（新增 MQ 配置任务）',
+            frontend: 'tasks.md（新增前端实现任务）',
+        };
+        const autoFixLines = [
+            `Tech spec coverage: ${coverageRate}% (${coveredCount}/${totalElements}).`,
+            '以下未覆盖元素将自动补充到提案中：',
+        ];
+        for (const el of uncovered) {
+            const target = targetFileMap[el.type] || 'design.md 或 tasks.md';
+            autoFixLines.push(`- [${el.type}] ${el.name} → 建议追加到 ${target}`);
+        }
+        const autoFixMsg = autoFixLines.join('\n');
+        // Always treat as warning (auto-fixable), never block
+        result.warnings.push(autoFixMsg);
+        if (coverageRate < 80) {
+            result.warnings.push(`Coverage ${coverageRate}% < 80% — AI 应自动将上述元素补充到对应提案文件，补充后重新检查直到 >= 80%`);
+        }
+    }
+    // Auto-fix mode: always pass (uncovered elements are auto-fixable, not blocking)
+    result.passed = true;
+    return result;
+}
+/**
+ * Extract structured elements from tech-spec.md content.
+ * Uses simple regex patterns — not a full parser.
+ */
+function extractTechSpecElements(content) {
+    const elements = [];
+    const seen = new Set();
+    const addElement = (type, name) => {
+        const key = `${type}:${name}`;
+        if (!seen.has(key) && name.length > 1) {
+            seen.add(key);
+            elements.push({ type, name });
+        }
+    };
+    // Database tables: CREATE TABLE / ALTER TABLE / t_xxx / table names in DDL sections
+    const tablePatterns = [
+        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?`?([\w.]+)`?/gi,
+        /ALTER\s+TABLE\s+`?([\w.]+)`?/gi,
+        /\b(t_[a-z][a-z0-9_]{2,})\b/g,
+    ];
+    for (const pat of tablePatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('database', m[1]);
+        }
+    }
+    // API / interface paths
+    const apiPatterns = [
+        /(?:@(?:Request|Get|Post|Put|Delete|Patch)Mapping)\s*\(\s*["']([^"']+)["']/gi,
+        /(?:path|url|endpoint)["'\s:=]+["']?(\/api\/[\w/{}.-]+)/gi,
+        /\b(\/api\/[\w/{}.-]+)\b/g,
+        /(?:SCF|RPC|HTTP|REST)\s+.*?["'`]([\w/.]+)["'`]/gi,
+    ];
+    for (const pat of apiPatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('api', m[1]);
+        }
+    }
+    // Class / interface / module names
+    const classPatterns = [
+        /\b(?:class|interface|enum)\s+([A-Z][A-Za-z0-9]+)/g,
+    ];
+    for (const pat of classPatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('class', m[1]);
+        }
+    }
+    // Config items: apollo.xxx / spring.xxx / application.yml keys
+    const configPatterns = [
+        /\b(apollo\.[a-zA-Z0-9._-]+)/g,
+        /\b(spring\.[a-zA-Z0-9._-]+)/g,
+        /\b(application\.[a-zA-Z0-9._-]+)/g,
+    ];
+    for (const pat of configPatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('config', m[1]);
+        }
+    }
+    // ES indexes
+    const esPatterns = [
+        /(?:index|mapping)["'\s:=]+["']?([a-z][a-z0-9_-]*_index[a-z0-9_-]*)/gi,
+        /\b([a-z][a-z0-9_]*_index)\b/g,
+    ];
+    for (const pat of esPatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('es', m[1]);
+        }
+    }
+    // MQ topics / consumers
+    const mqPatterns = [
+        /(?:topic|Topic)["'\s:=]+["']?([A-Z][A-Z0-9_]+)/g,
+        /\b(\w+Consumer)\b/g,
+        /\b(\w+Producer)\b/g,
+    ];
+    for (const pat of mqPatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('mq', m[1]);
+        }
+    }
+    // Frontend components / routes
+    const fePatterns = [
+        /\b(\w+(?:Page|View|Component|Modal|Dialog))\b/g,
+        /(?:route|path)["'\s:=]+["'](\/[\w/:.-]+)/gi,
+    ];
+    for (const pat of fePatterns) {
+        let m;
+        while ((m = pat.exec(content)) !== null) {
+            addElement('frontend', m[1]);
+        }
+    }
+    return elements;
+}
+/**
+ * Read all proposal files (proposal.md, design.md, specs/*.md, tasks.md)
+ * and concatenate their content for coverage matching.
+ */
+function readProposalFiles(changeDir) {
+    const parts = [];
+    const filesToRead = ['proposal.md', 'design.md', 'tasks.md'];
+    for (const f of filesToRead) {
+        const fp = join(changeDir, f);
+        try {
+            if (existsSync(fp)) {
+                parts.push(readFileSync(fp, 'utf-8'));
+            }
+        }
+        catch {
+            // graceful skip
+        }
+    }
+    // Read specs/*.md
+    const specsDir = join(changeDir, 'specs');
+    try {
+        if (existsSync(specsDir)) {
+            const specDirs = readdirSync(specsDir, { withFileTypes: true });
+            for (const entry of specDirs) {
+                if (entry.isDirectory()) {
+                    const specFile = join(specsDir, entry.name, 'spec.md');
+                    try {
+                        if (existsSync(specFile)) {
+                            parts.push(readFileSync(specFile, 'utf-8'));
+                        }
+                    }
+                    catch {
+                        // graceful skip
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // graceful skip
+    }
+    return parts.join('\n');
+}
+/**
+ * Check if a tech spec element is covered in the proposal content.
+ * Uses case-insensitive matching with the element name.
+ */
+function isElementCovered(element, proposalContent) {
+    const name = element.name;
+    // Exact match (case-insensitive)
+    if (proposalContent.toLowerCase().includes(name.toLowerCase())) {
+        return true;
+    }
+    // For database tables: also try without the t_ prefix
+    if (element.type === 'database' && name.startsWith('t_')) {
+        const withoutPrefix = name.substring(2);
+        if (proposalContent.toLowerCase().includes(withoutPrefix.toLowerCase())) {
+            return true;
+        }
+    }
+    // For API paths: try matching the last segment
+    if (element.type === 'api' && name.includes('/')) {
+        const segments = name.split('/').filter(Boolean);
+        const lastSegment = segments[segments.length - 1];
+        if (lastSegment && !lastSegment.startsWith('{') && proposalContent.toLowerCase().includes(lastSegment.toLowerCase())) {
+            return true;
+        }
+    }
+    // For class names: try matching camelCase split words
+    if (element.type === 'class') {
+        // Split PascalCase into words: e.g. OrderRefundService -> [Order, Refund, Service]
+        const words = name.replace(/([a-z])([A-Z])/g, '$1 $2').split(' ').filter(w => w.length > 2);
+        // If most words appear in proposal, consider it covered
+        if (words.length >= 2) {
+            const matchedWords = words.filter(w => proposalContent.toLowerCase().includes(w.toLowerCase()));
+            if (matchedWords.length >= Math.ceil(words.length * 0.6)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Rule: task-id-format
+ *
+ * Validates that all task IDs use the N.M format (e.g., 1.1, 2.3).
+ * Rejects non-standard formats like 3.2a, 1.1.1, abc, etc.
+ */
+const TASK_ID_PATTERN = /^\d+\.\d+$/;
+export function checkTaskIdFormat(tasksContent) {
+    const result = {
+        ruleId: 'task-id-format',
+        ruleName: 'Task ID format',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    const taskLines = tasksContent.match(/^- \[[ xX]\] (\S+) /gm) || [];
+    const invalidIds = [];
+    for (const line of taskLines) {
+        const match = line.match(/^- \[[ xX]\] (\S+)/);
+        if (match && !TASK_ID_PATTERN.test(match[1])) {
+            invalidIds.push(match[1]);
+        }
+    }
+    if (invalidIds.length > 0) {
+        result.errors = invalidIds.map(id => `Invalid task ID "${id}": must be N.M format (e.g., 1.1, 2.3)`);
+    }
+    result.passed = invalidIds.length === 0;
+    return result;
+}
 /**
  * Main entry: Run all strict validation rules
  */
 export async function runStrictValidation(tasksContent, parsedTasks, knownSkillNames, options) {
     const hasTestCase = options?.hasTestCase ?? false;
     const checks = [
+        checkTestCaseInquiryLogged(tasksContent),
         checkPreClarification(tasksContent),
         checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames),
         checkTaskOrderingByWave(tasksContent, parsedTasks),
@@ -655,11 +1193,20 @@ export async function runStrictValidation(tasksContent, parsedTasks, knownSkillN
         // review-gate-defined rule removed: review gate is enforced by the Review phase skill, not tasks.md
         checkFileConflicts(parsedTasks),
         checkTestCaseCoverage(tasksContent, hasTestCase),
+        checkTaskIdFormat(tasksContent),
     ];
     // Add new rules if parameters are provided
     if (options?.proposalContent) {
         checks.push(checkProposalFormatValid(options.proposalContent));
     }
+    // Add tech-spec-coverage rule if any tech spec document exists
+    if (options?.changeDir) {
+        const hasTechSpec = existsSync(join(options.changeDir, 'techDesign', 'tech-spec.md')) ||
+            existsSync(join(options.changeDir, 'tech-spec.md'));
+        if (hasTechSpec) {
+            checks.push(checkTechSpecCoverage(options.changeDir));
+        }
+    }
     // Detect current phase for spec-code consistency check
     if (options?.specsDir && options?.repoRoot) {
         const phase = options?.changeDir ? detectPhase(options.changeDir) : 'apply';