svharness 0.15.11 → 0.15.13

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,7 +63,6 @@ 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();
@@ -76,36 +75,53 @@ class AutoOrchestrator {
             event_bus_1.dashboardEventBus.emitBuildFailed(undefined);
             throw new Error(`构建阶段失败：${msg}；auto 构建终止，请在修复后重新执行`);
         }
-        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;
+        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);
             let review;
             try {
-                review = await this.runHarnessReview(round);
+                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; // 资源限制是整个流程的硬终止
+                    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) {
@@ -127,7 +143,7 @@ class AutoOrchestrator {
                 const msg = err.message;
                 if (msg.includes('预算') || msg.includes('次数') || msg.includes('ACP 调用')) {
                     logger_1.logger.warn(`[auto] 第 ${round} 轮优化因资源限制终止：${msg}`);
-                    break; // 资源限制触发时终止优化循环，保留当前评分
+                    break;
                 }
                 logger_1.logger.warn(`第 ${round} 轮优化执行失败：${msg}，状态重置已完成，下一轮可继续`);
             }
@@ -144,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);
     }
@@ -164,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);
     }

package/dist/lib/auto-pack-req-context.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeMaterialsPackRoot = looksLikeMaterialsPackRoot;
+exports.looksLikeRequirementsFolder = looksLikeRequirementsFolder;
+exports.resolveAutoPackReqWorkContext = resolveAutoPackReqWorkContext;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const harness_resolver_1 = require("./harness-resolver");
+const DOC_FILE_RE = /\.(md|docx|doc|pdf|xlsx|xls|pptx|ppt|txt|csv)$/i;
+const MATERIALS_PACK_SUBDIR_RE = /^(requirements?|baseline|references?|extra[-_]?skills?|需求|接口|协议|skill)/i;
+/** 当前目录是否像资料包根（含 requirements/、baseline/ 等子目录） */
+async function looksLikeMaterialsPackRoot(dir) {
+    if (!(await fs_extra_1.default.pathExists(dir)))
+        return false;
+    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (MATERIALS_PACK_SUBDIR_RE.test(entry.name))
+            return true;
+    }
+    return false;
+}
+/** 当前目录是否像 requirements 资料夹（含文档文件，且不像资料包根） */
+async function looksLikeRequirementsFolder(dir) {
+    if (!(await fs_extra_1.default.pathExists(dir)))
+        return false;
+    if (await (0, harness_resolver_1.isHarnessRoot)(dir))
+        return false;
+    if (await looksLikeMaterialsPackRoot(dir))
+        return false;
+    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+    const topFiles = entries.filter((e) => e.isFile());
+    if (topFiles.some((f) => DOC_FILE_RE.test(f.name)))
+        return true;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
+            continue;
+        const sub = node_path_1.default.join(dir, entry.name);
+        const subEntries = await fs_extra_1.default.readdir(sub, { withFileTypes: true });
+        if (subEntries.some((f) => f.isFile() && DOC_FILE_RE.test(f.name)))
+            return true;
+    }
+    return false;
+}
+/**
+ * 解析 auto_pack_req 工作上下文。
+ * 无显式 workdir 时：若当前目录本身是 requirements 资料夹，则以其父目录为 workDir 并固定 requirements 输入。
+ */
+async function resolveAutoPackReqWorkContext(positionalWorkdir, configWorkDir, requirementsOverride) {
+    const explicit = positionalWorkdir ?? configWorkDir;
+    if (explicit) {
+        const workDir = node_path_1.default.resolve(explicit);
+        const harnessRoot = await (0, harness_resolver_1.resolveHarnessRoot)(workDir);
+        return {
+            workDir,
+            harnessRoot,
+            requirementsPath: requirementsOverride
+                ? node_path_1.default.isAbsolute(requirementsOverride)
+                    ? requirementsOverride
+                    : node_path_1.default.resolve(workDir, requirementsOverride)
+                : undefined,
+            mode: harnessRoot ? 'harness-rerun' : 'materials-pack',
+        };
+    }
+    const cwd = process.cwd();
+    const harnessFromCwd = await (0, harness_resolver_1.resolveHarnessRoot)(cwd);
+    if (harnessFromCwd) {
+        return { workDir: cwd, harnessRoot: harnessFromCwd, mode: 'harness-rerun' };
+    }
+    if (await looksLikeMaterialsPackRoot(cwd)) {
+        return { workDir: cwd, harnessRoot: null, mode: 'materials-pack' };
+    }
+    if (await looksLikeRequirementsFolder(cwd)) {
+        const parent = node_path_1.default.dirname(cwd);
+        const harnessFromParent = await (0, harness_resolver_1.resolveHarnessRoot)(parent);
+        return {
+            workDir: parent,
+            harnessRoot: harnessFromParent,
+            requirementsPath: node_path_1.default.resolve(cwd),
+            mode: harnessFromParent ? 'harness-rerun' : 'requirements-cwd',
+        };
+    }
+    return { workDir: cwd, harnessRoot: null, mode: 'materials-pack' };
+}

package/dist/lib/auto-pack-req-finalize.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeReqPack = finalizeReqPack;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
+async function finalizeReqPack(ctx, review) {
+    if (!ctx.harnessRoot)
+        throw new Error('缺少 harnessRoot，无法完成需求包流程');
+    const outPath = node_path_1.default.join(ctx.harnessRoot, 'auto-review', 'pack-req-complete.json');
+    await fs_extra_1.default.ensureDir(node_path_1.default.dirname(outPath));
+    await fs_extra_1.default.writeFile(outPath, JSON.stringify({
+        completed_at: new Date().toISOString(),
+        scope: 'requirements',
+        composite_score: review.composite_score,
+        target_score: ctx.targetScore,
+        gate_pass: review.gate_pass,
+        critical_count: review.critical_count,
+        mechanical_score: review.mechanical_score,
+        adversarial_score: review.review_score,
+        report_path: node_path_1.default.relative(ctx.harnessRoot, review.report_path).replace(/\\/g, '/'),
+        note: 'auto_pack_req 需求条目化闭环完成（未执行 S90 封存）',
+    }, null, 2), 'utf8');
+    logger_1.logger.success(`auto_pack_req 完成：综合分 ${review.composite_score.toFixed(1)} > ${ctx.targetScore}，产物见 auto-review/`);
+}

package/dist/lib/auto-req-pack-review.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqPackReview = runReqPackReview;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
+const phase_prompt_loader_1 = require("./phase-prompt-loader");
+const gate_checker_1 = require("./gate-checker");
+const score_aggregator_1 = require("./score-aggregator");
+const auto_sample_trace_1 = require("./auto-sample-trace");
+const review_parser_1 = require("./review-parser");
+async function runReqPackReview(ctx, acp, cost, round) {
+    if (!ctx.harnessRoot)
+        throw new Error('缺少 harnessRoot，无法评审');
+    await fs_extra_1.default.ensureDir(node_path_1.default.join(ctx.harnessRoot, 'auto-review'));
+    const gates = await (0, gate_checker_1.runMechanicalGates)(ctx.harnessRoot, {
+        scope: 'requirements',
+        verbose: ctx.verbose,
+    });
+    await (0, auto_sample_trace_1.writeSampleFragmentsFile)(ctx.harnessRoot, ctx.sampleCount);
+    const selfReviewPath = node_path_1.default.join(ctx.harnessRoot, 'auto-review', `第${round}轮需求自评报告.md`);
+    const adversarialPath = node_path_1.default.join(ctx.harnessRoot, 'auto-review', `第${round}轮对抗评审.md`);
+    const samplePath = node_path_1.default.join(ctx.harnessRoot, 'auto-review', `第${round}轮抽样验证报告.md`);
+    if (ctx.dryRun) {
+        for (const template of ['S40-review.md', 'S40-adversarial-review.md', 'S40-sample-trace.md']) {
+            const prompt = await (0, phase_prompt_loader_1.loadPhasePrompt)(template, buildPromptVars(ctx, round, gates), ctx.promptDir);
+            logger_1.logger.plain(`\n--- ${template} ---\n${prompt}\n`);
+        }
+        return dryRunReqPackReview(round, gates);
+    }
+    await runAcpReviewPhase(ctx, acp, cost, round, 'S40-review.md', 'req_self_review', '<AUTO_SIGNAL>REQ_REVIEW_DONE</AUTO_SIGNAL>');
+    await runAcpReviewPhase(ctx, acp, cost, round, 'S40-adversarial-review.md', 'req_adversarial_review', '<AUTO_SIGNAL>ADV_REVIEW_DONE</AUTO_SIGNAL>');
+    await runAcpReviewPhase(ctx, acp, cost, round, 'S40-sample-trace.md', 'req_sample_trace', '<AUTO_SIGNAL>SAMPLE_TRACE_DONE</AUTO_SIGNAL>');
+    const selfRaw = await (0, review_parser_1.parseReportFrontmatter)(selfReviewPath);
+    const advRaw = await (0, review_parser_1.parseReportFrontmatter)(adversarialPath);
+    const sampleRaw = await (0, review_parser_1.parseReportFrontmatter)(samplePath);
+    if (!advRaw || !sampleRaw) {
+        throw new Error(`第 ${round} 轮需求评审报告缺失或 frontmatter 格式错误`);
+    }
+    const adversarial = parseAdversarialScore(advRaw);
+    const sampleTrace = parseSampleTraceScore(sampleRaw);
+    const selfContent = await fs_extra_1.default.readFile(selfReviewPath, 'utf8').catch(() => '');
+    const gaps = (0, review_parser_1.parseGapsFromMarkdown)(selfContent);
+    const criticalCount = countCriticalIssues(adversarial, gaps);
+    const scores = (0, score_aggregator_1.computeReqPackScore)(gates, adversarial.average, sampleTrace.average, criticalCount);
+    const review = {
+        round,
+        report_path: adversarialPath,
+        dimension_scores: {
+            requirements: Number(asRecord(asRecord(selfRaw?.score).dimensions).requirements ?? 0),
+        },
+        mechanical_score: scores.mechanical,
+        review_score: scores.adversarial,
+        critical_count: criticalCount,
+        gate_pass: scores.gate_pass,
+        gate_details: gates,
+        modifications_required: !(scores.composite > ctx.targetScore &&
+            scores.gate_pass &&
+            criticalCount === 0),
+        gaps,
+        composite_score: scores.composite,
+    };
+    await writeReqPackScoreSnapshot(ctx, review, adversarial, sampleTrace, scores);
+    logger_1.logger.info(`第 ${round} 轮需求包评分：综合 ${scores.composite.toFixed(1)} / 10 ` +
+        `(机械 ${scores.mechanical.toFixed(1)} + 对抗 ${scores.adversarial.toFixed(1)} + 抽样 ${scores.sample_trace.toFixed(1)})`);
+    return review;
+}
+async function runAcpReviewPhase(ctx, acp, cost, round, template, phaseKey, signal) {
+    const gates = await (0, gate_checker_1.runMechanicalGates)(ctx.harnessRoot, { scope: 'requirements', verbose: ctx.verbose });
+    const prompt = await (0, phase_prompt_loader_1.loadPhasePrompt)(template, buildPromptVars(ctx, round, gates), ctx.promptDir);
+    cost.recordCall(`${phaseKey}_round_${round}`);
+    const result = await acp.call({
+        workDir: ctx.harnessRoot,
+        phase: phaseKey,
+        prompt: (0, phase_prompt_loader_1.wrapAcpPrompt)(prompt, signal),
+        timeoutMs: ctx.acpTimeoutMs,
+    });
+    await fs_extra_1.default.writeFile(node_path_1.default.join(ctx.harnessRoot, 'auto-review', `${phaseKey}-round-${round}.log`), [result.output, result.error ? `\n[stderr]\n${result.error}` : ''].join(''), 'utf8');
+    if (!result.success) {
+        throw new Error(`${template} Agent 调用失败：${result.error ?? 'unknown error'}`);
+    }
+}
+function buildPromptVars(ctx, round, gates) {
+    return {
+        HARNESS_ROOT: ctx.harnessRoot,
+        AUTO_GOAL: ctx.goal ?? '未提供构建目的，请根据 harness 内容判断',
+        ROUND: round,
+        DOCTOR_EXIT: gates.doctor_exit,
+        VERIFY_EXIT: gates.verify_exit,
+        FILE_COMPLETENESS_PCT: gates.file_completeness_pct.toFixed(1),
+        SAMPLE_FRAGMENTS_PATH: node_path_1.default.join(ctx.harnessRoot, 'auto-review', 'sample-fragments.json'),
+    };
+}
+function parseAdversarialScore(raw) {
+    const score = asRecord(raw.score);
+    const adv = asRecord(score.adversarial);
+    const coverage = Number(adv.coverage ?? 0);
+    const fidelity = Number(adv.fidelity ?? 0);
+    const completeness = Number(adv.completeness ?? 0);
+    const average = Number(adv.average ?? (coverage + fidelity + completeness) / 3);
+    const issues = Array.isArray(raw.issues)
+        ? raw.issues
+        : [];
+    return { coverage, fidelity, completeness, average, issues };
+}
+function parseSampleTraceScore(raw) {
+    const score = asRecord(raw.score);
+    const st = asRecord(score.sample_trace);
+    const traceability = Number(st.traceability ?? 0);
+    const fidelity = Number(st.fidelity ?? 0);
+    const usability = Number(st.usability ?? 0);
+    const average = Number(st.average ?? (traceability + fidelity + usability) / 3);
+    const items = Array.isArray(st.items)
+        ? st.items
+        : [];
+    return { traceability, fidelity, usability, average, items };
+}
+function countCriticalIssues(adversarial, gaps) {
+    const fromAdv = adversarial.issues.filter((i) => i.severity === 'critical').length;
+    const fromGaps = gaps.filter((g) => g.severity === 'critical').length;
+    return fromAdv + fromGaps;
+}
+async function writeReqPackScoreSnapshot(ctx, review, adversarial, sampleTrace, scores) {
+    const snapshot = {
+        round: review.round,
+        evaluated_at: new Date().toISOString(),
+        scope: 'requirements',
+        mechanical_score: scores.mechanical,
+        adversarial_score: scores.adversarial,
+        sample_trace_score: scores.sample_trace,
+        composite_score: scores.composite,
+        target_score: ctx.targetScore,
+        gate_pass: scores.gate_pass,
+        critical_count: review.critical_count,
+        adversarial_details: adversarial,
+        sample_trace_details: sampleTrace,
+        gate_details: review.gate_details,
+    };
+    await fs_extra_1.default.writeFile(node_path_1.default.join(ctx.harnessRoot, 'auto-review', 'auto-score.json'), JSON.stringify(snapshot, null, 2), 'utf8');
+}
+function dryRunReqPackReview(round, gates) {
+    return {
+        round,
+        report_path: 'dry-run',
+        review_score: 0,
+        dimension_scores: {},
+        critical_count: 0,
+        gaps: [],
+        gate_pass: false,
+        gate_details: gates,
+        mechanical_score: 0,
+        composite_score: 0,
+        modifications_required: true,
+    };
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}

package/dist/lib/auto-sample-trace.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSampleFragments = generateSampleFragments;
+exports.writeSampleFragmentsFile = writeSampleFragmentsFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const MIN_EXCERPT_CHARS = 50;
+const MAX_EXCERPT_CHARS = 200;
+const NUMERIC_PATTERN = /\d+(\.\d+)?(%|ms|s|Hz|MHz|GB|MB|KB)?/;
+const ENUM_PATTERN = /\b(ON|OFF|TRUE|FALSE|ENABLE|DISABLE|是|否|打开|关闭)\b/i;
+const TIMING_PATTERN = /\b(延迟|超时|timeout|delay|ms|秒|分钟|时序|周期)\b/i;
+const SIGNAL_PRIORITY = {
+    numeric: 5,
+    timing: 4,
+    enum: 4,
+    table_row: 3,
+    list_item: 2,
+    paragraph: 1,
+};
+function classifyLine(text) {
+    const trimmed = text.trim();
+    if (!trimmed || trimmed.startsWith('```') || trimmed === '---') {
+        return { signal_type: 'paragraph', priority: 0 };
+    }
+    if (trimmed.startsWith('|') && trimmed.split('|').filter(Boolean).length >= 2) {
+        return { signal_type: 'table_row', priority: SIGNAL_PRIORITY.table_row };
+    }
+    if (/^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) {
+        return { signal_type: 'list_item', priority: SIGNAL_PRIORITY.list_item };
+    }
+    if (NUMERIC_PATTERN.test(trimmed)) {
+        return { signal_type: 'numeric', priority: SIGNAL_PRIORITY.numeric };
+    }
+    if (TIMING_PATTERN.test(trimmed)) {
+        return { signal_type: 'timing', priority: SIGNAL_PRIORITY.timing };
+    }
+    if (ENUM_PATTERN.test(trimmed)) {
+        return { signal_type: 'enum', priority: SIGNAL_PRIORITY.enum };
+    }
+    if (/^#{1,6}\s/.test(trimmed)) {
+        return { signal_type: 'list_item', priority: SIGNAL_PRIORITY.list_item + 1 };
+    }
+    return { signal_type: 'paragraph', priority: SIGNAL_PRIORITY.paragraph };
+}
+function buildExcerpt(lines, startIdx) {
+    let excerpt = '';
+    let endIdx = startIdx;
+    for (let i = startIdx; i < lines.length && excerpt.length < MAX_EXCERPT_CHARS; i++) {
+        const line = lines[i]?.trim();
+        if (!line)
+            continue;
+        const next = excerpt ? `${excerpt}\n${line}` : line;
+        if (next.length > MAX_EXCERPT_CHARS && excerpt.length >= MIN_EXCERPT_CHARS)
+            break;
+        excerpt = next;
+        endIdx = i;
+        if (excerpt.length >= MIN_EXCERPT_CHARS && excerpt.length >= MAX_EXCERPT_CHARS * 0.6)
+            break;
+    }
+    if (excerpt.length < MIN_EXCERPT_CHARS)
+        return null;
+    return { excerpt, endIdx };
+}
+async function collectCandidates(mdDir) {
+    const candidates = [];
+    if (!(await fs_extra_1.default.pathExists(mdDir)))
+        return candidates;
+    const files = (await fs_extra_1.default.readdir(mdDir)).filter((f) => f.endsWith('.md'));
+    for (const file of files) {
+        const abs = node_path_1.default.join(mdDir, file);
+        const content = await fs_extra_1.default.readFile(abs, 'utf8');
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            const { signal_type, priority } = classifyLine(lines[i] ?? '');
+            if (priority === 0)
+                continue;
+            candidates.push({
+                file: node_path_1.default.join('requirements/md', file).replace(/\\/g, '/'),
+                lineNo: i + 1,
+                text: lines[i] ?? '',
+                signal_type,
+                priority,
+            });
+        }
+    }
+    return candidates;
+}
+function shuffle(items) {
+    const copy = [...items];
+    for (let i = copy.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy;
+}
+async function generateSampleFragments(harnessRoot, count = 7) {
+    const mdDir = node_path_1.default.join(harnessRoot, 'requirements', 'md');
+    const candidates = await collectCandidates(mdDir);
+    if (candidates.length === 0)
+        return [];
+    const sorted = [...candidates].sort((a, b) => b.priority - a.priority);
+    const highPriority = sorted.filter((c) => c.priority >= 3);
+    const pool = shuffle(highPriority.length >= count ? highPriority : sorted);
+    const selected = pool.slice(0, Math.min(count, pool.length));
+    const fragments = [];
+    const usedKeys = new Set();
+    for (const cand of selected) {
+        const abs = node_path_1.default.join(harnessRoot, cand.file);
+        if (!(await fs_extra_1.default.pathExists(abs)))
+            continue;
+        const lines = (await fs_extra_1.default.readFile(abs, 'utf8')).split(/\r?\n/);
+        const startIdx = cand.lineNo - 1;
+        const built = buildExcerpt(lines, startIdx);
+        if (!built)
+            continue;
+        const key = `${cand.file}:${cand.lineNo}`;
+        if (usedKeys.has(key))
+            continue;
+        usedKeys.add(key);
+        fragments.push({
+            id: `SF-${String(fragments.length + 1).padStart(3, '0')}`,
+            file: cand.file,
+            start_line: cand.lineNo,
+            end_line: built.endIdx + 1,
+            excerpt: built.excerpt,
+            signal_type: cand.signal_type,
+        });
+    }
+    return fragments;
+}
+async function writeSampleFragmentsFile(harnessRoot, count = 7) {
+    const fragments = await generateSampleFragments(harnessRoot, count);
+    const outDir = node_path_1.default.join(harnessRoot, 'auto-review');
+    await fs_extra_1.default.ensureDir(outDir);
+    await fs_extra_1.default.writeJson(node_path_1.default.join(outDir, 'sample-fragments.json'), {
+        generated_at: new Date().toISOString(),
+        count: fragments.length,
+        fragments,
+    }, { spaces: 2 });
+    return fragments;
+}