svharness 0.15.10 → 0.15.13

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;
+}

package/dist/lib/auto-state.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupePhases = dedupePhases;
+exports.dedupePhaseFields = dedupePhaseFields;
+exports.repairBuildStateYaml = repairBuildStateYaml;
+exports.quoteUnsafeNextAction = quoteUnsafeNextAction;
 exports.readBuildState = readBuildState;
 exports.writeBuildState = writeBuildState;
 exports.phaseStatus = phaseStatus;
@@ -60,32 +63,145 @@ function dedupePhases(rawYaml) {
     }
     return result.join('\n');
 }
+const PHASE_FIELD_REGEX = /^    ([A-Za-z_][\w-]*):/;
+/**
+ * Within each phase block, drop duplicate field keys (e.g. a second
+ * `completed_at:` appended by ACP text-editing). Keeps the **last**
+ * occurrence so the most recent agent edit wins.
+ */
+function dedupeFieldsInPhaseBlock(blockLines) {
+    if (blockLines.length === 0)
+        return blockLines;
+    const spans = [];
+    for (let i = 0; i < blockLines.length; i++) {
+        const match = blockLines[i].match(PHASE_FIELD_REGEX);
+        if (!match)
+            continue;
+        if (spans.length > 0)
+            spans[spans.length - 1].end = i;
+        spans.push({ key: match[1], start: i, end: blockLines.length });
+    }
+    const lastByKey = new Map();
+    spans.forEach((span, idx) => lastByKey.set(span.key, idx));
+    const out = [];
+    spans.forEach((span, idx) => {
+        if (lastByKey.get(span.key) === idx) {
+            out.push(...blockLines.slice(span.start, span.end));
+        }
+    });
+    return out;
+}
+/**
+ * Strip duplicate field keys inside each phase block under `phases:`.
+ */
+function dedupePhaseFields(rawYaml) {
+    const lines = rawYaml.split('\n');
+    const phaseKeyRegex = /^  (\S+):$/;
+    const result = [];
+    let inPhases = false;
+    let phaseHeader = null;
+    let blockLines = [];
+    const flushPhase = () => {
+        if (phaseHeader === null)
+            return;
+        result.push(phaseHeader);
+        result.push(...dedupeFieldsInPhaseBlock(blockLines));
+        phaseHeader = null;
+        blockLines = [];
+    };
+    for (const line of lines) {
+        if (/^phases:$/.test(line)) {
+            inPhases = true;
+            result.push(line);
+            continue;
+        }
+        if (!inPhases) {
+            result.push(line);
+            continue;
+        }
+        if (/^\S/.test(line) && !/^  /.test(line)) {
+            flushPhase();
+            inPhases = false;
+            result.push(line);
+            continue;
+        }
+        const keyMatch = line.match(phaseKeyRegex);
+        if (keyMatch) {
+            flushPhase();
+            phaseHeader = line;
+            continue;
+        }
+        if (phaseHeader !== null) {
+            blockLines.push(line);
+        }
+        else {
+            result.push(line);
+        }
+    }
+    flushPhase();
+    return result.join('\n');
+}
+/** Apply all text-level repairs for agent-corrupted build-state YAML. */
+function repairBuildStateYaml(raw) {
+    return quoteUnsafeNextAction(dedupePhaseFields(dedupePhases(raw)));
+}
+/**
+ * Quote unquoted next_action scalars that contain colons.
+ * Agent text-edits sometimes write "H1: xxx" without quotes, which breaks YAML.
+ */
+function quoteUnsafeNextAction(rawYaml) {
+    return rawYaml.replace(/^next_action:\s+(?!['">|])(.+)$/gm, (_match, value) => {
+        const trimmed = value.trimEnd();
+        if (!trimmed.includes(':')) {
+            return _match;
+        }
+        const escaped = trimmed.replace(/'/g, "''");
+        return `next_action: '${escaped}'`;
+    });
+}
+function parseBuildStateBody(raw) {
+    const body = raw.replace(/^#.*\n/gm, '');
+    const state = (js_yaml_1.default.load(body) ?? {});
+    state.phases = state.phases ?? {};
+    return state;
+}
+async function persistBuildStateRaw(statePath, raw) {
+    const tmpPath = statePath + '.tmp';
+    await fs_extra_1.default.writeFile(tmpPath, raw, 'utf8');
+    await fs_extra_1.default.rename(tmpPath, statePath);
+}
 async function readBuildState(harnessRoot) {
     const statePath = node_path_1.default.join(harnessRoot, '.harness-build-state.yaml');
     const raw = await fs_extra_1.default.readFile(statePath, 'utf8');
-    const body = raw.replace(/^#.*\n/gm, '');
     try {
-        const state = (js_yaml_1.default.load(body) ?? {});
-        state.phases = state.phases ?? {};
-        return state;
+        return parseBuildStateBody(raw);
     }
     catch (err) {
-        // Auto-repair duplicate phase keys (ACP agent text-editing artifact)
-        if (err instanceof js_yaml_1.default.YAMLException && err.message.includes('duplicated mapping key')) {
-            const fixed = dedupePhases(raw);
-            // Persist the fixed content so subsequent reads also succeed
-            await fs_extra_1.default.writeFile(statePath, fixed, 'utf8');
-            const fixedBody = fixed.replace(/^#.*\n/gm, '');
-            const state = (js_yaml_1.default.load(fixedBody) ?? {});
-            state.phases = state.phases ?? {};
+        if (!(err instanceof js_yaml_1.default.YAMLException)) {
+            throw err;
+        }
+        const fixed = repairBuildStateYaml(raw);
+        if (fixed === raw) {
+            throw err;
+        }
+        try {
+            const state = parseBuildStateBody(fixed);
+            await persistBuildStateRaw(statePath, fixed);
             return state;
         }
-        throw err;
+        catch {
+            throw err;
+        }
     }
 }
 async function writeBuildState(harnessRoot, state) {
     const statePath = node_path_1.default.join(harnessRoot, '.harness-build-state.yaml');
-    await fs_extra_1.default.writeFile(statePath, STATE_HEADER + js_yaml_1.default.dump(state, { lineWidth: 100, noRefs: true, sortKeys: false }), 'utf8');
+    const tmpPath = statePath + '.tmp';
+    const content = STATE_HEADER + js_yaml_1.default.dump(state, { lineWidth: 100, noRefs: true, sortKeys: false });
+    // Write to temp file first, then atomic rename to prevent partial writes
+    // on process kill. On the same filesystem, rename is atomic.
+    await fs_extra_1.default.writeFile(tmpPath, content, 'utf8');
+    await fs_extra_1.default.rename(tmpPath, statePath);
 }
 function phaseStatus(state, phase) {
     return state.phases?.[phase]?.status;

package/dist/lib/cost-tracker.js

@@ -11,6 +11,10 @@ class CostTracker {
     totalCalls = 0;
     estimatedCostUsd = 0;
     phaseCosts = new Map();
+    budget80Warned = false;
+    budget95Warned = false;
+    calls80Warned = false;
+    calls95Warned = false;
     constructor(maxTotalCalls, budgetUsd, alertThreshold) {
         this.maxTotalCalls = maxTotalCalls;
         this.budgetUsd = budgetUsd;
@@ -24,11 +28,35 @@ class CostTracker {
         if (cost > this.alertThreshold) {
             logger_1.logger.warn(`[成本] ${phase} 本次约 $${cost.toFixed(2)}，累计 $${this.estimatedCostUsd.toFixed(2)}`);
         }
+        // Budget pre-warnings (80% → 95% → hard limit)
+        if (this.budgetUsd !== null) {
+            const usagePct = (this.estimatedCostUsd / this.budgetUsd) * 100;
+            if (usagePct >= 80 && usagePct < 95 && !this.budget80Warned) {
+                this.budget80Warned = true;
+                logger_1.logger.warn(`[成本] 预算已使用 ${usagePct.toFixed(0)}%（$${this.estimatedCostUsd.toFixed(2)} / $${this.budgetUsd.toFixed(2)}），接近上限`);
+            }
+            if (usagePct >= 95 && !this.budget95Warned) {
+                this.budget95Warned = true;
+                logger_1.logger.warn(`[成本] 预算已使用 ${usagePct.toFixed(0)}%（$${this.estimatedCostUsd.toFixed(2)} / $${this.budgetUsd.toFixed(2)}），即将达到上限`);
+            }
+        }
+        // Call count pre-warnings (80% → 95% → hard limit)
+        if (this.maxTotalCalls > 0) {
+            const callsPct = (this.totalCalls / this.maxTotalCalls) * 100;
+            if (callsPct >= 80 && callsPct < 95 && !this.calls80Warned) {
+                this.calls80Warned = true;
+                logger_1.logger.warn(`[成本] ACP 调用次数 ${this.totalCalls}/${this.maxTotalCalls}（${callsPct.toFixed(0)}%），接近上限`);
+            }
+            if (callsPct >= 95 && !this.calls95Warned) {
+                this.calls95Warned = true;
+                logger_1.logger.warn(`[成本] ACP 调用次数 ${this.totalCalls}/${this.maxTotalCalls}（${callsPct.toFixed(0)}%），即将达到上限`);
+            }
+        }
         if (this.totalCalls > this.maxTotalCalls) {
-            throw new Error(`ACP 调用次数 ${this.totalCalls} 已超过上限 ${this.maxTotalCalls}`);
+            throw new Error(`ACP 调用次数 ${this.totalCalls} 已超过上限 ${this.maxTotalCalls}，累计费用 $${this.estimatedCostUsd.toFixed(2)}`);
         }
         if (this.budgetUsd !== null && this.estimatedCostUsd > this.budgetUsd) {
-            throw new Error(`ACP 估算费用 $${this.estimatedCostUsd.toFixed(2)} 已超过预算 $${this.budgetUsd.toFixed(2)}`);
+            throw new Error(`ACP 估算费用 $${this.estimatedCostUsd.toFixed(2)} 已超过预算 $${this.budgetUsd.toFixed(2)}（${this.totalCalls} 次调用）`);
         }
         event_bus_1.dashboardEventBus.emitCostUpdated(this.estimatedCostUsd, this.totalCalls);
     }