svharness 0.15.10 → 0.15.13

package/dist/dashboard/sse-handler.js

@@ -101,6 +101,9 @@ class SseManager {
                     this.buildSnapshot.score = event.data.finalScore;
                 }
                 break;
+            case 'build_failed':
+                this.buildSnapshot.status = 'failed';
+                break;
         }
     }
     getSnapshot() {

package/dist/dashboard/static/js/app.js

@@ -323,6 +323,11 @@ function connectSSE() {
       addLog({ type: 'success', text: `✅ 构建完成！${data.finalScore != null ? `最终评分: ${data.finalScore}` : ''}`, timestamp: Date.now() });
       updateStatus();
     },
+    build_failed() {
+      state.status = 'failed';
+      addLog({ type: 'error', text: '❌ 构建失败！请检查终端日志', timestamp: Date.now() });
+      updateStatus();
+    },
     phase_started(data) {
       state.currentPhase = data.key;
       state.phaseStatuses[data.key] = 'IN_PROGRESS';

package/dist/index.js

@@ -5,13 +5,15 @@ const logger_1 = require("./utils/logger");
 const version_1 = require("./utils/version");
 const validate_args_1 = require("./utils/validate-args");
 const harness_name_1 = require("./utils/harness-name");
+const convert_1 = require("./constants/convert");
 const init_1 = require("./commands/init");
 const apply_1 = require("./commands/apply");
-const convert_1 = require("./commands/convert");
+const convert_2 = require("./commands/convert");
 const wizard_1 = require("./commands/wizard");
 const doctor_1 = require("./commands/doctor");
 const wiki_1 = require("./commands/wiki");
 const auto_1 = require("./commands/auto");
+const auto_pack_req_1 = require("./commands/auto-pack-req");
 const requirements_1 = require("./commands/requirements");
 const start_agent_1 = require("./commands/start-agent");
 const shell_integration_1 = require("./commands/shell-integration");
@@ -163,7 +165,7 @@ function attachBuildOptions(cmd) {
         .option('--convert-endpoint <url>', '【build 自动 convert】markitdown_serve 基址（默认 http://markitdown.desaysz.site）')
         .option('--convert-concurrency <n>', '【build 自动 convert】并发上传数（默认沿用 convert）', (v) => Number(v))
         .option('--convert-max-file-mb <n>', '【build 自动 convert】单文件大小上限 MB（默认沿用 convert）', (v) => Number(v))
-        .option('--convert-timeout-sec <n>', '【build 自动 convert】超时秒数（默认沿用 convert）', (v) => Number(v))
+        .option('--convert-timeout-sec <n>', `【build 自动 convert】超时秒数（默认 ${convert_1.DEFAULT_CONVERT_TIMEOUT_SEC}，15 分钟）`, (v) => Number(v))
         .option('--convert-force', '【build 自动 convert】覆盖已存在同名 .md')
         .option('--force', '强制覆盖已存在的目标目录')
         .option('-y, --yes', '跳过交互确认，使用默认值')
@@ -218,6 +220,10 @@ function main() {
         '│  # 方式六：对当前工程生成 wiki 骨架                                       ',
         '│  svharness wiki                                                          ',
         '│                                                                          ',
+        '│  # 方式七：在 requirements 资料目录直接条目化（或指定资料包根）          ',
+        '│  cd ./requirements && svharness auto_pack_req --yes                      ',
+        '│  svharness auto_pack_req ./req-pack --yes                                ',
+        '│                                                                          ',
         '└──────────────────────────────────────────────────────────────────────────',
         '  📚 使用说明文档：https://yesv-desaysv.feishu.cn/docx/OEBwdywTfoncPNxPZ0acClNincg',
         '',
@@ -248,14 +254,14 @@ function main() {
         .option('--extra-skills <path...>', '额外运行期资源路径（覆盖自动检测）')
         .option('--force', '目标 harness 已存在时覆盖')
         .option('--target-score <score>', '目标综合评分（默认 9.5）', (v) => Number(v))
-        .option('--max-optimize-rounds <n>', '最大优化轮数（默认 5）', (v) => Number(v))
+        .option('--max-optimize-rounds <n>', '最大优化轮数（默认 10）', (v) => Number(v))
         .option('--checkpoint <phase>', '到达阶段前暂停')
         .option('--max-phase <phase>', '只运行到此阶段即停止')
         .option('--dry-run', '打印 prompt 和动作，不调用 Claude')
         .option('--auto-approve', '自动通过无人值守下的表单门禁')
         .option('-y, --yes', '跳过交互确认')
         .option('--verbose', '显示详细日志')
-        .option('--max-total-calls <n>', 'ACP 调用次数上限（默认 30）', (v) => Number(v))
+        .option('--max-total-calls <n>', 'ACP 调用次数上限（默认 100）', (v) => Number(v))
         .option('--budget-usd <amount>', '费用预算上限（USD）', (v) => Number(v))
         .option('--cost-alert <amount>', '单次调用费用告警阈值（USD）', (v) => Number(v))
         .option('--acp-mode <mode>', 'ACP 模式：auto | cli-print | sdk')
@@ -264,6 +270,7 @@ function main() {
         .option('--prompt-dir <path>', '覆盖 auto phase prompt 模板目录')
         .option('--baseline-auto-extract <mode>', 'explicit | conservative | disabled')
         .option('--convert-endpoint <url>', 'markitdown_serve 基址')
+        .option('--no-auto-repair', '禁用阶段失败自动修复（默认启用）')
         .action(async (workdir, opts, cmd) => {
         try {
             await (0, auto_1.runAuto)(workdir, {
@@ -276,6 +283,72 @@ function main() {
             process.exitCode = 1;
         }
     });
+    program
+        .command('auto_pack_req [workdir]')
+        .description('需求包全自动条目化（S40 专项）：S30+S40 → 机械门禁+对抗验证+抽样验证，综合分须严格大于目标分')
+        .addHelpText('after', [
+        '',
+        '说明：',
+        '  独立于 svharness auto，仅跑 S30_convert_docs + S40_extract_requirements，不执行 S50~S90。',
+        '  综合分 = 机械门禁×0.40 + 对抗验证×0.30 + 抽样验证×0.30',
+        '  通过条件：综合分 > targetScore（默认 9.5）且 verify/doctor 硬门禁全通过。',
+        '',
+        '工作目录（无参数时默认当前目录）：',
+        '  · 当前目录是 requirements 资料夹（含 doc/md/pdf 等）→ 视为输入，在上级目录创建 harness',
+        '  · 当前目录是资料包根（含 requirements/ 子目录）→ 在目录内创建 harness',
+        '  · 当前目录是已有 harness 根 → 重置 S40 后重做条目化',
+        '',
+        '两种入口：',
+        '  · 资料包新建 — 无 harness.yaml，自动 build 后条目化',
+        '  · 已有 harness 重做 — 检测到 harness.yaml 后重置 S40=PENDING，仅重跑 S40',
+        '',
+        '内置默认：targetScore=9.5, maxOptimizeRounds=10, sampleCount=7, autoApprove=yes',
+        '配置示例：auto/templates/auto-pack-req.config.example.yaml（auto_pack_req: 节）',
+        '详细设计：auto/auto-harness-detail-design.md §2.2.1',
+        '',
+        '示例：',
+        '  cd ./requirements && svharness auto_pack_req --yes',
+        '  svharness auto_pack_req ./req-pack --yes',
+        '  svharness auto_pack_req ./my-harness --requirements ./docs --yes',
+        '  svharness auto_pack_req --dry-run',
+        '',
+    ].join('\n'))
+        .option('--work-dir <path>', '工作目录（资料包根或已有 harness 根）')
+        .option('--config <path>', '配置文件路径（支持 auto_pack_req: 节）')
+        .option('--harness-name <name>', 'harness 名称（资料包模式可自动推断）')
+        .option('--goal <text>', '构建目的描述')
+        .option('--arch <arch>', '架构模板：' + (0, validate_args_1.listSupportedArches)().join(' | '))
+        .option('--agent <agent>', '目标 Agent（默认 claude-code）')
+        .option('--requirements <path>', '需求文档路径（覆盖自动检测）')
+        .option('--force', '目标 harness 已存在时覆盖')
+        .option('--target-score <score>', '目标综合评分（默认 9.5，须严格大于此值）', (v) => Number(v))
+        .option('--max-optimize-rounds <n>', '最大优化轮数（默认 10）', (v) => Number(v))
+        .option('--sample-count <n>', '抽样验证片段数（默认 7）', (v) => Number(v))
+        .option('--dry-run', '打印 prompt 和动作，不调用 Agent')
+        .option('--auto-approve', '自动通过无人值守下的表单门禁')
+        .option('-y, --yes', '跳过交互确认')
+        .option('--verbose', '显示详细日志')
+        .option('--max-total-calls <n>', 'ACP 调用次数上限（默认 100）', (v) => Number(v))
+        .option('--budget-usd <amount>', '费用预算上限（USD）', (v) => Number(v))
+        .option('--cost-alert <amount>', '单次调用费用告警阈值（USD）', (v) => Number(v))
+        .option('--acp-mode <mode>', 'ACP 模式：auto | cli-print | sdk')
+        .option('--acp-timeout-ms <n>', '单次 ACP 调用超时毫秒', (v) => Number(v))
+        .option('--max-retries-per-phase <n>', '每阶段最大重试次数', (v) => Number(v))
+        .option('--prompt-dir <path>', '覆盖 auto phase prompt 模板目录')
+        .option('--convert-endpoint <url>', 'markitdown_serve 基址')
+        .option('--no-auto-repair', '禁用阶段失败自动修复（默认启用）')
+        .action(async (workdir, opts, cmd) => {
+        try {
+            await (0, auto_pack_req_1.runAutoPackReq)(workdir, {
+                ...opts,
+                costAlertThreshold: opts.costAlert,
+            }, cmd);
+        }
+        catch (err) {
+            logger_1.logger.error(err.message);
+            process.exitCode = 1;
+        }
+    });
     program
         .command('wizard')
         .description('交互式向导：分步填写路径与说明，可保存到 svharness.config.yaml 并/或立即执行 build/apply/convert。')
@@ -298,7 +371,7 @@ function main() {
         .option('--endpoint <url>', 'markitdown_serve 基址（逗号分隔可配置 failover）')
         .option('--concurrency <n>', '【默认 3】并发上传数', (v) => Number(v))
         .option('--max-file-mb <n>', '【默认 50】单文件大小上限（MB）', (v) => Number(v))
-        .option('--timeout-sec <n>', '【默认 120】超时秒数', (v) => Number(v))
+        .option('--timeout-sec <n>', `【默认 ${convert_1.DEFAULT_CONVERT_TIMEOUT_SEC}，15 分钟】单文件转换超时秒数`, (v) => Number(v))
         .option('--type <type>', 'requirements | references')
         .option('--force', '覆盖已存在同名 .md')
         .option('--split-sheets-suffix <suffix>', 'xlsx/xls 按 sheet（##）拆分时的子目录后缀', '_split')
@@ -325,7 +398,7 @@ function main() {
                 yes: opts.yes,
                 verbose: opts.verbose,
             }, loaded?.config.convert, loaded?.config.defaults, cmd);
-            await (0, convert_1.runConvert)({
+            await (0, convert_2.runConvert)({
                 input: merged.input ?? [],
                 harness: merged.harness,
                 output: merged.output,

package/dist/lib/acp-agent-cli-resolver.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreferredLocalClaudePath = getPreferredLocalClaudePath;
+exports.resolveAcpAgentCli = resolveAcpAgentCli;
+exports.ensureAcpAgentCliAvailable = ensureAcpAgentCliAvailable;
+exports.formatAcpAgentCliLog = formatAcpAgentCliLog;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const os_1 = __importDefault(require("os"));
+const node_child_process_1 = require("node:child_process");
+const codechat_runner_resolver_1 = require("./codechat-runner-resolver");
+/** Preferred Claude install: ~/.local/bin/claude(.exe) */
+function getPreferredLocalClaudePath(homedir = os_1.default.homedir(), platform = process.platform) {
+    const binName = platform === 'win32' ? 'claude.exe' : 'claude';
+    return node_path_1.default.join(homedir, '.local', 'bin', binName);
+}
+function normalizeComparable(p) {
+    return node_path_1.default.resolve(p).replace(/\\/g, '/').toLowerCase();
+}
+function canAccessExecutable(filePath) {
+    try {
+        fs_extra_1.default.accessSync(filePath, fs_extra_1.default.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findExecutableInPath(name, platform = process.platform) {
+    try {
+        if (platform === 'win32') {
+            const out = (0, node_child_process_1.execSync)(`where.exe ${name}`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+            });
+            for (const line of out.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (trimmed && canAccessExecutable(trimmed)) {
+                    return node_path_1.default.resolve(trimmed);
+                }
+            }
+            return null;
+        }
+        const out = (0, node_child_process_1.execSync)(`command -v ${name}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        if (out && canAccessExecutable(out)) {
+            return node_path_1.default.resolve(out);
+        }
+    }
+    catch {
+        // not in PATH
+    }
+    return null;
+}
+function getOtherClaudeCandidates(homedir, platform, excludePath) {
+    const exclude = excludePath ? normalizeComparable(excludePath) : undefined;
+    const found = [];
+    const seen = new Set();
+    const push = (candidate) => {
+        if (!candidate || !canAccessExecutable(candidate))
+            return;
+        const key = normalizeComparable(candidate);
+        if (exclude && key === exclude)
+            return;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        found.push(node_path_1.default.resolve(candidate));
+    };
+    push(findExecutableInPath('claude', platform));
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA ?? node_path_1.default.join(homedir, 'AppData', 'Roaming');
+        push(node_path_1.default.join(appData, 'npm', 'claude.cmd'));
+        push(node_path_1.default.join(appData, 'npm', 'claude'));
+        push(node_path_1.default.join(homedir, '.claude', 'local', 'claude.exe'));
+    }
+    return found;
+}
+const ALTERNATIVE_CLI_NAMES = [
+    'codechat',
+    'qodercli',
+    'traecli',
+    'opencode',
+    'codex',
+];
+function tryResolveCodechatRunner() {
+    try {
+        const { runner, source, label } = (0, codechat_runner_resolver_1.resolveCodechatRunner)();
+        return {
+            command: runner,
+            kind: 'codechat-runner',
+            source: `codechat-${source}`,
+            label,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function tryAlternativeClis(platform) {
+    for (const name of ALTERNATIVE_CLI_NAMES) {
+        const resolved = findExecutableInPath(name, platform);
+        if (resolved) {
+            return {
+                command: resolved,
+                kind: 'alternative-cli',
+                source: 'path',
+                label: name,
+            };
+        }
+    }
+    return tryResolveCodechatRunner();
+}
+/**
+ * Resolve the CLI used by ACP (`--print` mode).
+ *
+ * Priority:
+ * 1. ~/.local/bin/claude(.exe)
+ * 2. Other claude installs (PATH, npm global, etc.)
+ * 3. Alternative CLIs (codechat, qodercli, traecli, …) or CodeChat runner
+ */
+function resolveAcpAgentCli(options = {}) {
+    if (options.testCandidates?.length) {
+        return options.testCandidates[0];
+    }
+    const platform = options.platform ?? process.platform;
+    const homedir = options.homedir ?? os_1.default.homedir();
+    const localClaude = getPreferredLocalClaudePath(homedir, platform);
+    if (canAccessExecutable(localClaude)) {
+        return {
+            command: node_path_1.default.resolve(localClaude),
+            kind: 'claude-local-bin',
+            source: 'local-bin',
+            label: localClaude,
+        };
+    }
+    if (!options.skipProbe) {
+        const otherClaude = getOtherClaudeCandidates(homedir, platform, localClaude);
+        if (otherClaude.length > 0) {
+            return {
+                command: otherClaude[0],
+                kind: 'claude-path',
+                source: 'path',
+                label: otherClaude[0],
+            };
+        }
+        const alt = tryAlternativeClis(platform);
+        if (alt)
+            return alt;
+    }
+    return null;
+}
+function buildAgentCliNotFoundError(homedir, platform) {
+    const localClaude = getPreferredLocalClaudePath(homedir, platform);
+    const altList = ALTERNATIVE_CLI_NAMES.join('、');
+    const lines = [
+        '未找到可用于 ACP 调用的 Agent CLI（codechat / claude）。已按优先级检查：',
+        `  1. 本地 Claude → ${localClaude}`,
+        '  2. 其他 Claude 安装（PATH / npm global）',
+        `  3. 其他 CLI（${altList}）或 CodeChat runner`,
+        '',
+        '请先安装并配置其中之一，例如：',
+        `  - 将 claude.exe 放到 ${node_path_1.default.join(homedir, '.local', 'bin')}`,
+        '  - 或安装 CodeChat CLI / IDE 插件（~/.codechat/cli_app/）',
+        `  - 或确保 ${altList} 之一在 PATH 中`,
+        '',
+        '配置完成后再执行：svharness auto',
+    ];
+    return lines.join('\n');
+}
+/**
+ * Ensure an Agent CLI is available before auto mode starts.
+ * Throws with a user-facing message when nothing is found.
+ */
+function ensureAcpAgentCliAvailable(options = {}) {
+    const resolved = resolveAcpAgentCli(options);
+    if (!resolved) {
+        const homedir = options.homedir ?? os_1.default.homedir();
+        const platform = options.platform ?? process.platform;
+        throw new Error(buildAgentCliNotFoundError(homedir, platform));
+    }
+    return resolved;
+}
+function formatAcpAgentCliLog(resolved) {
+    const detail = resolved.label ?? resolved.command;
+    return `${resolved.command} (${resolved.source}${detail ? `: ${detail}` : ''})`;
+}

package/dist/lib/acp-client.js

@@ -29,8 +29,10 @@ function parseCompletionSignal(output) {
  */
 class AcpClient {
     mode;
-    constructor(mode = 'auto') {
+    agentCommand;
+    constructor(mode = 'auto', agentCommand = 'claude') {
         this.mode = mode;
+        this.agentCommand = agentCommand;
     }
     async call(opts) {
         if (this.mode === 'sdk') {
@@ -45,7 +47,7 @@ class AcpClient {
         const timeoutMs = opts.timeoutMs ?? 1_800_000;
         const isWin = process.platform === 'win32';
         return new Promise((resolve) => {
-            const child = (0, node_child_process_1.spawn)('claude', args, {
+            const child = (0, node_child_process_1.spawn)(this.agentCommand, args, {
                 cwd: opts.workDir,
                 shell: isWin,
             });

package/dist/lib/agent-launcher.js

@@ -230,10 +230,15 @@ async function ensureUserEnv(workdir, config, syncEnv) {
 }
 function buildRunnerArgs(config, workdir, skipPermissions) {
     const envFile = resolveUserEnvPath(config);
-    const args = [
-        formatRunnerArg('--env-file', envFile),
-        formatRunnerArg('--cwd', workdir),
-    ];
+    const resolvedWorkdir = path_1.default.resolve(workdir);
+    const args = [formatRunnerArg('--env-file', envFile)];
+    // run.bat → bootstrap.ps1: -cwd <path> must be two args; --cwd=path is dropped via cmd %*.
+    if (process.platform === 'win32') {
+        args.push('-cwd', resolvedWorkdir);
+    }
+    else {
+        args.push(formatRunnerArg('--cwd', resolvedWorkdir));
+    }
     if (skipPermissions) {
         args.push('--dangerously-skip-permissions');
     }

package/dist/lib/auto-assets.js

@@ -14,6 +14,7 @@ function resolveAutoAssetPaths(promptDirOverride) {
         autoRoot,
         promptDir,
         reviewRubric: node_path_1.default.join(autoRoot, 'templates', 'review-rubric.yaml'),
+        requirementsReviewRubric: node_path_1.default.join(autoRoot, 'templates', 'requirements-review-rubric.yaml'),
         skillDir: node_path_1.default.join(autoRoot, 'skills', 'svharness'),
     };
 }

package/dist/lib/auto-optimize.js

@@ -11,6 +11,18 @@ const logger_1 = require("../utils/logger");
 const phase_prompt_loader_1 = require("./phase-prompt-loader");
 const phase_deps_1 = require("./phase-deps");
 const auto_state_1 = require("./auto-state");
+const SCOPE_ALLOWED_PHASES = {
+    full: new Set([
+        'S10_wiki',
+        'S40_extract_requirements',
+        'S50_generate_specs',
+        'S60_process_references',
+        'S65_customize_agent_env',
+        'S70_runtime_assets',
+        'S80_seed_memory',
+    ]),
+    requirements: new Set(['S40_extract_requirements']),
+};
 async function runOptimizePlan(ctx, acp, cost, round, review) {
     if (!ctx.harnessRoot)
         throw new Error('缺少 harnessRoot，无法生成优化计划');
@@ -62,22 +74,27 @@ async function runOptimizeImplement(ctx, acp, cost, round, review) {
         logger_1.logger.warn(`优化实施 ACP 调用失败：${result.error ?? 'unknown error'}，继续状态重置`);
     }
     const state = await (0, auto_state_1.readBuildState)(ctx.harnessRoot);
-    const phases = await collectPlanPhases(ctx.harnessRoot, round, review);
+    const allowed = SCOPE_ALLOWED_PHASES[ctx.scope];
+    const phases = (await collectPlanPhases(ctx.harnessRoot, round, review)).filter((phase) => allowed.has(phase));
     for (const phase of phases) {
         if (!state.phases[phase])
             continue;
         state.phases[phase].status = 'PENDING';
         delete state.phases[phase].outdated_reason;
-        (0, phase_deps_1.invalidateDownstream)(phase, state);
+        if (ctx.scope === 'full') {
+            (0, phase_deps_1.invalidateDownstream)(phase, state);
+        }
     }
     for (const phase of (0, phase_deps_1.collectOutdatedKeys)(state)) {
+        if (!allowed.has(phase))
+            continue;
         state.phases[phase].status = 'PENDING';
         delete state.phases[phase].outdated_reason;
     }
     await (0, auto_state_1.writeBuildState)(ctx.harnessRoot, state);
 }
 async function collectPlanPhases(harnessRoot, round, review) {
-    const phases = new Set(review.gaps.map((gap) => (0, phase_deps_1.normalizeGapPhase)(gap.phase)));
+    const phases = new Set(review.gaps.map((gap) => (0, phase_deps_1.normalizeGapPhase)(gap.phase)).filter((p) => p.includes('_')));
     const planPath = node_path_1.default.join(harnessRoot, 'auto-review', `第${round}轮修改-plan.md`);
     if (await fs_extra_1.default.pathExists(planPath)) {
         const body = await fs_extra_1.default.readFile(planPath, 'utf8');
@@ -85,5 +102,8 @@ async function collectPlanPhases(harnessRoot, round, review) {
             phases.add((0, phase_deps_1.normalizeGapPhase)(match[0]));
         }
     }
+    if (phases.size === 0) {
+        phases.add('S40_extract_requirements');
+    }
     return [...phases];
 }

package/dist/lib/auto-orchestrator.js

@@ -52,9 +52,9 @@ class AutoOrchestrator {
     phaseRunner;
     constructor(ctx) {
         this.ctx = ctx;
-        this.acp = new acp_client_1.AcpClient(ctx.acpMode);
+        const agentCommand = ctx.acpAgentCli?.command ?? 'claude';
+        this.acp = new acp_client_1.AcpClient(ctx.acpMode, agentCommand);
         this.cost = new cost_tracker_1.CostTracker(ctx.maxTotalCalls, ctx.budgetUsd, ctx.costAlertThreshold);
-        // PhaseRunner 在 run() 中 ctx 就绪后延迟创建，避免初始 ctx.harnessRoot=null 时 PhaseRunner 持有陈旧引用
     }
     async run() {
         if (!this.ctx.harnessExists) {
@@ -63,28 +63,65 @@ class AutoOrchestrator {
         if (!this.ctx.harnessRoot) {
             throw new Error('未解析到 harnessRoot，无法继续 auto');
         }
-        // PhaseRunner 延迟创建：此时 ctx.harnessRoot 已就绪（可能在 runMaterialsPrepAndBuild 后才赋值）
         this.phaseRunner = new phase_runner_1.PhaseRunner(this.ctx, this.acp, this.cost);
         event_bus_1.dashboardEventBus.emitBuildStarted(phase_runner_1.PHASE_DEFS.length);
         await this.ensureReviewRubric();
-        await this.phaseRunner.runBuildPhases();
-        if (this.ctx.maxPhase && phaseNumber(this.ctx.maxPhase) < 85) {
-            logger_1.logger.info(`已到达 --max-phase ${this.ctx.maxPhase}，跳过评审优化`);
-            event_bus_1.dashboardEventBus.emitBuildCompleted(undefined);
-            return;
+        try {
+            await this.phaseRunner.runBuildPhases();
+        }
+        catch (err) {
+            const msg = err.message;
+            logger_1.logger.error(`[auto] 构建阶段执行失败：${msg}`);
+            event_bus_1.dashboardEventBus.emitBuildFailed(undefined);
+            throw new Error(`构建阶段失败：${msg}；auto 构建终止，请在修复后重新执行`);
+        }
+        if (this.shouldSkipReviewLoop()) {
+            logger_1.logger.info(this.ctx.scope === 'requirements'
+                ? '[auto_pack_req] 构建阶段完成，进入三维度评审'
+                : `已到达 --max-phase ${this.ctx.maxPhase}，跳过评审优化`);
+            if (this.ctx.scope !== 'requirements') {
+                event_bus_1.dashboardEventBus.emitBuildCompleted(undefined);
+                return;
+            }
         }
+        await this.runReviewOptimizeLoop();
+    }
+    shouldSkipReviewLoop() {
+        if (this.ctx.scope === 'requirements')
+            return false;
+        return !!(this.ctx.maxPhase && phaseNumber(this.ctx.maxPhase) < 85);
+    }
+    async runReviewOptimizeLoop() {
         let previousScore = 0;
         let finalReview;
         for (let round = 1; round <= this.ctx.maxOptimizeRounds; round++) {
             event_bus_1.dashboardEventBus.emitReviewStarted(round);
-            const review = await this.runHarnessReview(round);
+            let review;
+            try {
+                review = await this.runReview(round);
+            }
+            catch (err) {
+                const msg = err.message;
+                if (msg.includes('预算') || msg.includes('调用次数') || msg.includes('ACP 调用')) {
+                    logger_1.logger.error(`[auto] 第 ${round} 轮评审因资源限制终止：${msg}`);
+                    event_bus_1.dashboardEventBus.emitBuildFailed(undefined);
+                    throw err;
+                }
+                logger_1.logger.warn(`[auto] 第 ${round} 轮评审异常：${msg}，继续下一轮`);
+                continue;
+            }
             event_bus_1.dashboardEventBus.emitReviewCompleted(round, review.composite_score, review.critical_count);
             event_bus_1.dashboardEventBus.emitScoreUpdated(review.composite_score, round);
-            if (review.composite_score >= this.ctx.targetScore &&
-                review.gate_pass &&
-                review.critical_count === 0) {
+            const passed = this.ctx.scope === 'requirements'
+                ? review.composite_score > this.ctx.targetScore &&
+                    review.gate_pass &&
+                    review.critical_count === 0
+                : review.composite_score >= this.ctx.targetScore &&
+                    review.gate_pass &&
+                    review.critical_count === 0;
+            if (passed) {
                 finalReview = review;
-                await this.runFinalize(review);
+                await this.runCompletion(review);
                 break;
             }
             if (round >= this.ctx.maxOptimizeRounds) {
@@ -103,7 +140,12 @@ class AutoOrchestrator {
                 event_bus_1.dashboardEventBus.emitOptimizeCompleted(round);
             }
             catch (err) {
-                logger_1.logger.warn(`第 ${round} 轮优化执行失败：${err.message}，状态重置已完成，下一轮可继续`);
+                const msg = err.message;
+                if (msg.includes('预算') || msg.includes('次数') || msg.includes('ACP 调用')) {
+                    logger_1.logger.warn(`[auto] 第 ${round} 轮优化因资源限制终止：${msg}`);
+                    break;
+                }
+                logger_1.logger.warn(`第 ${round} 轮优化执行失败：${msg}，状态重置已完成，下一轮可继续`);
             }
         }
         event_bus_1.dashboardEventBus.emitCostUpdated(this.cost.report().estimatedCostUsd, this.cost.report().totalCalls);
@@ -118,14 +160,26 @@ class AutoOrchestrator {
         if (!this.ctx.harnessRoot)
             return;
         const assets = (0, auto_assets_1.resolveAutoAssetPaths)();
-        const dest = node_path_1.default.join(this.ctx.harnessRoot, 'auto', 'review-rubric.yaml');
-        if (!(await fs_extra_1.default.pathExists(dest))) {
-            await fs_extra_1.default.ensureDir(node_path_1.default.dirname(dest));
-            await fs_extra_1.default.copyFile(assets.reviewRubric, dest);
+        const autoDir = node_path_1.default.join(this.ctx.harnessRoot, 'auto');
+        await fs_extra_1.default.ensureDir(autoDir);
+        const rubricDest = node_path_1.default.join(autoDir, 'review-rubric.yaml');
+        if (!(await fs_extra_1.default.pathExists(rubricDest))) {
+            await fs_extra_1.default.copyFile(assets.reviewRubric, rubricDest);
             logger_1.logger.success('已注入 auto/review-rubric.yaml');
         }
+        if (this.ctx.scope === 'requirements') {
+            const reqRubricDest = node_path_1.default.join(autoDir, 'requirements-review-rubric.yaml');
+            if (!(await fs_extra_1.default.pathExists(reqRubricDest))) {
+                await fs_extra_1.default.copyFile(assets.requirementsReviewRubric, reqRubricDest);
+                logger_1.logger.success('已注入 auto/requirements-review-rubric.yaml');
+            }
+        }
     }
-    async runHarnessReview(round) {
+    async runReview(round) {
+        if (this.ctx.scope === 'requirements') {
+            const { runReqPackReview } = await Promise.resolve().then(() => __importStar(require('./auto-req-pack-review')));
+            return runReqPackReview(this.ctx, this.acp, this.cost, round);
+        }
         const { runHarnessReview } = await Promise.resolve().then(() => __importStar(require('./auto-review')));
         return runHarnessReview(this.ctx, this.acp, this.cost, round);
     }
@@ -138,7 +192,12 @@ class AutoOrchestrator {
         await runOptimizeImplement(this.ctx, this.acp, this.cost, round, review);
         await this.phaseRunner.runBuildPhases({ onlyPendingOrOutdated: true });
     }
-    async runFinalize(review) {
+    async runCompletion(review) {
+        if (this.ctx.scope === 'requirements') {
+            const { finalizeReqPack } = await Promise.resolve().then(() => __importStar(require('./auto-pack-req-finalize')));
+            await finalizeReqPack(this.ctx, review);
+            return;
+        }
         const { finalizeAutoHarness } = await Promise.resolve().then(() => __importStar(require('./auto-finalize')));
         await finalizeAutoHarness(this.ctx, review);
     }