svharness 0.15.8 → 0.15.10

package/auto/templates/phase-prompts/S40-requirements.md

@@ -1,5 +1,13 @@
 你是 harness 构建 Agent。当前任务：完成 {{HARNESS_ROOT}} 的 S40_extract_requirements 阶段。
 
+## 硬约束（必须遵守，违反则任务失败）
+你输出内容的**最后一行**必须精确匹配以下字符串（不含引号、不含多余空格、不含换行）：
+```
+<PHASE_DONE>S40</PHASE_DONE>
+```
+此信号是自动化流程检测阶段完成的唯一可靠方式。无论前面的执行结果如何，最后一行必须输出此信号。
+你可以在信号之后不再输出任何内容。
+
 ## 项目上下文
 - 构建目的：{{AUTO_GOAL}}
 - 工作根目录：{{HARNESS_ROOT}}
@@ -11,5 +19,4 @@
 4. 每条需求必须包含 `unit_id`、`source_doc`、`source_anchor`、`source_excerpt`、`acceptance`。
 5. 运行 `svharness requirements verify --harness {{HARNESS_ROOT}} --strict`，失败则修复后重试。
 6. 通过后最小补丁更新 `.harness-build-state.yaml`：`S40_extract_requirements.status = DONE`。
-7. 输出末尾：`<PHASE_DONE>S40</PHASE_DONE>`。
 

package/dist/lib/auto-optimize.js

@@ -27,7 +27,7 @@ async function runOptimizePlan(ctx, acp, cost, round, review) {
     const result = await acp.call({
         workDir: ctx.harnessRoot,
         phase: 'optimize-plan',
-        prompt,
+        prompt: (0, phase_prompt_loader_1.wrapAcpPrompt)(prompt, '<AUTO_SIGNAL>PLAN_DONE</AUTO_SIGNAL>'),
         timeoutMs: ctx.acpTimeoutMs,
     });
     if (!result.success)
@@ -55,7 +55,7 @@ async function runOptimizeImplement(ctx, acp, cost, round, review) {
     const result = await acp.call({
         workDir: ctx.harnessRoot,
         phase: 'optimize-implement',
-        prompt,
+        prompt: (0, phase_prompt_loader_1.wrapAcpPrompt)(prompt, '<AUTO_SIGNAL>OPTIMIZE_DONE</AUTO_SIGNAL>'),
         timeoutMs: ctx.acpTimeoutMs,
     });
     if (!result.success) {

package/dist/lib/auto-review.js

@@ -32,7 +32,7 @@ async function runHarnessReview(ctx, acp, cost, round) {
     const result = await acp.call({
         workDir: ctx.harnessRoot,
         phase: 'S85_pre_seal_validation',
-        prompt,
+        prompt: (0, phase_prompt_loader_1.wrapAcpPrompt)(prompt, '<AUTO_SIGNAL>REVIEW_DONE</AUTO_SIGNAL>'),
         timeoutMs: ctx.acpTimeoutMs,
     });
     await fs_extra_1.default.writeFile(node_path_1.default.join(ctx.harnessRoot, 'auto-review', `review-round-${round}.log`), [result.output, result.error ? `\n[stderr]\n${result.error}` : ''].join(''), 'utf8');

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPhasePrompt = loadPhasePrompt;
 exports.renderPrompt = renderPrompt;
+exports.wrapAcpPrompt = wrapAcpPrompt;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const auto_assets_1 = require("./auto-assets");
@@ -23,3 +24,31 @@ function renderPrompt(template, vars) {
         return value === undefined || value === null ? match : String(value);
     });
 }
+/**
+ * Wrap an auto-mode ACP prompt with a non-interactive preamble.
+ *
+ * All auto phase prompts run via `claude --print` (no stdin backchannel).
+ * This preamble forces Claude to:
+ *  - Never ask questions or wait for confirmation
+ *  - Always emit a completion signal as the very last line of output
+ *  - Output nothing after the signal
+ *
+ * Call this for EVERY acp.call() invocation, including phases that bypass
+ * PhaseRunner (S85 review, optimize-plan, optimize-implement).
+ */
+function wrapAcpPrompt(rawPrompt, completionSignal) {
+    return [
+        '## 非交互模式硬约束（必须遵守，违反则任务失败）',
+        '你处于自动化流水线的非交互模式。禁止向用户提问、征求确认或等待人工决策。',
+        '直接执行所有操作，不要停下来询问。',
+        `你输出内容的最后一行必须精确匹配以下字符串（不含引号、不含多余空格、不含换行，之后不要再输出任何内容）：`,
+        '```',
+        completionSignal,
+        '```',
+        '此信号是自动化流程识别阶段完成的唯一方式。',
+        '',
+        '---',
+        '',
+        rawPrompt,
+    ].join('\n');
+}

package/dist/lib/phase-runner.js

@@ -107,12 +107,18 @@ 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,
+                prompt: boundedPrompt,
                 timeoutMs: this.ctx.acpTimeoutMs,
                 onData: (text) => event_bus_1.dashboardEventBus.emitAcpOutput(def.key, text),
             });
@@ -139,6 +145,17 @@ class PhaseRunner {
                 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);
+            if (artifactResolved) {
+                const elapsed = Date.now() - phaseStartTime;
+                event_bus_1.dashboardEventBus.emitPhaseCompleted(def.key, artifactResolved, elapsed);
+                logger_1.logger.success(`${def.key} ✅ 完成（产物兜底检测）`);
+                return;
+            }
             if (attempt < this.ctx.maxRetriesPerPhase) {
                 logger_1.logger.warn(`${def.key} 未更新为 DONE/SKIPPED，准备重试第 ${attempt + 1} 次`);
             }
@@ -227,25 +244,146 @@ class PhaseRunner {
         logger_1.logger.success('S30_convert_docs ✅ 完成（机械检查）');
     }
     /**
-     * Parse Claude's output for <PHASE_DONE> / <PHASE_SKIP> signals and,
-     * if the phase matches, programmatically update the state file.
+     * Parse Claude's output for <PHASE_DONE> / <PHASE_SKIP> / <AUTO_SIGNAL> signals
+     * and, if the phase matches, programmatically update the state file.
      * This is a fallback for when Claude cannot edit the YAML itself.
+     *
+     * <PHASE_DONE>S40</PHASE_DONE> — exact phase match required (phase-runner phases)
+     * <AUTO_SIGNAL>REVIEW_DONE</AUTO_SIGNAL> — any AUTO_SIGNAL triggers DONE (review/optimize phases)
      */
     async tryResolveFromSignal(def, harnessRoot, result) {
         if (!result.completionSignal)
             return null;
         const doneMatch = result.completionSignal.match(/^<PHASE_DONE>(\w+)<\/PHASE_DONE>$/);
         const skipMatch = result.completionSignal.match(/^<PHASE_SKIP>(\w+)<\/PHASE_SKIP>$/);
-        const signalPhase = doneMatch?.[1] ?? skipMatch?.[1];
-        if (!signalPhase)
-            return null;
-        if (signalPhase !== def.short && signalPhase !== def.key)
-            return null;
-        const targetStatus = doneMatch ? 'DONE' : 'SKIPPED';
-        const state = await (0, auto_state_1.readBuildState)(harnessRoot);
-        (0, auto_state_1.setPhaseStatus)(state, def.key, targetStatus);
-        await (0, auto_state_1.writeBuildState)(harnessRoot, state);
-        return targetStatus;
+        const autoSignal = result.completionSignal.match(/^<AUTO_SIGNAL>(\w+)<\/AUTO_SIGNAL>$/);
+        // <PHASE_DONE>/<PHASE_SKIP>: verify phase matches
+        if (doneMatch || skipMatch) {
+            const signalPhase = doneMatch?.[1] ?? skipMatch?.[1];
+            if (!signalPhase)
+                return null;
+            if (signalPhase !== def.short && signalPhase !== def.key)
+                return null;
+            const targetStatus = doneMatch ? 'DONE' : 'SKIPPED';
+            const state = await (0, auto_state_1.readBuildState)(harnessRoot);
+            (0, auto_state_1.setPhaseStatus)(state, def.key, targetStatus);
+            await (0, auto_state_1.writeBuildState)(harnessRoot, state);
+            return targetStatus;
+        }
+        // <AUTO_SIGNAL>: any signal value resolves as DONE (used by S85/optimize phases)
+        if (autoSignal) {
+            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);
+            return 'DONE';
+        }
+        return null;
+    }
+    /**
+     * 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.
+     *
+     * Each phase defines its own detection criteria.
+     */
+    async tryResolveFromArtifacts(def, harnessRoot) {
+        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'));
+                        if (yamlFiles.length > 0) {
+                            break; // qualified → mark DONE below
+                        }
+                    }
+                    return null;
+                }
+                case 'S50_generate_specs': {
+                    // specs/ must have at least one non-empty subdirectory
+                    const specsDir = node_path_1.default.join(harnessRoot, 'specs');
+                    let found = false;
+                    if (await fs_extra_1.default.pathExists(specsDir)) {
+                        const subs = (await fs_extra_1.default.readdir(specsDir))
+                            .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);
+                            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
+                                }
+                            }
+                        }
+                    }
+                    if (found)
+                        break; // break switch → mark DONE
+                    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)) {
+                        break; // qualified
+                    }
+                    // Also accept SKIPPED state if references/md/ is empty (no references to process)
+                    const refMdDir = node_path_1.default.join(harnessRoot, 'references', 'md');
+                    if (await fs_extra_1.default.pathExists(refMdDir)) {
+                        const files = await fs_extra_1.default.readdir(refMdDir);
+                        if (files.filter((f) => f !== '.gitkeep').length === 0) {
+                            // No reference documents — SKIPPED is the correct outcome
+                            logger_1.logger.info(`${def.key} 产物兜底：无参考资料，自动标记 SKIPPED`);
+                            const state = await (0, auto_state_1.readBuildState)(harnessRoot);
+                            (0, auto_state_1.setPhaseStatus)(state, def.key, 'SKIPPED');
+                            await (0, auto_state_1.writeBuildState)(harnessRoot, state);
+                            return 'SKIPPED';
+                        }
+                    }
+                    return null;
+                }
+                case 'S65_customize_agent_env': {
+                    // agent-env/rules/ or agent-env/skills/ has content
+                    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)) {
+                        break; // qualified
+                    }
+                    return null;
+                }
+                case 'S70_runtime_assets': {
+                    // Check tasks/ or agent-env/skills/ or agent-env/rules/ for content
+                    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)) {
+                        break; // qualified
+                    }
+                    return null;
+                }
+                case 'S80_seed_memory': {
+                    const memoryInbox = node_path_1.default.join(harnessRoot, 'agent-env', 'memory', 'inbox');
+                    if (await hasNonEmptyFiles(memoryInbox)) {
+                        break; // qualified
+                    }
+                    return null;
+                }
+                default:
+                    return null; // no artifact-based detection for this phase
+            }
+            // If we reach here, the phase's artifacts were detected as present,
+            // so auto-resolve the phase to DONE.
+            logger_1.logger.info(`${def.key} 产物兜底：检测到输出产物，自动标记 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);
+            return 'DONE';
+        }
+        catch {
+            return null; // silently fall through to normal retry on any filesystem error
+        }
     }
     async writeAcpLog(phase, output, error) {
         if (!this.ctx.harnessRoot)
@@ -261,3 +399,26 @@ 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) {
+    if (!(await fs_extra_1.default.pathExists(dir)))
+        return false;
+    const entries = await fs_extra_1.default.readdir(dir);
+    return entries.some((e) => e !== '.gitkeep');
+}
+/** Check if a directory exists and has at least one subdirectory with files. */
+async function hasAnySubdirWithFiles(dir) {
+    if (!(await fs_extra_1.default.pathExists(dir)))
+        return false;
+    const entries = await fs_extra_1.default.readdir(dir);
+    for (const entry of entries) {
+        const subPath = node_path_1.default.join(dir, entry);
+        const stat = await fs_extra_1.default.stat(subPath);
+        if (stat.isDirectory()) {
+            const files = await fs_extra_1.default.readdir(subPath);
+            if (files.some((f) => f !== '.gitkeep'))
+                return true;
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svharness",
-  "version": "0.15.8",
+  "version": "0.15.10",
   "description": "CLI scaffolder for SDD-Driven Agent-Agnostic Coding Framework (harness)",
   "bin": {
     "svharness": "./bin/cli.js",