@zhuan-ai/zhuanspec 2.9.5 → 2.11.2

package/dist/core/hooks/pre-archive.js

@@ -17,29 +17,28 @@ async function runPreArchiveHook(changeId) {
         return { continue: false, stopReason: 'missing-change', systemMessage: 'Missing --change for pre-archive check' };
     }
     const changeDir = path.join(process.cwd(), 'zhuanspec', 'changes', changeId);
-    const reviewPath = path.join(changeDir, 'metrics', 'review.json');
-    const testsPath = path.join(changeDir, 'metrics', 'tests.json');
-    const reviewReportPath = path.join(changeDir, 'review-report.md');
-    if (!(await FileSystemUtils.fileExists(reviewPath)) ||
-        !(await FileSystemUtils.fileExists(testsPath)) ||
+    const reviewDir = path.join(changeDir, 'review');
+    const codeReviewPath = path.join(reviewDir, 'code-review-result.json');
+    const unitTestPath = path.join(reviewDir, 'unit-test-result.json');
+    const reviewReportPath = path.join(reviewDir, 'review-report.md');
+    if (!(await FileSystemUtils.fileExists(codeReviewPath)) ||
+        !(await FileSystemUtils.fileExists(unitTestPath)) ||
         !(await FileSystemUtils.fileExists(reviewReportPath))) {
         return {
             continue: false,
             stopReason: 'review-or-tests-missing',
-            systemMessage: 'Pre-archive check failed: missing review.json/tests.json/review-report.md',
+            systemMessage: 'Pre-archive check failed: missing changes/<id>/review/code-review-result.json, unit-test-result.json, or review-report.md',
         };
     }
-    const review = JSON.parse(await FileSystemUtils.readFile(reviewPath));
-    const tests = JSON.parse(await FileSystemUtils.readFile(testsPath));
-    const reviewPassed = Boolean(review.passed);
-    const testPassed = Number(tests.failed ?? 1) === 0;
-    const specConsistencyPassed = review?.checks?.specCompliance === true;
-    const critical = Number(review?.summary?.critical ?? 0);
-    if (!reviewPassed || !testPassed || critical > 0 || !specConsistencyPassed) {
+    const codeReview = JSON.parse(await FileSystemUtils.readFile(codeReviewPath));
+    const unitTest = JSON.parse(await FileSystemUtils.readFile(unitTestPath));
+    const critical = Number(codeReview?.criticalCount ?? 0);
+    const testPassed = Boolean(unitTest?.testPassed);
+    if (critical > 0 || !testPassed) {
         return {
             continue: false,
             stopReason: 'quality-gate-failed',
-            systemMessage: `Pre-archive check failed: review=${reviewPassed}, tests=${testPassed}, specConsistency=${specConsistencyPassed}, critical=${critical}`,
+            systemMessage: `Pre-archive check failed: critical=${critical}, testPassed=${testPassed}`,
         };
     }
     return {

package/dist/core/hooks/pre-review.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pre-Review Hook
+ *
+ * Quality gate checks before entering Review phase:
+ * 1. All tasks in tasks.md are completed
+ * 2. Progress data is consistent with tasks.md
+ * 3. Specs completeness check (all delta specs have content)
+ */
+interface CheckResult {
+    passed: boolean;
+    message: string;
+    details?: string[];
+}
+export interface PreReviewResult {
+    passed: boolean;
+    details: {
+        tasksComplete: CheckResult;
+        progressConsistent: CheckResult;
+        specsComplete: CheckResult;
+    };
+}
+/**
+ * Run all pre-review checks for a change directory.
+ */
+export declare function preReviewHook(changePath: string): Promise<PreReviewResult>;
+export {};
+//# sourceMappingURL=pre-review.d.ts.map

package/dist/core/hooks/pre-review.js

@@ -0,0 +1,169 @@
+/**
+ * Pre-Review Hook
+ *
+ * Quality gate checks before entering Review phase:
+ * 1. All tasks in tasks.md are completed
+ * 2. Progress data is consistent with tasks.md
+ * 3. Specs completeness check (all delta specs have content)
+ */
+import path from 'path';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { readdirSync, existsSync } from 'fs';
+/**
+ * Run all pre-review checks for a change directory.
+ */
+export async function preReviewHook(changePath) {
+    const checks = {
+        tasksComplete: await checkTasksCompletion(changePath),
+        progressConsistent: await checkProgressConsistency(changePath),
+        specsComplete: await checkSpecsCompleteness(changePath),
+    };
+    return {
+        passed: Object.values(checks).every(c => c.passed),
+        details: checks,
+    };
+}
+/**
+ * Check that all tasks in tasks.md are completed.
+ */
+async function checkTasksCompletion(changePath) {
+    const tasksPath = path.join(changePath, 'tasks.md');
+    if (!await FileSystemUtils.fileExists(tasksPath)) {
+        return {
+            passed: false,
+            message: 'tasks.md not found',
+        };
+    }
+    try {
+        const content = await FileSystemUtils.readFile(tasksPath);
+        const allTasks = content.match(/^- \[[ x]\] .+$/gm) || [];
+        const uncompletedTasks = content.match(/^- \[ \] .+$/gm) || [];
+        const completedTasks = content.match(/^- \[x\] .+$/gm) || [];
+        if (allTasks.length === 0) {
+            return {
+                passed: false,
+                message: 'No tasks found in tasks.md',
+            };
+        }
+        if (uncompletedTasks.length > 0) {
+            return {
+                passed: false,
+                message: `${uncompletedTasks.length}/${allTasks.length} tasks uncompleted`,
+                details: uncompletedTasks.map(t => t.trim()),
+            };
+        }
+        return {
+            passed: true,
+            message: `All ${completedTasks.length} tasks completed`,
+        };
+    }
+    catch {
+        return {
+            passed: false,
+            message: 'Failed to read tasks.md',
+        };
+    }
+}
+/**
+ * Check that progress.json data is consistent with tasks.md counts.
+ */
+async function checkProgressConsistency(changePath) {
+    const progressPath = path.join(changePath, 'metrics', 'progress.json');
+    const tasksPath = path.join(changePath, 'tasks.md');
+    if (!await FileSystemUtils.fileExists(progressPath)) {
+        return {
+            passed: true,
+            message: 'No progress.json found (skipped)',
+        };
+    }
+    if (!await FileSystemUtils.fileExists(tasksPath)) {
+        return {
+            passed: true,
+            message: 'No tasks.md found (skipped)',
+        };
+    }
+    try {
+        const progressContent = await FileSystemUtils.readFile(progressPath);
+        const progress = JSON.parse(progressContent);
+        const tasksContent = await FileSystemUtils.readFile(tasksPath);
+        const totalFromTasks = (tasksContent.match(/^- \[[ x]\] .+$/gm) || []).length;
+        const completedFromTasks = (tasksContent.match(/^- \[x\] .+$/gm) || []).length;
+        const totalFromProgress = progress.totalTasks || 0;
+        if (totalFromProgress !== totalFromTasks) {
+            return {
+                passed: false,
+                message: `Task count mismatch: progress.json says ${totalFromProgress}, tasks.md has ${totalFromTasks}`,
+                details: [
+                    `progress.json totalTasks: ${totalFromProgress}`,
+                    `tasks.md total tasks: ${totalFromTasks}`,
+                    `tasks.md completed: ${completedFromTasks}`,
+                ],
+            };
+        }
+        return {
+            passed: true,
+            message: `Progress consistent: ${completedFromTasks}/${totalFromTasks} tasks`,
+        };
+    }
+    catch {
+        return {
+            passed: true,
+            message: 'Progress consistency check skipped (parse error)',
+        };
+    }
+}
+/**
+ * Check that all delta spec files under specs/ have meaningful content.
+ */
+async function checkSpecsCompleteness(changePath) {
+    const specsDir = path.join(changePath, 'specs');
+    if (!existsSync(specsDir)) {
+        return {
+            passed: false,
+            message: 'specs/ directory not found',
+        };
+    }
+    try {
+        const capabilities = readdirSync(specsDir, { withFileTypes: true })
+            .filter(e => e.isDirectory())
+            .map(e => e.name);
+        if (capabilities.length === 0) {
+            return {
+                passed: false,
+                message: 'No capability directories found in specs/',
+            };
+        }
+        const emptySpecs = [];
+        for (const cap of capabilities) {
+            const specPath = path.join(specsDir, cap, 'spec.md');
+            if (!existsSync(specPath)) {
+                emptySpecs.push(`${cap}/spec.md (missing)`);
+                continue;
+            }
+            const content = await FileSystemUtils.readFile(specPath);
+            // Check if spec has at least one delta marker (ADDED/MODIFIED/REMOVED)
+            const hasDelta = /\b(ADDED|MODIFIED|REMOVED)\b/.test(content);
+            if (!hasDelta) {
+                emptySpecs.push(`${cap}/spec.md (no delta markers)`);
+            }
+        }
+        if (emptySpecs.length > 0) {
+            return {
+                passed: false,
+                message: `${emptySpecs.length} spec(s) incomplete`,
+                details: emptySpecs,
+            };
+        }
+        return {
+            passed: true,
+            message: `All ${capabilities.length} spec(s) complete`,
+        };
+    }
+    catch {
+        return {
+            passed: false,
+            message: 'Failed to check specs completeness',
+        };
+    }
+}
+//# sourceMappingURL=pre-review.js.map

package/dist/core/hooks/record-progress.d.ts

@@ -98,6 +98,8 @@ interface SkillCallRecord {
     durationMs?: number;
     success: boolean;
     outputSummary?: string;
+    afterAction?: string;
+    flowResumed?: boolean;
 }
 /**
  * Hook 触发记录
@@ -149,6 +151,28 @@ export interface PhaseDurationRecord {
     taskCount: number;
     completedTaskCount: number;
 }
+/**
+ * Proposal change record for tracking modifications to proposal files
+ */
+export interface ProposalChangeRecord {
+    changeRecordId: string;
+    timestamp: string;
+    phase: string;
+    triggeredBy: 'reverse-sync' | 'manual-edit' | 'ai-supplement' | 'review-fix';
+    modifiedFiles: Array<{
+        filePath: string;
+        changeType: 'modified' | 'created' | 'deleted';
+        summary: string;
+        diff?: {
+            before: string;
+            after: string;
+        };
+        linesAdded?: number;
+        linesRemoved?: number;
+    }>;
+    reason?: string;
+    relatedDeviationId?: string;
+}
 export interface ProgressData {
     changeId: string;
     sessionId: string;
@@ -181,6 +205,7 @@ export interface ProgressData {
             archive: number;
         };
     };
+    proposalChanges: ProposalChangeRecord[];
     events?: Array<{
         event: string;
         timestamp: string;

package/dist/core/hooks/record-progress.js

@@ -7,7 +7,7 @@
  * 3. Track tool calls for metrics
  */
 import path from 'path';
-import { promises as fsPromises } from 'fs';
+import { promises as fsPromises, existsSync, readFileSync, unlinkSync } from 'fs';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { PHASE_ORDER } from '../../utils/phase-utils.js';
 const fs = fsPromises;
@@ -103,6 +103,7 @@ export async function recoverProgressJsonForWrite(filePath) {
                 linesRemoved: 0,
                 deviationCount: 0,
                 deviationRecords: [],
+                proposalChanges: [],
                 reviewStats: { loopCount: 0, criticalFixes: 0, testFixes: 0, consistencyFixes: 0 },
                 phaseTransitions: [],
                 phaseDurations: [{
@@ -281,6 +282,34 @@ async function detectActiveChange(cwd, filePath) {
     candidates.sort((a, b) => b.sortKey - a.sortKey);
     return { changeId: candidates[0].changeId, phase: candidates[0].phase };
 }
+/**
+ * Check if a file path is a proposal file
+ */
+function isProposalFile(filePath, changePath) {
+    const absFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+    const absChangePath = path.isAbsolute(changePath) ? changePath : path.resolve(process.cwd(), changePath);
+    if (!absFilePath.startsWith(absChangePath + path.sep))
+        return false;
+    const relativePath = path.relative(absChangePath, absFilePath);
+    return ['proposal.md', 'tasks.md', 'design.md', 'test-cases.md']
+        .some(f => relativePath === f)
+        || relativePath.startsWith('specs' + path.sep);
+}
+/**
+ * Generate a brief summary of proposal file changes from tool input
+ */
+function generateProposalChangeSummary(toolInput) {
+    const content = typeof toolInput.content === 'string' ? toolInput.content : '';
+    if (!content)
+        return 'File modified';
+    // Extract first meaningful line as summary
+    const lines = content.split('\n').filter(l => l.trim().length > 0);
+    if (lines.length === 0)
+        return 'File modified';
+    const firstLine = lines[0].trim();
+    // Truncate to 120 chars
+    return firstLine.length > 120 ? firstLine.substring(0, 117) + '...' : firstLine;
+}
 async function runRecordProgress(filePath, toolName, success, stdinData) {
     const cwd = process.cwd();
     // Priority: filePath-derived > progress.json scan > environment variables
@@ -327,6 +356,7 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             };
             progress.phaseTransitions = progress.phaseTransitions || [];
             progress.phaseDurations = progress.phaseDurations || [];
+            progress.proposalChanges = progress.proposalChanges || [];
             progress.stats = progress.stats || {
                 tokenUsageTotal: 0,
                 contextLoad: 0,
@@ -434,6 +464,43 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
             progress.filesModified.push(filePath);
         }
     }
+    // Detect proposal file changes and record them
+    const changePath = path.join(zhuanspecDir, 'changes', changeId);
+    const WRITE_EDIT_TOOLS = new Set(['Write', 'Edit']);
+    if (filePath && WRITE_EDIT_TOOLS.has(toolName) && isProposalFile(filePath, changePath)) {
+        const relativeProposalPath = path.relative(changePath, path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+        const linesContent = typeof toolInput.content === 'string' ? toolInput.content : '';
+        const contentLines = linesContent ? linesContent.split('\n').length : 0;
+        const record = {
+            changeRecordId: `pc-${Date.now()}`,
+            timestamp,
+            phase,
+            triggeredBy: phase === 'apply' ? 'reverse-sync' : phase === 'review' ? 'review-fix' : 'manual-edit',
+            modifiedFiles: [{
+                    filePath: relativeProposalPath,
+                    changeType: toolName === 'Write' ? 'created' : 'modified',
+                    summary: generateProposalChangeSummary(toolInput),
+                    linesAdded: contentLines,
+                    linesRemoved: 0,
+                }],
+        };
+        // Read related deviation ID from temp file (cross-process communication)
+        let relatedDeviationId;
+        try {
+            const deviationIdPath = path.join(changePath, 'metrics', '.last-deviation-id');
+            if (existsSync(deviationIdPath)) {
+                relatedDeviationId = readFileSync(deviationIdPath, 'utf-8').trim();
+                unlinkSync(deviationIdPath); // consume after reading
+            }
+        }
+        catch {
+            // graceful degradation - no deviation ID available
+        }
+        if (relatedDeviationId) {
+            record.relatedDeviationId = relatedDeviationId;
+        }
+        progress.proposalChanges.push(record);
+    }
     // Try to estimate lines from content
     const content = stdinData.tool_input?.content;
     if (content) {
@@ -470,6 +537,24 @@ async function runRecordProgress(filePath, toolName, success, stdinData) {
                 progress.stats.durationMs.archive = elapsedMs;
         }
     }
+    // === Auto-count tasks from tasks.md ===
+    const tasksPath = path.join(changeDir, 'tasks.md');
+    if (await FileSystemUtils.fileExists(tasksPath)) {
+        try {
+            const tasksContent = await FileSystemUtils.readFile(tasksPath);
+            const totalTaskMatches = tasksContent.match(/^- \[[ x]\] .+$/gm) || [];
+            const completedTaskMatches = tasksContent.match(/^- \[x\] .+$/gm) || [];
+            progress.totalTasks = totalTaskMatches.length;
+            // Update completedTasks array with completed task descriptions
+            const completedDescriptions = completedTaskMatches.map(t => t.replace(/^- \[x\] /, '').trim());
+            if (completedDescriptions.length > 0) {
+                progress.completedTasks = completedDescriptions;
+            }
+        }
+        catch {
+            // Ignore tasks.md read errors
+        }
+    }
     // Write progress file atomically
     await atomicWriteJson(progressPath, progress);
     // Also update tool_calls.json separately for detailed tracking
@@ -569,6 +654,7 @@ function createNewProgress(changeId) {
             consistencyFixes: 0,
         },
         phaseTransitions: [],
+        proposalChanges: [],
         phaseDurations: [{
                 phase: initialPhase,
                 startedAt: getBeijingTime(),
@@ -617,6 +703,7 @@ export async function initializeProgress(changeId, initialPhase = 'propose') {
             progress.filesModified = progress.filesModified || [];
             progress.completedTasks = progress.completedTasks || [];
             progress.deviationRecords = progress.deviationRecords || [];
+            progress.proposalChanges = progress.proposalChanges || [];
             progress.phaseTransitions = progress.phaseTransitions || [];
             progress.phaseDurations = progress.phaseDurations || [];
             progress.reviewStats = progress.reviewStats || {

package/dist/core/hooks/review-hooks.js

@@ -13,10 +13,10 @@
  * - Controls loop count (max 3)
  */
 import path from 'path';
+import fs from 'fs';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { getBeijingTime } from './record-progress.js';
 // Output file paths for skill results
-const SKILL_OUTPUT_DIR = 'zhuanspec/.skill-outputs';
 const CODE_REVIEW_OUTPUT = 'code-review-result.json';
 const UNIT_TEST_OUTPUT = 'unit-test-result.json';
 const SPEC_CONSISTENCY_OUTPUT = 'spec-consistency-result.json';
@@ -143,15 +143,19 @@ export async function unitTestResultCheck(changeId, skillOutput) {
     };
 }
 export async function specConsistencyResultCheck(changeId, skillOutput) {
-    const output = skillOutput || await readSkillOutput(changeId, SPEC_CONSISTENCY_OUTPUT);
+    let output = skillOutput || await readSkillOutput(changeId, SPEC_CONSISTENCY_OUTPUT);
+    // Fallback: auto-execute basic consistency analysis when no JSON exists
+    if (!output) {
+        output = await runBasicConsistencyAnalysis(changeId);
+    }
     if (!output) {
         return {
             pass: false,
             needFix: false,
             loopCount: 0,
-            metrics: { error: 'No skill output found' },
+            metrics: { error: 'No skill output found and basic analysis failed' },
             nextAction: 'stop',
-            fixPrompt: 'Spec-consistency skill output not found. Please run spec-code-consistency check first.',
+            fixPrompt: 'Spec-consistency skill output not found and basic analysis failed. Please run spec-code-consistency check first.',
         };
     }
     const loopCount = (output.loopCount || 0) + 1;
@@ -201,11 +205,174 @@ export async function specConsistencyResultCheck(changeId, skillOutput) {
     };
 }
 // ============================================================
+// Basic Consistency Analysis Fallback
+// ============================================================
+/**
+ * Run basic consistency analysis when spec-consistency-result.json is missing.
+ * Reads specs/ under the change directory, extracts Requirements/Scenarios,
+ * searches touched files for keyword matches, and writes a basic result.
+ */
+async function runBasicConsistencyAnalysis(changeId) {
+    const cwd = process.cwd();
+    const changeDir = path.join(cwd, 'zhuanspec', 'changes', changeId);
+    const specsDir = path.join(changeDir, 'specs');
+    // Check if specs directory exists
+    if (!await FileSystemUtils.directoryExists(specsDir)) {
+        return null;
+    }
+    try {
+        const specEntries = await fs.promises.readdir(specsDir, { withFileTypes: true });
+        const allRequirements = [];
+        for (const entry of specEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const specFile = path.join(specsDir, entry.name, 'spec.md');
+            if (!await FileSystemUtils.fileExists(specFile))
+                continue;
+            const content = await FileSystemUtils.readFile(specFile);
+            const lines = content.split('\n');
+            let currentSection = '';
+            let currentReq = null;
+            let reqCounter = 0;
+            let scenarioCounter = 0;
+            for (const line of lines) {
+                if (line.match(/^##\s+(ADDED|Added|\u65b0\u589e)/i))
+                    currentSection = 'ADDED';
+                else if (line.match(/^##\s+(MODIFIED|Modified|\u4fee\u6539)/i))
+                    currentSection = 'MODIFIED';
+                else if (line.match(/^##\s+(REMOVED|Removed|\u5220\u9664)/i))
+                    currentSection = 'REMOVED';
+                else if (line.match(/^###\s+(Requirement|\u9700\u6c42)[\uff1a:]/i)) {
+                    const reqName = line.replace(/^###\s+(Requirement|\u9700\u6c42)[\uff1a:]\s+/i, '').trim();
+                    if (currentSection === 'ADDED' || currentSection === 'MODIFIED') {
+                        reqCounter++;
+                        currentReq = { id: `REQ-${reqCounter}`, name: reqName, scenarios: [] };
+                        allRequirements.push(currentReq);
+                    }
+                    else {
+                        currentReq = null;
+                    }
+                }
+                else if (line.match(/^####\s+(Scenario|\u573a\u666f)[\uff1a:]/i) && currentReq) {
+                    scenarioCounter++;
+                    const scenarioDesc = line.replace(/^####\s+(Scenario|\u573a\u666f)[\uff1a:]\s+/i, '').trim();
+                    currentReq.scenarios.push({ id: `SC-${scenarioCounter}`, description: scenarioDesc });
+                }
+            }
+        }
+        if (allRequirements.length === 0) {
+            return null;
+        }
+        // Get touched files from git
+        let touchedFiles = [];
+        try {
+            const { execSync } = await import('child_process');
+            const diffOutput = execSync('git diff --name-only HEAD', {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            touchedFiles = diffOutput.split('\n').map(f => f.trim()).filter(f => f.length > 0);
+            const statusOutput = execSync('git status --porcelain', {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            const statusFiles = statusOutput.split('\n')
+                .map(l => l.replace(/^\s*[A-Z?]+\s+/, '').trim())
+                .filter(f => f.length > 0);
+            touchedFiles = [...new Set([...touchedFiles, ...statusFiles])];
+        }
+        catch {
+            // No git info available
+        }
+        // Build scenario mapping and check coverage
+        const mapping = [];
+        const uncoveredScenarios = [];
+        let totalScenarios = 0;
+        let coveredCount = 0;
+        for (const req of allRequirements) {
+            const scenarios = req.scenarios.length > 0
+                ? req.scenarios
+                : [{ id: `${req.id}-implicit`, description: req.name }];
+            for (const scenario of scenarios) {
+                totalScenarios++;
+                const keywords = scenario.description
+                    .toLowerCase()
+                    .split(/[\s\-_/\uff0c\u3001]+/)
+                    .filter(w => w.length > 3);
+                let found = false;
+                let matchedFile = '';
+                for (const file of touchedFiles) {
+                    const fileLower = file.toLowerCase();
+                    if (keywords.some(kw => fileLower.includes(kw))) {
+                        found = true;
+                        matchedFile = file;
+                        break;
+                    }
+                    try {
+                        const fullPath = path.isAbsolute(file) ? file : path.join(cwd, file);
+                        const fileContent = await FileSystemUtils.readFile(fullPath);
+                        if (keywords.some(kw => fileContent.toLowerCase().includes(kw))) {
+                            found = true;
+                            matchedFile = file;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
+                if (found) {
+                    coveredCount++;
+                    mapping.push({
+                        requirementId: req.id,
+                        scenarioId: scenario.id,
+                        codeFile: matchedFile,
+                        status: 'covered',
+                    });
+                }
+                else {
+                    mapping.push({
+                        requirementId: req.id,
+                        scenarioId: scenario.id,
+                        codeFile: '',
+                        status: 'missing',
+                    });
+                    uncoveredScenarios.push({
+                        requirementId: req.id,
+                        scenarioId: scenario.id,
+                        description: scenario.description,
+                    });
+                }
+            }
+        }
+        const consistencyRate = totalScenarios > 0
+            ? Math.round((coveredCount / totalScenarios) * 100)
+            : 100;
+        const result = {
+            consistencyRate,
+            totalRequirements: allRequirements.length,
+            totalScenarios,
+            coveredScenarios: coveredCount,
+            uncoveredScenarios,
+            mapping,
+            loopCount: 0,
+        };
+        // Write the result so subsequent calls can read it directly
+        await writeSkillOutput(changeId, SPEC_CONSISTENCY_OUTPUT, result);
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
 // Helper Functions
 // ============================================================
 async function readSkillOutput(changeId, filename) {
     const cwd = process.cwd();
-    const outputPath = path.join(cwd, SKILL_OUTPUT_DIR, changeId, filename);
+    const outputPath = path.join(cwd, 'zhuanspec', 'changes', changeId, 'review', filename);
     try {
         if (await FileSystemUtils.fileExists(outputPath)) {
             const content = await FileSystemUtils.readFile(outputPath);
@@ -276,7 +443,7 @@ export async function writeSpecConsistencyOutput(changeId, output) {
 export { writeSkillOutput };
 async function writeSkillOutput(changeId, filename, data) {
     const cwd = process.cwd();
-    const outputDir = path.join(cwd, SKILL_OUTPUT_DIR, changeId);
+    const outputDir = path.join(cwd, 'zhuanspec', 'changes', changeId, 'review');
     await FileSystemUtils.createDirectory(outputDir);
     const outputPath = path.join(outputDir, filename);
     await FileSystemUtils.writeFile(outputPath, JSON.stringify(data, null, 2));
@@ -337,7 +504,9 @@ ${results.codeReview.pass && results.unitTest.pass && results.specConsistency.pa
     // Write report to change directory
     const cwd = process.cwd();
     const changeDir = path.join(cwd, 'zhuanspec', 'changes', changeId);
-    const reportPath = path.join(changeDir, 'review-report.md');
+    const reviewDir = path.join(changeDir, 'review');
+    const reportPath = path.join(reviewDir, 'review-report.md');
+    await FileSystemUtils.createDirectory(reviewDir);
     await FileSystemUtils.writeFile(reportPath, report);
     return report;
 }