ai-dev-harness 0.1.1 → 0.1.3

package/dist/contextScore.js

@@ -0,0 +1,44 @@
+import { writeFile } from "node:fs/promises";
+function hasValueAfter(label, output) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = output.match(new RegExp(`${escaped}\\s*[:：]?\\s*([^\\n]+)`, "i"));
+    if (!match)
+        return false;
+    const value = match[1].trim();
+    return Boolean(value && !/^[-(]?\s*(none|n\/a|unknown|无|没有|未使用|缺失|不适用)/i.test(value));
+}
+function hasAnyValueAfter(labels, output) {
+    return labels.some((label) => hasValueAfter(label, output));
+}
+function hasAnyPattern(patterns, output) {
+    return patterns.some((pattern) => pattern.test(output));
+}
+export function createContextScore(output) {
+    const requiredFields = {
+        codegraphToolsUsed: hasAnyValueAfter(["CodeGraph tools used", "CodeGraph 工具", "CodeGraph 使用工具", "代码图谱工具"], output) ||
+            hasAnyPattern([/codegraph[_-]?\w+/i, /codegraph_explore/i], output),
+        blastRadiusSummary: hasAnyValueAfter(["Blast-radius summary", "Blast radius summary", "影响范围", "影响面", "变更影响范围"], output) ||
+            hasAnyPattern([/blast[_ -]?radius/i, /影响范围\s*[:：]\s*\S+/i], output),
+        knowledgeConceptIds: hasAnyValueAfter(["Candidate concept_ids", "Concept IDs", "候选 concept_ids", "知识库 concept_ids", "知识概念"], output) ||
+            hasAnyPattern([/concept[_ -]?ids?\s*[:：]\s*\S+/i, /\/[^ \n]+\/(overview|features|metrics|api|playbooks|references)\//i], output),
+        missingContextDeclared: hasAnyValueAfter(["Missing context", "缺失上下文", "上下文缺口", "未确认上下文"], output) ||
+            hasAnyPattern([/Missing context\s*[:：]/i, /缺失上下文\s*[:：]/i, /上下文缺口\s*[:：]/i], output)
+    };
+    const missing = Object.entries(requiredFields)
+        .filter(([, present]) => !present)
+        .map(([key]) => key);
+    const presentCount = Object.values(requiredFields).filter(Boolean).length;
+    return {
+        status: presentCount >= 4 ? "strong" : presentCount >= 2 ? "acceptable" : "weak",
+        requiredFields,
+        missing,
+        recommendation: missing.length
+            ? `下一轮请补充以下上下文证据：${missing.join(", ")}。`
+            : "上下文证据结构完整。"
+    };
+}
+export async function writeContextScore(path, output) {
+    const score = createContextScore(output);
+    await writeFile(path, `${JSON.stringify(score, null, 2)}\n`, "utf8");
+    return score;
+}

package/dist/diagnostics.js

@@ -0,0 +1,58 @@
+import { writeFile } from "node:fs/promises";
+import { truncate } from "./utils.js";
+const FILE_PATTERN = /(?:^|\s)([A-Za-z]:[\\/][^\s:]+|\b[\w./\\-]+\.(?:ts|tsx|js|jsx|json|md|yaml|yml|py|java|cc|cpp|h|hpp|cs|go|rs))(?::(\d+))?/g;
+function uniq(values) {
+    return [...new Set(values.filter(Boolean))].slice(0, 20);
+}
+function errorLines(log) {
+    return log
+        .split(/\r?\n/)
+        .filter((line) => /error|failed|failure|exception|assert|not ok|FAIL|Error:/i.test(line))
+        .slice(0, 30)
+        .map((line) => truncate(line, 500));
+}
+function suspectedFiles(log) {
+    const files = [];
+    for (const match of log.matchAll(FILE_PATTERN))
+        files.push(match[1].replace(/\\/g, "/"));
+    return uniq(files);
+}
+function testNames(log) {
+    const names = [];
+    for (const line of log.split(/\r?\n/)) {
+        const subtest = line.match(/# Subtest:\s*(.+)$/);
+        if (subtest)
+            names.push(subtest[1].trim());
+        const jest = line.match(/(?:FAIL|✕|×)\s+(.+)$/);
+        if (jest)
+            names.push(jest[1].trim());
+    }
+    return uniq(names);
+}
+export function createVerifyDiagnostics(verify) {
+    const failedCommands = verify.commands
+        .filter((command) => command.exitCode !== 0)
+        .map((command) => {
+        const log = `${command.stdout}\n${command.stderr}`;
+        const errors = errorLines(log);
+        return {
+            name: command.name,
+            command: command.command,
+            exitCode: command.exitCode,
+            failureSummary: errors[0] ?? truncate(log.trim() || "验证命令失败但没有输出。", 1000),
+            errorLines: errors,
+            suspectedFiles: suspectedFiles(log),
+            testNames: testNames(log),
+            rawLogRef: "verify.json"
+        };
+    });
+    return {
+        status: verify.status,
+        failedCommands
+    };
+}
+export async function writeVerifyDiagnostics(path, verify) {
+    const diagnostics = createVerifyDiagnostics(verify);
+    await writeFile(path, `${JSON.stringify(diagnostics, null, 2)}\n`, "utf8");
+    return diagnostics;
+}

package/dist/doctor.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { git, pathExists, runCommand } from "./utils.js";
+const agentLabels = ["codex", "claude", "cursor", "gemini"];
+function commandHead(command) {
+    const trimmed = command.trim();
+    const quoted = trimmed.match(/^"([^"]+)"/);
+    if (quoted)
+        return quoted[1];
+    return trimmed.split(/\s+/)[0] ?? "";
+}
+async function commandAvailable(command, cwd) {
+    const head = commandHead(command);
+    if (!head)
+        return false;
+    const probe = process.platform === "win32" ? `where ${head}` : `command -v ${head}`;
+    const result = await runCommand(probe, cwd, undefined, 5000);
+    return result.exitCode === 0;
+}
+function renderStatus(status) {
+    if (status === "ok")
+        return "OK";
+    if (status === "warn")
+        return "WARN";
+    return "FAIL";
+}
+export async function runDoctor(cwd, config) {
+    const checks = [];
+    const isGitRepo = Boolean(await git(cwd, "rev-parse --show-toplevel"));
+    checks.push({
+        name: "Git 仓库",
+        status: isGitRepo ? "ok" : "fail",
+        detail: isGitRepo ? "当前目录是 Git 仓库。" : "当前目录不是 Git 仓库，请在业务仓库根目录运行。"
+    });
+    const gitStatus = isGitRepo ? await git(cwd, "status --short") : "";
+    checks.push({
+        name: "Git 工作区",
+        status: gitStatus ? "warn" : "ok",
+        detail: gitStatus ? "当前存在未提交改动，restore 会拒绝自动恢复运行前已有改动。" : "当前工作区 clean。"
+    });
+    checks.push({
+        name: "harness.yaml",
+        status: (await pathExists(path.join(cwd, "harness.yaml"))) ? "ok" : "fail",
+        detail: (await pathExists(path.join(cwd, "harness.yaml"))) ? "配置文件存在。" : "未找到 harness.yaml，请先运行 harness init。"
+    });
+    const skillNames = ["fix_bug", "add_feature", "write_tests", "update_docs"];
+    const missingSkills = [];
+    for (const skill of skillNames) {
+        if (!(await pathExists(path.join(cwd, "skills", skill, "SKILL.md"))))
+            missingSkills.push(skill);
+    }
+    checks.push({
+        name: "内置 Skills",
+        status: missingSkills.length ? "fail" : "ok",
+        detail: missingSkills.length ? `缺少 Skill：${missingSkills.join(", ")}。` : "内置 Skill 文件完整。"
+    });
+    checks.push({
+        name: "对话集成脚本",
+        status: (await pathExists(path.join(cwd, ".harness", "ai-dev-harness", "scripts", "run-harness.ps1"))) ? "ok" : "warn",
+        detail: (await pathExists(path.join(cwd, ".harness", "ai-dev-harness", "scripts", "run-harness.ps1")))
+            ? "run-harness.ps1 已安装。"
+            : "未找到对话集成脚本；CLI 仍可用，可运行 harness install-integration --agent all。"
+    });
+    for (const agent of agentLabels) {
+        const command = config.agents[agent].command;
+        const available = await commandAvailable(command, cwd);
+        checks.push({
+            name: `${agent} 执行器`,
+            status: available ? "ok" : "warn",
+            detail: available ? `命令可用：${command}` : `命令不可用或不在 PATH：${command}。不用该 agent 可忽略。`
+        });
+    }
+    const mcpUrls = [
+        ["CodeGraph MCP", config.mcp.codegraph.url],
+        ["Knowledge Graph MCP", config.mcp.knowledgeGraph.url]
+    ];
+    for (const [name, url] of mcpUrls) {
+        const isDefaultLocal = /localhost:733[12]/.test(url);
+        checks.push({
+            name,
+            status: url && !isDefaultLocal ? "ok" : "warn",
+            detail: url
+                ? isDefaultLocal
+                    ? `当前仍是默认地址：${url}。本地试点请改成真实 MCP source metadata。`
+                    : `已配置地址：${url}。Harness 只记录 metadata，不主动连接。`
+                : "未配置 MCP 地址。"
+        });
+    }
+    const verifyCommands = config.verify.defaultCommands;
+    const onlyGitStatus = verifyCommands.length === 1 && verifyCommands[0].command === "git status --short";
+    checks.push({
+        name: "验证命令强度",
+        status: onlyGitStatus ? "warn" : "ok",
+        detail: onlyGitStatus
+            ? "当前只有 git status，适合冒烟但验证较弱；试点真实任务建议补充 test/lint/typecheck。"
+            : `已配置 ${verifyCommands.length} 条默认验证命令。`
+    });
+    const failed = checks.some((check) => check.status === "fail");
+    const text = ["AI Dev Harness Doctor", ...checks.map((check) => `- [${renderStatus(check.status)}] ${check.name}: ${check.detail}`)].join("\n");
+    return { checks, failed, text };
+}

package/dist/feedback.js

@@ -0,0 +1,5 @@
+import { appendFile } from "node:fs/promises";
+import { nowIso } from "./utils.js";
+export async function feedbackEvent(feedbackPath, event, detail = {}) {
+    await appendFile(feedbackPath, `${JSON.stringify({ timestamp: nowIso(), event, ...detail })}\n`, "utf8");
+}

package/dist/integration.js

@@ -10,7 +10,7 @@ export async function installIntegration(options) {
     created.push(...scriptResult.created);
     updated.push(...scriptResult.updated);
     skipped.push(...scriptResult.skipped);
-    if (options.agent === "claude" || options.agent === "both") {
+    if (options.agent === "claude" || options.agent === "both" || options.agent === "all") {
         const result = await installClaudeSkill(options.targetDir, options.harnessCommand, options.packageRoot);
         if (result === "created")
             created.push(".claude/skills/ai-dev-harness/SKILL.md");
@@ -19,7 +19,7 @@ export async function installIntegration(options) {
         else
             skipped.push(".claude/skills/ai-dev-harness/SKILL.md");
     }
-    if (options.agent === "codex" || options.agent === "both") {
+    if (options.agent === "codex" || options.agent === "both" || options.agent === "all") {
         const result = await installCodexRules(options.targetDir, options.harnessCommand, options.packageRoot);
         if (result === "created")
             created.push("AGENTS.md");
@@ -28,6 +28,24 @@ export async function installIntegration(options) {
         else
             skipped.push("AGENTS.md");
     }
+    if (options.agent === "cursor" || options.agent === "all") {
+        const result = await installCursorRules(options.targetDir, options.harnessCommand, options.packageRoot);
+        if (result === "created")
+            created.push(".cursor/rules/ai-dev-harness.mdc");
+        else if (result === "updated")
+            updated.push(".cursor/rules/ai-dev-harness.mdc");
+        else
+            skipped.push(".cursor/rules/ai-dev-harness.mdc");
+    }
+    if (options.agent === "gemini" || options.agent === "all") {
+        const result = await installGeminiRules(options.targetDir, options.harnessCommand, options.packageRoot);
+        if (result === "created")
+            created.push("GEMINI.md");
+        else if (result === "updated")
+            updated.push("GEMINI.md");
+        else
+            skipped.push("GEMINI.md");
+    }
     return { created, updated, skipped };
 }
 async function installScriptAssets(targetDir, packageRoot, harnessCliPath) {
@@ -92,6 +110,38 @@ async function installCodexRules(targetDir, harnessCommand, packageRoot) {
     await appendFile(agentsPath, `\n\n${block}`, "utf8");
     return "updated";
 }
+async function installCursorRules(targetDir, harnessCommand, packageRoot) {
+    const rulesPath = path.join(targetDir, ".cursor", "rules", "ai-dev-harness.mdc");
+    await mkdir(path.dirname(rulesPath), { recursive: true });
+    const next = await cursorRules(harnessCommand, packageRoot);
+    if (await pathExists(rulesPath)) {
+        const current = await readFile(rulesPath, "utf8");
+        if (current === next)
+            return "skipped";
+        await writeFile(rulesPath, next, "utf8");
+        return "updated";
+    }
+    await writeFile(rulesPath, next, "utf8");
+    return "created";
+}
+async function installGeminiRules(targetDir, harnessCommand, packageRoot) {
+    const geminiPath = path.join(targetDir, "GEMINI.md");
+    const block = await geminiBlock(harnessCommand, packageRoot);
+    if (!(await pathExists(geminiPath))) {
+        await writeFile(geminiPath, `# Project Agent Rules\n\n${block}`, "utf8");
+        return "created";
+    }
+    const current = await readFile(geminiPath, "utf8");
+    if (current.includes("## AI Dev Harness")) {
+        const next = current.replace(/(?:\r?\n){0,2}## AI Dev Harness[\s\S]*$/m, `\n\n${block}`);
+        if (next === current)
+            return "skipped";
+        await writeFile(geminiPath, next, "utf8");
+        return "updated";
+    }
+    await appendFile(geminiPath, `\n\n${block}`, "utf8");
+    return "updated";
+}
 async function claudeSkill(harnessCommand, packageRoot) {
     return renderTemplate(await readTemplateFile(path.join("integrations", "claude", "SKILL.md"), packageRoot), {
         HARNESS_COMMAND: harnessCommand
@@ -102,3 +152,13 @@ async function codexBlock(harnessCommand, packageRoot) {
         HARNESS_COMMAND: harnessCommand
     });
 }
+async function cursorRules(harnessCommand, packageRoot) {
+    return renderTemplate(await readTemplateFile(path.join("integrations", "cursor", "ai-dev-harness.mdc"), packageRoot), {
+        HARNESS_COMMAND: harnessCommand
+    });
+}
+async function geminiBlock(harnessCommand, packageRoot) {
+    return renderTemplate(await readTemplateFile(path.join("integrations", "gemini", "GEMINI_BLOCK.md"), packageRoot), {
+        HARNESS_COMMAND: harnessCommand
+    });
+}

package/dist/loop.js

@@ -0,0 +1,116 @@
+import { writeFile } from "node:fs/promises";
+export function evaluateIteration(options) {
+    let failureType = "none";
+    let reason = "Agent 执行成功、输出契约通过、验证通过。";
+    if (options.agentResult.status !== "success") {
+        failureType = "agent_failed";
+        reason = `Agent 执行失败：${options.agentResult.error ?? `exitCode=${options.agentResult.exitCode}`}`;
+    }
+    else if (options.contractCheck.status !== "passed") {
+        failureType = "contract_failed";
+        reason = `Agent 输出缺少必需章节：${options.contractCheck.missingSections.join(", ") || "unknown"}`;
+    }
+    else if (options.approval?.required) {
+        failureType = "approval_required";
+        reason = `触发审批门禁：${options.approval.reasons.map((item) => item.type).join(", ")}`;
+    }
+    else if (options.contextScore?.status === "weak") {
+        failureType = "context_weak";
+        reason = `上下文证据不足：${options.contextScore.missing.join(", ") || "unknown"}`;
+    }
+    else if (options.verifyResult.status !== "passed") {
+        failureType = "verify_failed";
+        const failed = options.verifyResult.commands.filter((command) => command.exitCode !== 0).map((command) => command.name);
+        const diagnostic = options.verifyDiagnostics?.failedCommands[0]?.failureSummary;
+        reason = `验证未通过：${failed.join(", ") || options.verifyResult.status}${diagnostic ? `；${diagnostic}` : ""}`;
+    }
+    if (failureType === "none") {
+        return {
+            iteration: options.iteration,
+            status: "passed",
+            failureType,
+            reason,
+            canRework: false,
+            nextAction: "summarize",
+            signals: {
+                agentStatus: options.agentResult.status,
+                agentExitCode: options.agentResult.exitCode,
+                contractStatus: options.contractCheck.status,
+                verifyStatus: options.verifyResult.status,
+                contextScoreStatus: options.contextScore?.status,
+                approvalRequired: Boolean(options.approval?.required),
+                changedFiles: options.agentResult.changedFiles
+            }
+        };
+    }
+    if (options.previous?.failureType === failureType) {
+        failureType = "same_failure_repeated";
+        reason = `连续两轮出现相同失败，停止自循环：${options.previous.failureType}`;
+    }
+    else if (options.iteration >= options.maxIterations) {
+        failureType = "max_iterations_reached";
+        reason = `达到最大自循环轮次 ${options.maxIterations}，停止。最后失败原因：${reason}`;
+    }
+    const canRework = failureType !== "same_failure_repeated" && failureType !== "max_iterations_reached" && failureType !== "approval_required";
+    return {
+        iteration: options.iteration,
+        status: canRework ? "rework_needed" : "stopped",
+        failureType,
+        reason,
+        canRework,
+        nextAction: canRework ? "rework" : "stop",
+        signals: {
+            agentStatus: options.agentResult.status,
+            agentExitCode: options.agentResult.exitCode,
+            contractStatus: options.contractCheck.status,
+            verifyStatus: options.verifyResult.status,
+            contextScoreStatus: options.contextScore?.status,
+            approvalRequired: Boolean(options.approval?.required),
+            changedFiles: options.agentResult.changedFiles
+        }
+    };
+}
+export function renderReworkFeedback(evaluation) {
+    return `上一轮自纠偏评估:
+- iteration: ${evaluation.iteration}
+- failure_type: ${evaluation.failureType}
+- reason: ${evaluation.reason}
+- next_action: ${evaluation.nextAction}
+
+请只围绕上述失败原因做最小 rework：
+1. 重新检查目标、上下文和计划是否偏离。
+2. 优先修复验证失败、输出契约缺失、上下文证据不足或 Agent 执行错误。
+3. 不扩大任务范围，不做无关重构。
+4. 如果需要扩大范围、改公共接口、或目标不明确，请停止并说明需要人工确认。`;
+}
+export async function writeLoopArtifacts(options) {
+    await writeFile(options.reviewPath, `${JSON.stringify(options.review, null, 2)}\n`, "utf8");
+    const latest = options.review.iterations.at(-1);
+    const report = `# 自纠偏循环报告
+
+## 结果
+- 状态: ${options.review.status}
+- 最大轮次: ${options.review.maxIterations}
+- 实际轮次: ${options.review.iterations.length}
+- 最终原因: ${latest?.reason ?? "无"}
+
+## 轮次明细
+${options.review.iterations
+        .map((item) => `### Iteration ${item.iteration}
+- 状态: ${item.status}
+- 失败类型: ${item.failureType}
+- 原因: ${item.reason}
+- 下一步: ${item.nextAction}
+- Agent: ${item.signals.agentStatus} (${item.signals.agentExitCode ?? "n/a"})
+- 契约: ${item.signals.contractStatus}
+- 验证: ${item.signals.verifyStatus}
+- 修改文件: ${item.signals.changedFiles.join(", ") || "无"}`)
+        .join("\n\n")}
+
+## 人工介入建议
+- 如果状态为 stopped，请先看 \`execution.log\`、\`verify.json\`、\`agent_contract.json\` 和本报告中的失败类型。
+- 如果失败类型是 \`same_failure_repeated\`，优先补充上下文、调整 Skill 或让用户确认目标。
+- 如果失败类型是 \`max_iterations_reached\`，不要继续盲目重跑，先做人工评审。
+`;
+    await writeFile(options.reportPath, report, "utf8");
+}

package/dist/mcp.js

@@ -9,7 +9,7 @@ function endpointSummary(endpoint) {
 function agentDrivenResult(source, endpoint, skill) {
     const request = {
         mode: "agent-driven",
-        instruction: "Claude/Codex should call this MCP server with its own configured MCP client before invoking Harness. Harness records the configured source but does not implement MCP transport.",
+        instruction: "The current execution agent should call this MCP server with its own configured MCP client before invoking Harness. Harness records the configured source but does not implement MCP transport.",
         endpoint: endpointSummary(endpoint),
         suggestedQueries: skill.contextQueries
     };

package/dist/metrics.js

@@ -0,0 +1,91 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathExists } from "./utils.js";
+async function readJson(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function increment(map, key) {
+    map[key] = (map[key] ?? 0) + 1;
+}
+export async function collectRunMetrics(cwd, config) {
+    const runsRoot = path.join(cwd, config.audit.path);
+    const entries = (await pathExists(runsRoot)) ? await readdir(runsRoot, { withFileTypes: true }) : [];
+    const runs = [];
+    for (const entry of entries.filter((item) => item.isDirectory())) {
+        const runDir = path.join(runsRoot, entry.name);
+        const intake = await readJson(path.join(runDir, "intake.json"));
+        const review = await readJson(path.join(runDir, "loop_review.json"));
+        const verify = await readJson(path.join(runDir, "verify.json"));
+        const last = review?.iterations?.at(-1);
+        runs.push({
+            runId: entry.name,
+            skill: intake?.skill,
+            agent: intake?.agent,
+            status: review?.status ?? "unknown",
+            iterations: review?.iterations?.length ?? 0,
+            failureType: last?.failureType ?? "unknown",
+            contractStatus: last?.signals?.contractStatus,
+            verifyStatus: last?.signals?.verifyStatus,
+            contextScore: last?.signals?.contextScoreStatus,
+            approvalRequired: Boolean(last?.signals?.approvalRequired),
+            failedVerifyCommands: verify?.commands?.filter((command) => command.exitCode !== 0).map((command) => command.name) ?? []
+        });
+    }
+    const failureTypes = {};
+    const skillStatus = {};
+    const agentStatus = {};
+    const verifyFailures = {};
+    const contextScores = {};
+    for (const run of runs) {
+        increment(failureTypes, run.failureType);
+        if (run.skill)
+            increment(skillStatus, `${run.skill}:${run.status}`);
+        if (run.agent)
+            increment(agentStatus, `${run.agent}:${run.status}`);
+        for (const command of run.failedVerifyCommands)
+            increment(verifyFailures, command);
+        if (run.contextScore)
+            increment(contextScores, run.contextScore);
+    }
+    const total = runs.length;
+    const passed = runs.filter((run) => run.status === "passed").length;
+    const firstPass = runs.filter((run) => run.status === "passed" && run.iterations === 1).length;
+    const contractPassed = runs.filter((run) => run.contractStatus === "passed").length;
+    const averageIterations = total ? runs.reduce((sum, run) => sum + run.iterations, 0) / total : 0;
+    return {
+        runs,
+        summary: {
+            totalRuns: total,
+            successRate: total ? passed / total : 0,
+            firstPassRate: total ? firstPass / total : 0,
+            agentContractPassRate: total ? contractPassed / total : 0,
+            averageIterations,
+            failureTypes,
+            skillStatus,
+            agentStatus,
+            verifyFailureTopN: Object.fromEntries(Object.entries(verifyFailures).sort((a, b) => b[1] - a[1]).slice(0, 10)),
+            approvalGateCount: runs.filter((run) => run.approvalRequired).length,
+            contextScores
+        }
+    };
+}
+export function renderMetricsText(metrics) {
+    return `运行指标
+- 总运行次数: ${metrics.summary.totalRuns}
+- 成功率: ${Number(metrics.summary.successRate).toFixed(2)}
+- 一次通过率: ${Number(metrics.summary.firstPassRate).toFixed(2)}
+- Agent 契约通过率: ${Number(metrics.summary.agentContractPassRate).toFixed(2)}
+- 平均循环轮次: ${Number(metrics.summary.averageIterations).toFixed(2)}
+- 失败类型分布: ${JSON.stringify(metrics.summary.failureTypes)}
+- Skill 状态: ${JSON.stringify(metrics.summary.skillStatus)}
+- Agent 状态: ${JSON.stringify(metrics.summary.agentStatus)}
+- 验证失败 Top N: ${JSON.stringify(metrics.summary.verifyFailureTopN)}
+- Approval Gate 触发次数: ${metrics.summary.approvalGateCount}
+- Context Score 分布: ${JSON.stringify(metrics.summary.contextScores)}
+`;
+}

package/dist/replay.js

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+export async function buildReplayPlan(runDir, overrideAgent, dry = false) {
+    const intake = JSON.parse(await readFile(path.join(runDir, "intake.json"), "utf8"));
+    const agent = overrideAgent ?? intake.agent;
+    if (agent !== "codex" && agent !== "claude" && agent !== "cursor" && agent !== "gemini") {
+        throw new Error(`历史运行记录中的 agent 无效：${agent}`);
+    }
+    if (!intake.task || !intake.skill)
+        throw new Error(`历史运行记录缺少 task 或 skill：${runDir}`);
+    return {
+        sourceRun: runDir,
+        task: intake.task,
+        skill: intake.skill,
+        agent,
+        dry
+    };
+}
+export function renderReplayPlan(plan) {
+    return `Replay Plan
+- Source run: ${plan.sourceRun}
+- Task: ${plan.task}
+- Skill: ${plan.skill}
+- Agent: ${plan.agent}
+- Dry run: ${plan.dry ? "yes" : "no"}
+`;
+}

package/dist/runPaths.js

@@ -15,8 +15,38 @@ export function makeRunPaths(cwd, config, task) {
         agentContract: path.join(runDir, "agent_contract.json"),
         gitDiff: path.join(runDir, "git_diff.patch"),
         verify: path.join(runDir, "verify.json"),
+        verifyDiagnostics: path.join(runDir, "verify_diagnostics.json"),
+        contextScore: path.join(runDir, "context_score.json"),
+        approvalRequired: path.join(runDir, "approval_required.json"),
+        feedback: path.join(runDir, "feedback.jsonl"),
+        checkpoint: path.join(runDir, "checkpoint.json"),
+        preIterationDiff: path.join(runDir, "pre_iteration_diff.patch"),
+        postIterationDiff: path.join(runDir, "post_iteration_diff.patch"),
         summary: path.join(runDir, "summary.md"),
         persistSuggestions: path.join(runDir, "persist_suggestions.md"),
+        loopReview: path.join(runDir, "loop_review.json"),
+        loopReport: path.join(runDir, "loop_report.md"),
         audit: path.join(runDir, "audit.jsonl")
     };
 }
+export function makeIterationPaths(paths, iteration) {
+    const iterationDir = path.join(paths.runDir, `iteration-${iteration}`);
+    return {
+        iteration,
+        iterationDir,
+        contextPack: path.join(iterationDir, "context_pack.md"),
+        agentPrompt: path.join(iterationDir, "agent_prompt.md"),
+        plan: path.join(iterationDir, "plan.md"),
+        executionLog: path.join(iterationDir, "execution.log"),
+        agentContract: path.join(iterationDir, "agent_contract.json"),
+        gitDiff: path.join(iterationDir, "git_diff.patch"),
+        verify: path.join(iterationDir, "verify.json"),
+        verifyDiagnostics: path.join(iterationDir, "verify_diagnostics.json"),
+        contextScore: path.join(iterationDir, "context_score.json"),
+        approvalRequired: path.join(iterationDir, "approval_required.json"),
+        feedback: path.join(iterationDir, "feedback.jsonl"),
+        checkpoint: path.join(iterationDir, "checkpoint.json"),
+        preIterationDiff: path.join(iterationDir, "pre_iteration_diff.patch"),
+        postIterationDiff: path.join(iterationDir, "post_iteration_diff.patch")
+    };
+}