svharness 0.15.10 → 0.15.13

package/dist/lib/gate-checker.js

@@ -13,10 +13,21 @@ const ESSENTIAL_FILES = [
     'AGENTS_BUILD.md',
     '.harness-build-state.yaml',
 ];
-async function runMechanicalGates(harnessRoot, verbose = false) {
-    const doctor_exit = await runDoctorGate(harnessRoot);
+const REQ_PACK_ESSENTIAL = [
+    'harness.yaml',
+    '.harness-build-state.yaml',
+    'requirements/raw',
+    'requirements/md',
+    'requirements/yaml',
+    'requirements/_work',
+];
+async function runMechanicalGates(harnessRoot, opts = {}) {
+    const normalized = typeof opts === 'boolean' ? { verbose: opts } : opts;
+    const scope = normalized.scope ?? 'full';
+    const verbose = normalized.verbose ?? false;
+    const doctor_exit = await runDoctorGate(harnessRoot, scope);
     const verify_exit = await runVerifyGate(harnessRoot, verbose);
-    const file_completeness_pct = await computeFileCompleteness(harnessRoot);
+    const file_completeness_pct = await computeFileCompleteness(harnessRoot, scope);
     return {
         doctor_exit,
         verify_exit,
@@ -24,11 +35,11 @@ async function runMechanicalGates(harnessRoot, verbose = false) {
         doctor_passed: doctor_exit === 0,
     };
 }
-async function runDoctorGate(harnessRoot) {
+async function runDoctorGate(harnessRoot, scope) {
     try {
         const report = await (0, index_1.runDoctorChecks)({
             harnessRoot,
-            mode: 'pre-seal',
+            mode: scope === 'requirements' ? 'requirements' : 'pre-seal',
             strict: true,
         });
         return report.passed ? 0 : 1;
@@ -48,11 +59,10 @@ async function runVerifyGate(harnessRoot, verbose) {
         return 1;
     }
 }
-async function computeFileCompleteness(harnessRoot) {
-    const checks = [...ESSENTIAL_FILES];
-    for (const dir of ['requirements', 'references', 'specs', 'agent-env', 'tasks']) {
-        checks.push(dir);
-    }
+async function computeFileCompleteness(harnessRoot, scope) {
+    const checks = scope === 'requirements'
+        ? [...REQ_PACK_ESSENTIAL]
+        : [...ESSENTIAL_FILES, 'requirements', 'references', 'specs', 'agent-env', 'tasks'];
     let present = 0;
     for (const rel of checks) {
         if (await fs_extra_1.default.pathExists(node_path_1.default.join(harnessRoot, rel)))

package/dist/lib/phase-prompt-loader.js

@@ -8,6 +8,7 @@ exports.renderPrompt = renderPrompt;
 exports.wrapAcpPrompt = wrapAcpPrompt;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
 const auto_assets_1 = require("./auto-assets");
 async function loadPhasePrompt(templateName, vars, promptDirOverride) {
     const assets = (0, auto_assets_1.resolveAutoAssetPaths)(promptDirOverride);
@@ -21,6 +22,9 @@ async function loadPhasePrompt(templateName, vars, promptDirOverride) {
 function renderPrompt(template, vars) {
     return template.replace(/\{\{([A-Z0-9_]+)\}\}/g, (match, key) => {
         const value = vars[key];
+        if (value === undefined || value === null) {
+            logger_1.logger.warn(`prompt 模板中占位符 {{${key}}} 未提供值，保留原样`);
+        }
         return value === undefined || value === null ? match : String(value);
     });
 }

package/dist/lib/phase-runner.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhaseRunner = exports.PHASE_DEFS = void 0;
+exports.PhaseRunner = exports.SCOPE_PHASES = exports.PHASE_DEFS = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const logger_1 = require("../utils/logger");
@@ -28,6 +28,10 @@ exports.PHASE_DEFS = [
     { key: 'S70_runtime_assets', short: 'S70', mode: 'acp', promptTemplate: 'S70-runtime-assets.md' },
     { key: 'S80_seed_memory', short: 'S80', mode: 'acp', promptTemplate: 'S80-seed-memory.md' },
 ];
+exports.SCOPE_PHASES = {
+    full: null,
+    requirements: ['S30_convert_docs', 'S40_extract_requirements'],
+};
 /** 阶段描述映射，供阶段执行时显示给用户了解当前进展。 */
 const PHASE_DESC = {
     S10_wiki: '生成 baseline wiki 正文',
@@ -62,7 +66,14 @@ class PhaseRunner {
     async getBuildPhases() {
         const harnessRoot = this.ctx.harnessRoot;
         const state = await (0, auto_state_1.readBuildState)(harnessRoot);
-        return exports.PHASE_DEFS.filter((def) => def.key in state.phases);
+        const allowed = exports.SCOPE_PHASES[this.ctx.scope];
+        return exports.PHASE_DEFS.filter((def) => {
+            if (!(def.key in state.phases))
+                return false;
+            if (allowed && !allowed.includes(def.key))
+                return false;
+            return true;
+        });
     }
     shouldStopAtMaxPhase(def) {
         if (!this.ctx.maxPhase)
@@ -107,61 +118,108 @@ class PhaseRunner {
             logger_1.logger.plain(`\n--- ${def.key} prompt ---\n${prompt}\n`);
             return;
         }
-        // Prepend a non-interactive preamble to every ACP prompt.  This prevents
-        // Claude from asking questions or waiting for confirmation (it has no
-        // stdin backchannel in --print mode) and forces a completion signal as
-        // the very last line of output so the harness can detect phase completion
-        // reliably.
-        const boundedPrompt = (0, phase_prompt_loader_1.wrapAcpPrompt)(prompt, `<PHASE_DONE>${def.short}</PHASE_DONE>`);
         for (let attempt = 0; attempt <= this.ctx.maxRetriesPerPhase; attempt++) {
-            this.cost.recordCall(def.key);
-            const result = await this.acp.call({
-                workDir: harnessRoot,
-                phase: def.key,
-                prompt: boundedPrompt,
-                timeoutMs: this.ctx.acpTimeoutMs,
-                onData: (text) => event_bus_1.dashboardEventBus.emitAcpOutput(def.key, text),
-            });
-            await this.writeAcpLog(def.short, result.output, result.error);
-            if (!result.success) {
-                logger_1.logger.warn(`${def.key} ACP 调用失败：${result.error ?? 'unknown error'}`);
+            // Recalculate boundedPrompt inside the retry loop so each attempt gets:
+            // 1) A fresh wrap with the attempt number in context, and
+            // 2) Awareness of any partial artifacts left by previous attempts.
+            // Without this, every retry receives the same prompt and Claude would
+            // start from scratch rather than incrementally fixing.
+            const attemptPrompt = attempt > 0
+                ? `[重试第 ${attempt} 次] 这是第 ${attempt} 次尝试。如果上一次尝试已经产生了部分文件，请检查并修复它们，不要从头开始。\n${prompt}`
+                : prompt;
+            const boundedPrompt = (0, phase_prompt_loader_1.wrapAcpPrompt)(attemptPrompt, `<PHASE_DONE>${def.short}</PHASE_DONE>`);
+            // Try ACP call; on CostTracker budget/call-limit error, fall back to
+            // free recovery checks (signal + artifact detection) without crashing.
+            let acpOk = true;
+            try {
+                this.cost.recordCall(def.key);
             }
-            const after = await (0, auto_state_1.readBuildState)(harnessRoot);
-            const afterStatus = (0, auto_state_1.phaseStatus)(after, def.key);
-            if (afterStatus === 'DONE' || afterStatus === 'SKIPPED') {
-                const elapsed = Date.now() - phaseStartTime;
-                event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, afterStatus, elapsed);
-                const label = afterStatus === 'DONE' ? '✅ 完成' : '⏭️ 跳过';
-                logger_1.logger.success(`${def.key} ${label}`);
-                return;
+            catch (err) {
+                acpOk = false;
+                logger_1.logger.warn(`${def.key} 资源限制：${err.message}，跳过 ACP 调用并尝试产物兜底`);
             }
-            // Fallback: Claude may have emitted a completion signal in its text output
-            // but failed to edit the YAML state file.  Rely on the signal instead.
-            const resolved = await this.tryResolveFromSignal(def, harnessRoot, result);
-            if (resolved) {
-                const elapsed = Date.now() - phaseStartTime;
-                event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, resolved, elapsed);
-                const label = resolved === 'DONE' ? '✅ 完成（信号兜底）' : '⏭️ 跳过（信号兜底）';
-                logger_1.logger.success(`${def.key} ${label}`);
-                return;
+            if (acpOk) {
+                const result = await this.acp.call({
+                    workDir: harnessRoot,
+                    phase: def.key,
+                    prompt: boundedPrompt,
+                    timeoutMs: this.ctx.acpTimeoutMs,
+                    onData: (text) => event_bus_1.dashboardEventBus.emitAcpOutput(def.key, text),
+                });
+                await this.writeAcpLog(def.short, result.output, result.error);
+                if (!result.success) {
+                    logger_1.logger.warn(`${def.key} ACP 调用失败：${result.error ?? 'unknown error'}`);
+                }
+                const after = await (0, auto_state_1.readBuildState)(harnessRoot);
+                const afterStatus = (0, auto_state_1.phaseStatus)(after, def.key);
+                if (afterStatus === 'DONE' || afterStatus === 'SKIPPED') {
+                    const elapsed = Date.now() - phaseStartTime;
+                    event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, afterStatus, elapsed);
+                    const label = afterStatus === 'DONE' ? '✅ 完成' : '⏭️ 跳过';
+                    logger_1.logger.success(`${def.key} ${label}`);
+                    return;
+                }
+                // Fallback: Claude may have emitted a completion signal in its text output
+                // but failed to edit the YAML state file.  Rely on the signal instead.
+                const resolved = await this.tryResolveFromSignal(def, harnessRoot, result);
+                if (resolved) {
+                    const elapsed = Date.now() - phaseStartTime;
+                    event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, resolved, elapsed);
+                    const label = resolved === 'DONE' ? '✅ 完成（信号兜底）' : '⏭️ 跳过（信号兜底）';
+                    logger_1.logger.success(`${def.key} ${label}`);
+                    return;
+                }
+                // Fallback: detect phase completion by checking for expected output artifacts.
+                // Some phases (e.g. S40_extract_requirements) may have produced all required
+                // artifacts even though Claude failed to emit the completion signal or update the
+                // YAML state file.  Detect and resolve programmatically to avoid false retries.
+                const artifactResolved = await this.tryResolveFromArtifacts(def, harnessRoot, result, phaseStartTime);
+                if (artifactResolved) {
+                    const elapsed = Date.now() - phaseStartTime;
+                    event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, artifactResolved, elapsed);
+                    logger_1.logger.success(`${def.key} ✅ 完成（产物兜底检测）`);
+                    return;
+                }
             }
-            // Fallback: detect phase completion by checking for expected output artifacts.
-            // Some phases (e.g. S40_extract_requirements) may have produced all required
-            // artifacts even though Claude failed to emit the completion signal or update the
-            // YAML state file.  Detect and resolve programmatically to avoid false retries.
-            const artifactResolved = await this.tryResolveFromArtifacts(def, harnessRoot);
-            if (artifactResolved) {
-                const elapsed = Date.now() - phaseStartTime;
-                event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, artifactResolved, elapsed);
-                logger_1.logger.success(`${def.key} ✅ 完成（产物兜底检测）`);
-                return;
+            else {
+                // Budget/call-limit exhausted: skip ACP but try free artifact fallback.
+                // The previous ACP attempt (which was already paid for) may have left valid
+                // artifacts on disk even though the state file wasn't updated to DONE.
+                logger_1.logger.warn(`${def.key} 资源已耗尽，尝试产物兜底恢复...`);
+                const artifactResolved = await this.tryResolveFromArtifacts(def, harnessRoot, { success: true }, phaseStartTime);
+                if (artifactResolved) {
+                    const elapsed = Date.now() - phaseStartTime;
+                    event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, artifactResolved, elapsed);
+                    logger_1.logger.success(`${def.key} ✅ 完成（资源受限产物兜底）`);
+                    return;
+                }
+                // Break out of retry loop — no more ACP calls are possible.
+                break;
             }
             if (attempt < this.ctx.maxRetriesPerPhase) {
                 logger_1.logger.warn(`${def.key} 未更新为 DONE/SKIPPED，准备重试第 ${attempt + 1} 次`);
             }
         }
         event_bus_1.dashboardEventBus.emitPhaseFailed(def.key, 'state 未更新为 DONE/SKIPPED', this.ctx.maxRetriesPerPhase);
-        throw new Error(`${def.key} 未完成：state 未更新为 DONE/SKIPPED`);
+        // All retries exhausted — try ACP auto-repair before giving up
+        if (this.ctx.autoRepair !== false) {
+            logger_1.logger.warn(`${def.key} 重试耗尽，启动 ACP 自动修复...`);
+            const repaired = await this.tryAutoRepair(def, harnessRoot, phaseStartTime);
+            if (repaired) {
+                const elapsed = Date.now() - phaseStartTime;
+                event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, 'DONE', elapsed);
+                logger_1.logger.success(`${def.key} ✅ 完成（ACP 自动修复）`);
+                return;
+            }
+            logger_1.logger.warn(`${def.key} ACP 自动修复未生效`);
+        }
+        // Don't throw — mark as SKIPPED so the build continues to subsequent phases
+        logger_1.logger.warn(`${def.key} 已耗尽所有重试次数，标记 SKIPPED 后继续执行后续阶段`);
+        const skipState = await (0, auto_state_1.readBuildState)(harnessRoot);
+        (0, auto_state_1.setPhaseStatus)(skipState, def.key, 'SKIPPED');
+        skipState.phases[def.key].note = '重试耗尽且自动修复未生效，已自动跳过';
+        await (0, auto_state_1.writeBuildState)(harnessRoot, skipState);
+        event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, 'SKIPPED', Date.now() - phaseStartTime);
     }
     async runMechanicalPre(def) {
         if (!this.ctx.harnessRoot || this.ctx.dryRun)
@@ -270,8 +328,14 @@ class PhaseRunner {
             await (0, auto_state_1.writeBuildState)(harnessRoot, state);
             return targetStatus;
         }
-        // <AUTO_SIGNAL>: any signal value resolves as DONE (used by S85/optimize phases)
+        // <AUTO_SIGNAL>: resolves as DONE for any signal value.
+        // Note: this branch is only reachable for phase-runner phases (S10-S80),
+        // which all use <PHASE_DONE> signals via wrapAcpPrompt, not <AUTO_SIGNAL>.
+        // The <AUTO_SIGNAL> protocol is used by auto-optimize.ts and auto-review.ts
+        // which bypass PhaseRunner entirely.  If this fires unexpectedly, the log
+        // below provides an audit trail.
         if (autoSignal) {
+            logger_1.logger.warn(`${def.key} 收到意外 AUTO_SIGNAL「${autoSignal[1]}」（phase-runner 阶段应使用 PHASE_DONE）、自动标记 DONE`);
             const state = await (0, auto_state_1.readBuildState)(harnessRoot);
             (0, auto_state_1.setPhaseStatus)(state, def.key, 'DONE');
             await (0, auto_state_1.writeBuildState)(harnessRoot, state);
@@ -281,27 +345,48 @@ class PhaseRunner {
     }
     /**
      * Detect phase completion by checking for expected output artifacts on disk.
-     * Used as a last-resort fallback when Claude completed the work but failed to
-     * emit <PHASE_DONE> or update the YAML state file.
+     * Used when ACP succeeded but failed to emit a completion signal or update
+     * the YAML state file.
      *
-     * Each phase defines its own detection criteria.
+     * Only runs when result.success === true — ACP failure artifacts are too
+     * unreliable to use as a completion signal.
      */
-    async tryResolveFromArtifacts(def, harnessRoot) {
+    async tryResolveFromArtifacts(def, harnessRoot, result, phaseStartTime) {
+        // Only use artifact fallback when ACP actually succeeded.
+        // Failed ACP calls may leave partial/incomplete artifacts that would
+        // cause false-positive phase resolution, bypassing retry logic.
+        if (!result.success)
+            return null;
         try {
             switch (def.key) {
                 case 'S40_extract_requirements': {
                     const yamlDir = node_path_1.default.join(harnessRoot, 'requirements', 'yaml');
                     if (await fs_extra_1.default.pathExists(yamlDir)) {
                         const entries = await fs_extra_1.default.readdir(yamlDir);
-                        const yamlFiles = entries.filter((e) => e.endsWith('.yaml'));
+                        const yamlFiles = entries
+                            .filter((e) => e.endsWith('.yaml'));
                         if (yamlFiles.length > 0) {
-                            break; // qualified → mark DONE below
+                            // Verify at minimum that the yaml file has substantive content
+                            // created during or after this phase started.
+                            const validYamlFiles = (await Promise.all(yamlFiles.map(async (f) => {
+                                const fp = node_path_1.default.join(yamlDir, f);
+                                try {
+                                    const stat = await fs_extra_1.default.stat(fp);
+                                    return stat.size > 50 && stat.mtimeMs >= phaseStartTime - 5000;
+                                }
+                                catch {
+                                    return false;
+                                }
+                            }))).filter(Boolean);
+                            if (validYamlFiles.length > 0)
+                                break; // qualified
                         }
                     }
                     return null;
                 }
                 case 'S50_generate_specs': {
                     // specs/ must have at least one non-empty subdirectory
+                    // with a non-trivial .md or .yaml file (>100 bytes) created during this phase.
                     const specsDir = node_path_1.default.join(harnessRoot, 'specs');
                     let found = false;
                     if (await fs_extra_1.default.pathExists(specsDir)) {
@@ -309,24 +394,43 @@ class PhaseRunner {
                             .filter((e) => e !== '_work');
                         for (const sub of subs) {
                             const subDir = node_path_1.default.join(specsDir, sub);
-                            const stat = await fs_extra_1.default.stat(subDir);
+                            let stat;
+                            try {
+                                stat = await fs_extra_1.default.stat(subDir);
+                            }
+                            catch {
+                                continue;
+                            }
                             if (stat.isDirectory()) {
                                 const files = await fs_extra_1.default.readdir(subDir);
-                                if (files.some((f) => f.endsWith('.md') || f.endsWith('.yaml'))) {
-                                    found = true;
-                                    break; // break for loop only; 'found' carries the result
+                                for (const f of files) {
+                                    if (!f.endsWith('.md') && !f.endsWith('.yaml'))
+                                        continue;
+                                    const fp = node_path_1.default.join(subDir, f);
+                                    try {
+                                        const fstat = await fs_extra_1.default.stat(fp);
+                                        if (fstat.size > 100 && fstat.mtimeMs >= phaseStartTime - 5000) {
+                                            found = true;
+                                            break;
+                                        }
+                                    }
+                                    catch {
+                                        continue;
+                                    }
                                 }
+                                if (found)
+                                    break;
                             }
                         }
                     }
                     if (found)
-                        break; // break switch → mark DONE
+                        break;
                     return null;
                 }
                 case 'S60_process_references': {
                     // references/yaml/index.yaml is the primary output artifact
                     const indexYaml = node_path_1.default.join(harnessRoot, 'references', 'yaml', 'index.yaml');
-                    if (await fs_extra_1.default.pathExists(indexYaml)) {
+                    if (await fs_extra_1.default.pathExists(indexYaml) && await isRecentFile(indexYaml, phaseStartTime)) {
                         break; // qualified
                     }
                     // Also accept SKIPPED state if references/md/ is empty (no references to process)
@@ -345,27 +449,25 @@ class PhaseRunner {
                     return null;
                 }
                 case 'S65_customize_agent_env': {
-                    // agent-env/rules/ or agent-env/skills/ has content
+                    // agent-env/rules/ or agent-env/skills/ has content from this phase
                     const rulesDir = node_path_1.default.join(harnessRoot, 'agent-env', 'rules');
                     const skillsDir = node_path_1.default.join(harnessRoot, 'agent-env', 'skills');
-                    if (await hasNonEmptyFiles(rulesDir) || await hasAnySubdirWithFiles(skillsDir)) {
+                    if (await hasNonGitkeepEntries(rulesDir) || await hasAnySubdirWithFiles(skillsDir)) {
                         break; // qualified
                     }
                     return null;
                 }
                 case 'S70_runtime_assets': {
-                    // Check tasks/ or agent-env/skills/ or agent-env/rules/ for content
+                    // Check tasks/ for content; avoid skills/ overlap with S65 detection.
                     const s70TasksDir = node_path_1.default.join(harnessRoot, 'tasks');
-                    const s70SkillsDir = node_path_1.default.join(harnessRoot, 'agent-env', 'skills');
-                    if (await hasNonEmptyFiles(s70TasksDir) ||
-                        await hasAnySubdirWithFiles(s70SkillsDir)) {
+                    if (await hasNonGitkeepEntries(s70TasksDir)) {
                         break; // qualified
                     }
                     return null;
                 }
                 case 'S80_seed_memory': {
                     const memoryInbox = node_path_1.default.join(harnessRoot, 'agent-env', 'memory', 'inbox');
-                    if (await hasNonEmptyFiles(memoryInbox)) {
+                    if (await hasNonGitkeepEntries(memoryInbox)) {
                         break; // qualified
                     }
                     return null;
@@ -381,8 +483,53 @@ class PhaseRunner {
             await (0, auto_state_1.writeBuildState)(harnessRoot, state);
             return 'DONE';
         }
-        catch {
-            return null; // silently fall through to normal retry on any filesystem error
+        catch (err) {
+            // Log IO errors rather than swallowing them silently.
+            // Previously this was a bare catch {} which masked real filesystem
+            // issues (permissions, disk full, race conditions).
+            logger_1.logger.warn(`${def.key} 产物兜底检测异常：${err instanceof Error ? err.message : String(err)}`);
+            return null; // fall through to normal retry
+        }
+    }
+    /**
+     * Try to auto-repair a failed phase by calling ACP with a diagnosis prompt.
+     * The ACP agent inspects the harness, fixes data issues, and updates the state.
+     */
+    async tryAutoRepair(def, harnessRoot, phaseStartTime) {
+        try {
+            const desc = PHASE_DESC[def.key] ?? def.key;
+            const repairPrompt = `[ACP AUTO-REPAIR] 阶段 ${def.key}（${desc}）执行失败。\n\n` +
+                `请检查 harness 目录 ${harnessRoot}，识别并修复该阶段应产生的产物问题，\n` +
+                `然后更新 .harness-build-state.yaml 中 ${def.key} 的状态为 DONE。\n\n` +
+                `注意：\n` +
+                `1. 只关注 ${def.key} 阶段的问题，不要修改其他阶段的产物或状态\n` +
+                `2. 修复完成后务必在输出末尾输出 <PHASE_DONE>${def.short}</PHASE_DONE>\n`;
+            this.cost.recordCall(def.key + '_repair');
+            const result = await this.acp.call({
+                workDir: harnessRoot,
+                phase: def.key + '_repair',
+                prompt: (0, phase_prompt_loader_1.wrapAcpPrompt)(repairPrompt, `<PHASE_DONE>${def.short}</PHASE_DONE>`),
+                timeoutMs: this.ctx.acpTimeoutMs,
+            });
+            await this.writeAcpLog(def.short + '-repair', result.output, result.error);
+            // Check state
+            const after = await (0, auto_state_1.readBuildState)(harnessRoot);
+            const afterStatus = (0, auto_state_1.phaseStatus)(after, def.key);
+            if (afterStatus === 'DONE' || afterStatus === 'SKIPPED')
+                return true;
+            // Check signal fallback
+            const resolved = await this.tryResolveFromSignal(def, harnessRoot, result);
+            if (resolved)
+                return true;
+            // Check artifact fallback
+            const artifactResolved = await this.tryResolveFromArtifacts(def, harnessRoot, result, phaseStartTime);
+            if (artifactResolved)
+                return true;
+            return false;
+        }
+        catch (err) {
+            logger_1.logger.warn(`${def.key} 自动修复异常：${err instanceof Error ? err.message : String(err)}`);
+            return false;
         }
     }
     async writeAcpLog(phase, output, error) {
@@ -399,8 +546,8 @@ function phaseNumber(phase) {
     const match = phase.match(/^S(\d+)/i);
     return match ? Number(match[1]) : Number.POSITIVE_INFINITY;
 }
-/** Check if a directory exists and contains at least one file (excluding .gitkeep). */
-async function hasNonEmptyFiles(dir) {
+/** Check if a directory exists and contains at least one entry (excluding .gitkeep). */
+async function hasNonGitkeepEntries(dir) {
     if (!(await fs_extra_1.default.pathExists(dir)))
         return false;
     const entries = await fs_extra_1.default.readdir(dir);
@@ -422,3 +569,19 @@ async function hasAnySubdirWithFiles(dir) {
     }
     return false;
 }
+/**
+ * Check if a file was last modified at or after a given timestamp.
+ * Used to distinguish artifacts produced by the current phase attempt
+ * from stale files left by a previous build, preventing false-positive
+ * artifact detection.
+ */
+async function isRecentFile(filePath, sinceMs) {
+    try {
+        const stat = await fs_extra_1.default.stat(filePath);
+        // Allow 5-second tolerance for filesystem timestamp granularity
+        return stat.mtimeMs >= sinceMs - 5000;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/ps-codechat-alias.js

@@ -13,7 +13,20 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const logger_1 = require("../utils/logger");
-const launch_script_path_1 = require("./launch-script-path");
+/**
+ * Resolve absolute path to templates/codechat/Start-CodeChat.ps1 in the installed package.
+ */
+function resolveStartCodeChatPs1Path() {
+    const fromDist = path_1.default.resolve(__dirname, '..', '..', 'templates', 'codechat', 'Start-CodeChat.ps1');
+    if (fs_extra_1.default.existsSync(fromDist)) {
+        return fromDist;
+    }
+    const fromCwd = path_1.default.resolve(__dirname, '..', '..', '..', 'templates', 'codechat', 'Start-CodeChat.ps1');
+    if (fs_extra_1.default.existsSync(fromCwd)) {
+        return fromCwd;
+    }
+    throw new Error(`未找到 Start-CodeChat.ps1（预期：${fromDist}）`);
+}
 const START_MARKER = /^#\s*>>>\s*codechat\s*>>>/;
 const END_MARKER = /^#\s*<<<\s*codechat\s*<<</;
 function assertWin32() {
@@ -57,8 +70,8 @@ function stripCodechatBlock(content) {
     const joined = clean.join('\n').replace(/\n+$/, '');
     return { clean: joined ? `${joined}\n` : '', hadBlock };
 }
-function buildAliasSnippet(launchScriptPath) {
-    const escapedPath = launchScriptPath.replace(/'/g, "''");
+function buildAliasSnippet(ps1Path) {
+    const escapedPath = ps1Path.replace(/'/g, "''");
     return `
 
 # >>> codechat >>>
@@ -69,17 +82,17 @@ function codechat {
         [string[]]$ExtraArgs
     )
     if (-not $Path) { $Path = (Get-Location).Path }
-    & node '${escapedPath}' "$Path" @ExtraArgs
+    & '${escapedPath}' -Action Start -WorkDir "$Path" @ExtraArgs
 }
 # <<< codechat <<<
 
 `;
 }
-function profileHasSvharnessAlias(content, launchScriptPath) {
+function profileHasSvharnessAlias(content, ps1Path) {
     if (!START_MARKER.test(content)) {
         return false;
     }
-    const needle = normalizePathForCompare(launchScriptPath);
+    const needle = normalizePathForCompare(ps1Path);
     return normalizePathForCompare(content).includes(needle);
 }
 /**
@@ -89,11 +102,11 @@ function profileHasSvharnessAlias(content, launchScriptPath) {
 async function installCodechatAlias(opts = {}) {
     assertWin32();
     const profilePath = getPowerShellProfilePath();
-    const launchScriptPath = (0, launch_script_path_1.resolveLaunchScriptPath)();
+    const ps1Path = resolveStartCodeChatPs1Path();
     const existing = (await fs_extra_1.default.pathExists(profilePath))
         ? await fs_extra_1.default.readFile(profilePath, 'utf8')
         : '';
-    if (profileHasSvharnessAlias(existing, launchScriptPath)) {
+    if (profileHasSvharnessAlias(existing, ps1Path)) {
         if (!opts.silent) {
             logger_1.logger.info(`PowerShell 别名 codechat 已存在：${profilePath}`);
         }
@@ -104,11 +117,11 @@ async function installCodechatAlias(opts = {}) {
         await fs_extra_1.default.writeFile(profilePath, '', 'utf8');
     }
     const { clean, hadBlock } = stripCodechatBlock(existing);
-    const snippet = buildAliasSnippet(launchScriptPath);
+    const snippet = buildAliasSnippet(ps1Path);
     await fs_extra_1.default.writeFile(profilePath, `${clean}${snippet}`, 'utf8');
     if (!opts.silent) {
         if (hadBlock) {
-            logger_1.logger.success(`已更新 PowerShell 别名 codechat → ${launchScriptPath}`);
+            logger_1.logger.success(`已更新 PowerShell 别名 codechat → ${ps1Path}`);
         }
         else {
             logger_1.logger.success(`已安装 PowerShell 别名 codechat → ${profilePath}`);
@@ -144,24 +157,24 @@ async function uninstallCodechatAlias(opts = {}) {
 function getCodechatAliasStatus() {
     assertWin32();
     const profilePath = getPowerShellProfilePath();
-    let launchScriptPath = '';
+    let ps1Path = '';
     try {
-        launchScriptPath = (0, launch_script_path_1.resolveLaunchScriptPath)();
+        ps1Path = resolveStartCodeChatPs1Path();
     }
     catch {
-        launchScriptPath = '(未找到)';
+        ps1Path = '(未找到)';
     }
     let installed = false;
-    if (fs_extra_1.default.existsSync(profilePath) && launchScriptPath !== '(未找到)') {
+    if (fs_extra_1.default.existsSync(profilePath) && ps1Path !== '(未找到)') {
         try {
             const content = fs_extra_1.default.readFileSync(profilePath, 'utf8');
-            installed = profileHasSvharnessAlias(content, launchScriptPath);
+            installed = profileHasSvharnessAlias(content, ps1Path);
         }
         catch {
             installed = false;
         }
     }
-    return { profilePath, installed, launchScriptPath };
+    return { profilePath, installed, launchScriptPath: ps1Path };
 }
 function printCodechatAliasStatus() {
     const status = getCodechatAliasStatus();

package/dist/lib/review-parser.js

@@ -3,10 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReportFrontmatter = parseReportFrontmatter;
 exports.parseReviewReport = parseReviewReport;
+exports.parseGapsFromMarkdown = parseGapsFromMarkdown;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const score_aggregator_1 = require("./score-aggregator");
+async function parseReportFrontmatter(reportPath) {
+    if (!(await fs_extra_1.default.pathExists(reportPath)))
+        return null;
+    const content = await fs_extra_1.default.readFile(reportPath, 'utf8');
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return null;
+    return js_yaml_1.default.load(match[1]);
+}
 async function parseReviewReport(reportPath) {
     if (!(await fs_extra_1.default.pathExists(reportPath)))
         return null;
@@ -51,6 +62,9 @@ function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : {};
 }
 function parseGaps(content) {
+    return parseGapsFromMarkdown(content);
+}
+function parseGapsFromMarkdown(content) {
     const gaps = [];
     const lines = content.split(/\r?\n/);
     for (const line of lines) {