@zhuan-ai/zhuanspec 2.2.4 → 2.4.8

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

@@ -1,17 +1,18 @@
 /**
  * Strict Validation Rules
  *
- * Implementation of three strict validation rules for `zhuanspec validate --strict`:
- * 1. pre-clarification-completed: Check Pre-Clarification Log section
- * 2. skill-tags-valid: Validate @skill tags against known skills
- * 3. task-ordering-by-wave: Verify task ordering follows wave structure
+ * Implementation of strict validation rules for `zhuanspec validate --strict`.
  */
 import { generateExecutionPlan } from '../task-graph/execution-planner.js';
 import { renderExecutionPlanXml } from '../task-graph/xml-renderer.js';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import path from 'path';
 // Patterns for detecting unresolved markers
 const UNRESOLVED_MARKERS = /\b(TODO|TBD|PENDING|\?)\b/i;
 const HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
-const PRE_CLARIFICATION_SECTION_PATTERN = /^##\s+Pre-Clarification\s+Log\s*$/im;
+const PRE_CLARIFICATION_SECTION_PATTERN = /^##\s+(Pre-Clarification\s+Log|澄清日志)\s*$/im;
 const VALID_COMPLETION_MARKERS = [
     /no\s+clarification\s+needed/i,
     /status:\s*completed/i,
@@ -102,7 +103,7 @@ export function checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames)
     // a. Check Skill Mapping section exists with table data
     const sectionMatch = tasksContent.match(SKILL_MAPPING_SECTION_PATTERN);
     if (!sectionMatch) {
-        result.warnings.push('Skill Mapping section not found');
+        result.errors.push('Skill Mapping section not found');
     }
     else {
         // Extract section content (from header to next ## or end)
@@ -125,7 +126,7 @@ export function checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames)
         });
         // Need at least 2 rows (header + 1 data row)
         if (!dataRows || dataRows.length < 2) {
-            result.warnings.push('Skill Mapping table has no data rows');
+            result.errors.push('Skill Mapping table has no data rows');
         }
     }
     // If no tasks, consider it valid
@@ -336,16 +337,309 @@ export function checkSubagentDirectives(parsedTasks) {
     result.passed = result.errors.length === 0;
     return result;
 }
+/**
+ * Rule 5: review-gate-defined
+ *
+ * Tasks must explicitly mention zhuanspec review gate.
+ */
+export function checkReviewGateDefined(tasksContent) {
+    const result = {
+        ruleId: 'review-gate-defined',
+        ruleName: 'Review gate defined',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    const hasReviewGate = tasksContent.includes('zhuanspec review') ||
+        /review\s*gate/i.test(tasksContent) ||
+        /双轨审查/.test(tasksContent);
+    if (!hasReviewGate) {
+        result.errors.push('tasks.md must include a zhuanspec review gate before completion');
+        return result;
+    }
+    result.passed = true;
+    return result;
+}
+/**
+ * Rule 7: proposal-format-valid
+ *
+ * Validates that proposal.md contains required sections:
+ * - Why/变更原因
+ * - What Changes/变更内容
+ * - Impact/影响范围
+ */
+export function checkProposalFormatValid(proposalContent) {
+    const result = {
+        ruleId: 'proposal-format-valid',
+        ruleName: 'Proposal format valid',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    const requiredSections = [
+        { pattern: /^##\s+(变更原因|Why)/im, name: 'Why/变更原因' },
+        { pattern: /^##\s+(变更内容|What\s+Changes)/im, name: 'What Changes/变更内容' },
+        { pattern: /^##\s+(影响范围|Impact)/im, name: 'Impact/影响范围' },
+    ];
+    for (const section of requiredSections) {
+        if (!section.pattern.test(proposalContent)) {
+            result.errors.push(`Proposal 缺少必需章节：${section.name}`);
+        }
+    }
+    result.passed = result.errors.length === 0;
+    return result;
+}
+/**
+ * Detect current workflow phase based on progress.json.
+ *
+ * Phase detection logic:
+ * 1. If progress.json doesn't exist -> Propose phase
+ * 2. If progress.json exists with phase field -> use that phase
+ * 3. If progress.json exists without phase field -> Apply phase (default)
+ */
+export function detectPhase(changeDir) {
+    const progressPath = join(changeDir, 'metrics', 'progress.json');
+    // If no progress.json, we're in Propose phase
+    if (!existsSync(progressPath)) {
+        return 'propose';
+    }
+    try {
+        const progressContent = readFileSync(progressPath, 'utf-8');
+        const progress = JSON.parse(progressContent);
+        // If phase field exists, use it
+        if (progress.phase) {
+            return progress.phase;
+        }
+        // Default to Apply phase if progress.json exists but no phase field
+        return 'apply';
+    }
+    catch {
+        // If can't read/parse progress.json, assume Propose phase
+        return 'propose';
+    }
+}
+/**
+ * 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.
+ *
+ * SKIPPED in Propose phase (no code changes yet).
+ */
+function checkSpecCodeConsistent(specsDir, repoRoot, phase) {
+    const result = {
+        ruleId: 'spec-code-consistent',
+        ruleName: 'Spec-Code consistency',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // Skip this check in Propose phase
+    if (phase === 'propose') {
+        result.passed = true;
+        result.warnings.push('SKIPPED (Propose phase) - no code changes to validate');
+        return result;
+    }
+    // If specsDir doesn't exist, skip this check
+    if (!specsDir) {
+        result.passed = true;
+        return result;
+    }
+    // Collect requirements from delta specs
+    const requirements = [];
+    try {
+        const specDirs = readdirSync(specsDir, { withFileTypes: true });
+        for (const entry of specDirs) {
+            if (!entry.isDirectory())
+                continue;
+            const specFile = join(specsDir, entry.name, 'spec.md');
+            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
+            const lines = content.split('\n');
+            let currentSection = '';
+            for (const line of lines) {
+                if (line.match(/^##\s+(ADDED|Added|新增)/i))
+                    currentSection = 'ADDED';
+                else if (line.match(/^##\s+(MODIFIED|Modified|修改)/i))
+                    currentSection = 'MODIFIED';
+                else if (line.match(/^##\s+(REMOVED|Removed|删除)/i))
+                    currentSection = 'REMOVED';
+                else if (line.match(/^##\s+(RENAMED|Renamed|重命名)/i))
+                    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 });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Directory read error, skip
+        result.passed = true;
+        return result;
+    }
+    // If no requirements found, consider passed
+    if (requirements.length === 0) {
+        result.passed = true;
+        return result;
+    }
+    // Get git diff files
+    let touchedFiles = [];
+    try {
+        const gitOutput = execSync('git diff --name-only', {
+            cwd: repoRoot,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        touchedFiles = gitOutput.trim().split('\n').filter(Boolean);
+    }
+    catch {
+        // Git command failed, try git status for uncommitted changes
+        try {
+            const statusOutput = execSync('git status --porcelain', {
+                cwd: repoRoot,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            touchedFiles = statusOutput.trim().split('\n')
+                .map(line => line.replace(/^\s*[A-Z]+\s+/, '').trim())
+                .filter(Boolean);
+        }
+        catch {
+            // No git info available, pass the check
+            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 {
+                const fullPath = path.join(repoRoot, file);
+                if (!existsSync(fullPath))
+                    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}) 未找到对应代码改动`);
+        }
+    }
+    result.passed = result.errors.length === 0;
+    return result;
+}
+/**
+ * Rule: test-case-coverage
+ * Validates that tasks.md has test case coverage section.
+ * Behavior differs based on hasTestCase mode:
+ * - hasTestCase=true (TDD or user provided cases): REQUIRED, blocking if missing
+ * - hasTestCase=false (normal spec-driven): SKIPPED, warning only
+ *
+ * Table format validation (when hasTestCase=true):
+ * - Must have four columns: Task, 测试 Case ID, 测试 Case 文件路径, 覆盖场景
+ * - Column headers must match expected format
+ */
+export function checkTestCaseCoverage(tasksContent, hasTestCase = false) {
+    const result = {
+        ruleId: 'test-case-coverage',
+        ruleName: 'Test case coverage',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // If no test case mode, skip with warning
+    if (!hasTestCase) {
+        result.passed = true;
+        result.warnings.push('SKIPPED (no test case mode) - test-case-coverage check only applies when test cases are provided');
+        return result;
+    }
+    // Check for Test Case Coverage section (required when hasTestCase=true)
+    const testCaseSectionPattern = /^##\s+Test\s+Case\s+Coverage/im;
+    if (!testCaseSectionPattern.test(tasksContent)) {
+        result.errors.push('Missing Test Case Coverage section - REQUIRED when test cases are provided (TDD mode or user-provided cases)');
+        return result;
+    }
+    // Check for @test-case tags in tasks
+    const testCaseTagPattern = /@test-case:TC-\d+/g;
+    const testCaseTags = tasksContent.match(testCaseTagPattern);
+    if (testCaseTags && testCaseTags.length > 0) {
+        result.passed = true;
+    }
+    else {
+        result.errors.push('No @test-case tags found - REQUIRED when test cases are provided. Link tasks to test cases using @test-case:TC-XXX');
+    }
+    // Validate Test Case Coverage table format (four columns required)
+    // Expected headers: Task, 测试 Case ID, 测试 Case 文件路径, 覆盖场景
+    const tablePattern = /^##\s+Test\s+Case\s+Coverage\s*\n\n(?:<!--[^>]*-->\s*\n)?\|.*\|.*\|.*\|.*\|/m;
+    const tableMatch = tasksContent.match(tablePattern);
+    if (tableMatch) {
+        // Extract header row and validate columns
+        const headerLine = tableMatch[0].split('\n').find(line => line.startsWith('|') && !line.includes('<!--'));
+        if (headerLine) {
+            const columns = headerLine.split('|').filter(col => col.trim() !== '');
+            if (columns.length < 4) {
+                result.warnings.push(`Test Case Coverage table should have 4 columns (Task, 测试 Case ID, 测试 Case 文件路径, 覆盖场景), found ${columns.length}`);
+            }
+            else {
+                // Check column names contain expected keywords
+                const headerText = headerLine.toLowerCase();
+                const hasTaskCol = headerText.includes('task');
+                const hasTestCaseIdCol = headerText.includes('测试 case id') || headerText.includes('test case') || headerText.includes('tc');
+                const hasPathCol = headerText.includes('文件路径') || headerText.includes('path') || headerText.includes('路径');
+                const hasScenarioCol = headerText.includes('覆盖场景') || headerText.includes('场景') || headerText.includes('scenario');
+                if (!hasTaskCol || !hasTestCaseIdCol || !hasPathCol || !hasScenarioCol) {
+                    result.warnings.push('Test Case Coverage table headers should follow format: Task, 测试 Case ID, 测试 Case 文件路径, 覆盖场景');
+                }
+            }
+        }
+    }
+    else {
+        result.warnings.push('Test Case Coverage table format not detected - ensure table has 4 columns with proper headers');
+    }
+    return result;
+}
 /**
  * Main entry: Run all strict validation rules
  */
-export async function runStrictValidation(tasksContent, parsedTasks, knownSkillNames) {
+export async function runStrictValidation(tasksContent, parsedTasks, knownSkillNames, options) {
+    const hasTestCase = options?.hasTestCase ?? false;
     const checks = [
         checkPreClarification(tasksContent),
         checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames),
         checkTaskOrderingByWave(tasksContent, parsedTasks),
         checkSubagentDirectives(parsedTasks),
+        checkReviewGateDefined(tasksContent),
+        checkTestCaseCoverage(tasksContent, hasTestCase),
     ];
+    // Add new rules if parameters are provided
+    if (options?.proposalContent) {
+        checks.push(checkProposalFormatValid(options.proposalContent));
+    }
+    // Detect current phase for spec-code consistency check
+    if (options?.specsDir && options?.repoRoot) {
+        const phase = options?.changeDir ? detectPhase(options.changeDir) : 'apply';
+        checks.push(checkSpecCodeConsistent(options.specsDir, options.repoRoot, phase));
+    }
     const allPassed = checks.every(check => check.passed);
     return {
         checks,

package/dist/core/validation/validator.js

@@ -288,14 +288,64 @@ export class Validator {
                     });
                 }
                 // Run strict validation
-                const strictResult = await runStrictValidation(tasksContent, parsedTasks, knownSkillNames);
+                // Read proposal.md for proposal-format-valid check
+                const proposalPath = path.join(changeDir, 'proposal.md');
+                let proposalContent;
+                try {
+                    proposalContent = await fs.readFile(proposalPath, 'utf-8');
+                }
+                catch {
+                    // proposal.md not found - skip proposal format validation
+                }
+                // Get specs directory and repo root for spec-code-consistent check
+                const repoRoot = this.findProjectRoot(changeDir);
+                // Detect hasTestCase mode:
+                // 1. Check for test-cases.md file
+                // 2. Check for @test-case tags in tasks.md
+                // 3. Check for TDD schema in metadata
+                let hasTestCase = false;
+                const testCasesPath = path.join(changeDir, 'test-cases.md');
+                if (existsSync(testCasesPath)) {
+                    hasTestCase = true;
+                }
+                else if (tasksContent.includes('@test-case:')) {
+                    hasTestCase = true;
+                }
+                else {
+                    // Check metadata for schema type
+                    const metadataPath = path.join(changeDir, '.zhuanspec.yaml');
+                    try {
+                        const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+                        if (metadataContent.includes('schema: tdd') || metadataContent.includes('schema:\n  tdd')) {
+                            hasTestCase = true;
+                        }
+                    }
+                    catch {
+                        // No metadata file - assume spec-driven (no test cases)
+                    }
+                }
+                const strictResult = await runStrictValidation(tasksContent, parsedTasks, knownSkillNames, {
+                    proposalContent,
+                    specsDir,
+                    repoRoot,
+                    changeDir,
+                    hasTestCase,
+                });
                 strictChecks = strictResult.checks;
                 // Merge strict errors into main issues
                 for (const check of strictResult.checks) {
+                    // Determine path based on rule ID
+                    let issuePath = 'tasks.md';
+                    if (check.ruleId === 'proposal-format-valid') {
+                        issuePath = 'proposal.md';
+                    }
+                    else if (check.ruleId === 'spec-code-consistent') {
+                        issuePath = 'specs/';
+                    }
                     for (const error of check.errors) {
                         issues.push({
                             level: 'ERROR',
-                            path: 'tasks.md',
+                            path: issuePath,
                             message: `[${check.ruleName}] ${error}`,
                         });
                     }

package/dist/core/view.d.ts

@@ -3,6 +3,7 @@ export declare class ViewCommand {
     private getChangesData;
     private getSpecsData;
     private displaySummary;
+    private displayRichMetrics;
     private createProgressBar;
 }
 //# sourceMappingURL=view.d.ts.map

package/dist/core/view.js

@@ -3,6 +3,7 @@ import * as path from 'path';
 import chalk from 'chalk';
 import { getTaskProgressForChange } from '../utils/task-progress.js';
 import { MarkdownParser } from './parsers/markdown-parser.js';
+import { loadChangeMetrics } from './dashboard/metrics.js';
 export class ViewCommand {
     async execute(targetPath = '.') {
         const zhuanspecDir = path.join(targetPath, 'zhuanspec');
@@ -15,8 +16,9 @@ export class ViewCommand {
         // Get changes and specs data
         const changesData = await this.getChangesData(zhuanspecDir);
         const specsData = await this.getSpecsData(zhuanspecDir);
+        const activeMetrics = await Promise.all(changesData.active.map((change) => loadChangeMetrics(zhuanspecDir, change.name)));
         // Display summary metrics
-        this.displaySummary(changesData, specsData);
+        this.displaySummary(changesData, specsData, activeMetrics);
         // Display draft changes
         if (changesData.draft.length > 0) {
             console.log(chalk.bold.gray('\nDraft Changes'));
@@ -36,6 +38,7 @@ export class ViewCommand {
                     : 0;
                 console.log(`  ${chalk.yellow('◉')} ${chalk.bold(change.name.padEnd(30))} ${progressBar} ${chalk.dim(`${percentage}%`)}`);
             });
+            this.displayRichMetrics(activeMetrics);
         }
         // Display completed changes
         if (changesData.completed.length > 0) {
@@ -127,7 +130,7 @@ export class ViewCommand {
         }
         return specs;
     }
-    displaySummary(changesData, specsData) {
+    displaySummary(changesData, specsData, activeMetrics) {
         const totalChanges = changesData.draft.length + changesData.active.length + changesData.completed.length;
         const totalSpecs = specsData.length;
         const totalRequirements = specsData.reduce((sum, spec) => sum + spec.requirementCount, 0);
@@ -153,6 +156,61 @@ export class ViewCommand {
             const overallProgress = Math.round((completedTasks / totalTasks) * 100);
             console.log(`  ${chalk.magenta('●')} Task Progress: ${chalk.bold(`${completedTasks}/${totalTasks}`)} (${overallProgress}% complete)`);
         }
+        const totalTokenUsage = activeMetrics.reduce((sum, item) => sum + item.tokenUsage, 0);
+        const totalContextLoad = activeMetrics.reduce((sum, item) => sum + item.contextLoad, 0);
+        if (activeMetrics.length > 0) {
+            console.log(`  ${chalk.white('●')} Runtime Metrics: ${chalk.bold(`token=${totalTokenUsage}`)}, ${chalk.bold(`context=${totalContextLoad}`)}`);
+        }
+    }
+    displayRichMetrics(metricsList) {
+        const total = metricsList.length;
+        if (total === 0)
+            return;
+        console.log(chalk.bold.magenta('\nFlow Overview'));
+        console.log('─'.repeat(60));
+        for (const item of metricsList) {
+            const flowText = `${item.phase} -> ${item.currentNode}`;
+            const waveText = item.currentWave > 0 ? `Wave ${item.currentWave}` : 'Wave -';
+            const taskText = item.currentTask || item.nextTask || '-';
+            console.log(`  ${chalk.magenta('▸')} ${chalk.bold(item.changeId)}  ${chalk.dim(flowText)}  ${chalk.dim(waveText)}  task:${chalk.white(taskText)}`);
+        }
+        const totalToolCalls = metricsList.reduce((sum, m) => sum + m.toolCalls, 0);
+        const reviewCritical = metricsList.reduce((sum, m) => sum + m.review.critical, 0);
+        const reviewImportant = metricsList.reduce((sum, m) => sum + m.review.important, 0);
+        const reviewMinor = metricsList.reduce((sum, m) => sum + m.review.minor, 0);
+        const testPassed = metricsList.reduce((sum, m) => sum + m.tests.passed, 0);
+        const testFailed = metricsList.reduce((sum, m) => sum + m.tests.failed, 0);
+        const coverageValues = metricsList
+            .map((m) => m.tests.coverage)
+            .filter((v) => typeof v === 'number');
+        const avgCoverage = coverageValues.length > 0
+            ? Math.round(coverageValues.reduce((sum, v) => sum + v, 0) / coverageValues.length)
+            : null;
+        console.log(chalk.bold.magenta('\nEfficiency Metrics'));
+        console.log('─'.repeat(60));
+        console.log(`  ${chalk.magenta('▸')} Tool Calls: ${chalk.bold(totalToolCalls)}`);
+        const skillMap = {};
+        for (const metric of metricsList) {
+            for (const [name, count] of Object.entries(metric.skillCalls)) {
+                skillMap[name] = (skillMap[name] ?? 0) + count;
+            }
+        }
+        const topSkills = Object.entries(skillMap)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([name, count]) => `${name}:${count}`)
+            .join(', ');
+        console.log(`  ${chalk.magenta('▸')} Skill Calls: ${topSkills || 'N/A'}`);
+        console.log(chalk.bold.magenta('\nQuality Metrics'));
+        console.log('─'.repeat(60));
+        console.log(`  ${chalk.magenta('▸')} Review: C=${reviewCritical} I=${reviewImportant} M=${reviewMinor}`);
+        console.log(`  ${chalk.magenta('▸')} Tests: passed=${testPassed} failed=${testFailed} coverage=${avgCoverage !== null ? `${avgCoverage}%` : 'N/A'}`);
+        const totalDuration = metricsList.reduce((sum, m) => {
+            return sum + m.durations.proposeMs + m.durations.applyMs + m.durations.reviewMs + m.durations.archiveMs;
+        }, 0);
+        console.log(chalk.bold.magenta('\nTimeline'));
+        console.log('─'.repeat(60));
+        console.log(`  ${chalk.magenta('▸')} Total Duration: ${Math.round(totalDuration / 1000)}s`);
     }
     createProgressBar(completed, total, width = 20) {
         if (total === 0)

package/dist/mcp/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MCP Client Wrapper
+ *
+ * This module provides a wrapper for MCP tools that may be available
+ * in the runtime environment. If the MCP server is not configured,
+ * these functions will gracefully return empty results.
+ */
+interface SonarQueryParams {
+    branchName?: string;
+    staticType?: string;
+}
+interface SonarIssue {
+    type: string;
+    severity: string;
+    message: string;
+    file: string;
+    line?: number;
+}
+/**
+ * Query Sonar issues for a branch
+ *
+ * Note: This function uses the MCP tool mcp__sonar__get_Sonar_Query
+ * which must be configured in the environment. If not available,
+ * it returns an empty array.
+ */
+export declare function mcp__sonar__get_Sonar_Query(params: SonarQueryParams): Promise<SonarIssue[]>;
+export type { SonarQueryParams, SonarIssue };
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,31 @@
+/**
+ * MCP Client Wrapper
+ *
+ * This module provides a wrapper for MCP tools that may be available
+ * in the runtime environment. If the MCP server is not configured,
+ * these functions will gracefully return empty results.
+ */
+/**
+ * Query Sonar issues for a branch
+ *
+ * Note: This function uses the MCP tool mcp__sonar__get_Sonar_Query
+ * which must be configured in the environment. If not available,
+ * it returns an empty array.
+ */
+export async function mcp__sonar__get_Sonar_Query(params) {
+    // In a real implementation, this would call the MCP tool
+    // For now, we provide a placeholder that returns empty results
+    // when the MCP is not configured
+    try {
+        // Dynamic import to handle cases where MCP tools are not available
+        // The actual MCP tool mcp__sonar__get_Sonar_Query is provided by the runtime
+        // This wrapper serves as a TypeScript-compatible interface
+        // Return empty array as fallback
+        // The actual implementation would be handled by the MCP runtime
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/utils/file-system.d.ts

@@ -13,6 +13,7 @@ export declare class FileSystemUtils {
     static directoryExists(dirPath: string): Promise<boolean>;
     static writeFile(filePath: string, content: string): Promise<void>;
     static readFile(filePath: string): Promise<string>;
+    static deleteFile(filePath: string): Promise<void>;
     static updateFileWithMarkers(filePath: string, content: string, startMarker: string, endMarker: string): Promise<void>;
     static ensureWritePermissions(dirPath: string): Promise<boolean>;
 }

package/dist/utils/file-system.js

@@ -125,6 +125,17 @@ export class FileSystemUtils {
     static async readFile(filePath) {
         return await fs.readFile(filePath, 'utf-8');
     }
+    static async deleteFile(filePath) {
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            // File doesn't exist, nothing to delete
+        }
+    }
     static async updateFileWithMarkers(filePath, content, startMarker, endMarker) {
         let existingContent = '';
         if (await this.fileExists(filePath)) {

package/dist/utils/item-discovery.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+import { FileSystemUtils } from './file-system.js';
 export async function getActiveChangeIds(root = process.cwd()) {
     const changesPath = path.join(root, 'zhuanspec', 'changes');
     try {
@@ -8,13 +9,34 @@ export async function getActiveChangeIds(root = process.cwd()) {
         for (const entry of entries) {
             if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'archive')
                 continue;
-            const proposalPath = path.join(changesPath, entry.name, 'proposal.md');
+            const changeDir = path.join(changesPath, entry.name);
+            const proposalPath = path.join(changeDir, 'proposal.md');
             try {
+                // Check for proposal.md (normal propose/apply/review change)
                 await fs.access(proposalPath);
                 result.push(entry.name);
             }
             catch {
-                // skip directories without proposal.md
+                // No proposal.md - check if it's a techDesign change
+                const techDesignMarker = path.join(changeDir, '.tech-design');
+                const techDesignMarkerExists = await FileSystemUtils.fileExists(techDesignMarker);
+                // Also check progress.json phase
+                const progressPath = path.join(changeDir, 'metrics', 'progress.json');
+                let progressPhaseIsTechDesign = false;
+                if (await FileSystemUtils.fileExists(progressPath)) {
+                    try {
+                        const progressContent = await FileSystemUtils.readFile(progressPath);
+                        const progress = JSON.parse(progressContent);
+                        progressPhaseIsTechDesign = progress.phase === 'techDesign';
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                // If techDesign markers exist, add to active changes
+                if (techDesignMarkerExists || progressPhaseIsTechDesign) {
+                    result.push(entry.name);
+                }
             }
         }
         return result.sort();