ai-dev-harness 0.1.0 → 0.1.2

package/dist/integration.js

@@ -1,16 +1,17 @@
 import path from "node:path";
-import { appendFile, copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { readTemplateFile, renderTemplate } from "./templates.js";
 import { pathExists } from "./utils.js";
 export async function installIntegration(options) {
     const created = [];
     const updated = [];
     const skipped = [];
-    const scriptResult = await installScriptAssets(options.targetDir, options.packageRoot ?? process.cwd());
+    const scriptResult = await installScriptAssets(options.targetDir, options.packageRoot ?? process.cwd(), options.harnessCliPath);
     created.push(...scriptResult.created);
     updated.push(...scriptResult.updated);
     skipped.push(...scriptResult.skipped);
-    if (options.agent === "claude" || options.agent === "both") {
-        const result = await installClaudeSkill(options.targetDir, options.harnessCommand);
+    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");
         else if (result === "updated")
@@ -18,8 +19,8 @@ export async function installIntegration(options) {
         else
             skipped.push(".claude/skills/ai-dev-harness/SKILL.md");
     }
-    if (options.agent === "codex" || options.agent === "both") {
-        const result = await installCodexRules(options.targetDir, options.harnessCommand);
+    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");
         else if (result === "updated")
@@ -27,9 +28,27 @@ 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) {
+async function installScriptAssets(targetDir, packageRoot, harnessCliPath) {
     const created = [];
     const updated = [];
     const skipped = [];
@@ -42,7 +61,8 @@ async function installScriptAssets(targetDir, packageRoot) {
         const rel = path.join(".harness", "ai-dev-harness", "scripts", asset);
         if (!(await pathExists(source)))
             continue;
-        const next = await readFile(source, "utf8");
+        const raw = await readFile(source, "utf8");
+        const next = renderTemplate(raw, { HARNESS_CLI_PATH: harnessCliPath ?? "{{HARNESS_CLI_PATH}}" });
         if (await pathExists(target)) {
             const current = await readFile(target, "utf8");
             if (current === next) {
@@ -53,28 +73,28 @@ async function installScriptAssets(targetDir, packageRoot) {
             updated.push(rel);
             continue;
         }
-        await copyFile(source, target);
+        await writeFile(target, next, "utf8");
         created.push(rel);
     }
     return { created, updated, skipped };
 }
-async function installClaudeSkill(targetDir, harnessCommand) {
+async function installClaudeSkill(targetDir, harnessCommand, packageRoot) {
     const skillPath = path.join(targetDir, ".claude", "skills", "ai-dev-harness", "SKILL.md");
     await mkdir(path.dirname(skillPath), { recursive: true });
     if (await pathExists(skillPath)) {
         const current = await readFile(skillPath, "utf8");
-        const next = claudeSkill(harnessCommand);
+        const next = await claudeSkill(harnessCommand, packageRoot);
         if (current === next)
             return "skipped";
         await writeFile(skillPath, next, "utf8");
         return "updated";
     }
-    await writeFile(skillPath, claudeSkill(harnessCommand), "utf8");
+    await writeFile(skillPath, await claudeSkill(harnessCommand, packageRoot), "utf8");
     return "created";
 }
-async function installCodexRules(targetDir, harnessCommand) {
+async function installCodexRules(targetDir, harnessCommand, packageRoot) {
     const agentsPath = path.join(targetDir, "AGENTS.md");
-    const block = codexBlock(harnessCommand);
+    const block = await codexBlock(harnessCommand, packageRoot);
     if (!(await pathExists(agentsPath))) {
         await writeFile(agentsPath, `# Project Agent Rules\n\n${block}`, "utf8");
         return "created";
@@ -90,84 +110,55 @@ async function installCodexRules(targetDir, harnessCommand) {
     await appendFile(agentsPath, `\n\n${block}`, "utf8");
     return "updated";
 }
-function claudeSkill(harnessCommand) {
-    return `---
-name: ai-dev-harness
-description: Trigger the auditable AI Dev Harness CLI from Claude Code conversations and stream the Harness process in the current chat.
----
-
-# AI Dev Harness
-
-Use this skill when the user asks to use Harness, AI Dev Harness, an audited run, CodeGraph/Knowledge Graph context, or one of these skills: \`fix_bug\`, \`add_feature\`, \`write_tests\`, \`update_docs\`.
-
-## Command
-
-Run from the repository root:
-
-\`\`\`bash
-powershell -ExecutionPolicy Bypass -File ".harness/ai-dev-harness/scripts/run-harness.ps1" -Task "<task>" -Skill <skill> -Agent claude -Live
-\`\`\`
-
-Fallback direct command:
-
-\`\`\`bash
-${harnessCommand} run --task "<task>" --skill <skill> --agent claude --live
-\`\`\`
-
-## Skill Mapping
-
-- Defect or regression: \`fix_bug\`
-- Scoped feature: \`add_feature\`
-- Add or improve tests: \`write_tests\`
-- Read-only analysis or docs: \`update_docs\`
-
-For read-only analysis, include "Do not modify repository files" in the task.
-
-## Reporting
-
-After the command finishes, inspect and report:
-
-- Evidence directory printed by Harness
-- \`summary.md\`
-- \`verify.json\`
-- \`audit.jsonl\`
-- MCP degradation errors, if present
-
-You may use:
-
-\`\`\`bash
-powershell -ExecutionPolicy Bypass -File ".harness/ai-dev-harness/scripts/read-evidence.ps1" -Run <run_id_or_path>
-\`\`\`
-
-Do not bypass Harness for implementation tasks unless the user explicitly asks for direct manual work.
-`;
+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
+    });
+}
+async function codexBlock(harnessCommand, packageRoot) {
+    return renderTemplate(await readTemplateFile(path.join("integrations", "codex", "AGENTS_BLOCK.md"), 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
+    });
 }
-function codexBlock(harnessCommand) {
-    return `## AI Dev Harness
-
-Use the AI Dev Harness CLI when the user asks for Harness, an audited run, CodeGraph/Knowledge Graph assisted work, or one of these skills:
-
-- \`fix_bug\`
-- \`add_feature\`
-- \`write_tests\`
-- \`update_docs\`
-
-Run from the repository root:
-
-\`\`\`bash
-powershell -ExecutionPolicy Bypass -File ".harness/ai-dev-harness/scripts/run-harness.ps1" -Task "<task>" -Skill <skill> -Agent codex -Live
-\`\`\`
-
-Fallback direct command:
-
-\`\`\`bash
-${harnessCommand} run --task "<task>" --skill <skill> --agent codex --live
-\`\`\`
-
-For read-only analysis, include "Do not modify repository files" in the task and usually use \`update_docs\`.
-
-After every Harness run, report the evidence directory, inspect \`summary.md\`, \`verify.json\`, and \`audit.jsonl\`, and report MCP degradation errors if present.
-Use \`.harness/ai-dev-harness/scripts/read-evidence.ps1\` to print the evidence summary when useful.
-Do not write directly to Knowledge Graph in v1; use \`persist_suggestions.md\`.
-`;
+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

@@ -1,49 +1,25 @@
 import { appendFile } from "node:fs/promises";
-import { truncate } from "./utils.js";
-async function postJson(url, body, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const response = await fetch(url, {
-            method: "POST",
-            headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
-            body: JSON.stringify(body),
-            signal: controller.signal
-        });
-        const text = await response.text();
-        if (!response.ok)
-            throw new Error(`HTTP ${response.status}: ${truncate(text, 1000)}`);
-        return parseMcpResponse(text, response.headers.get("content-type") ?? "");
-    }
-    finally {
-        clearTimeout(timer);
-    }
+function endpointSummary(endpoint) {
+    return {
+        type: endpoint.type ?? "http",
+        url: endpoint.url,
+        headerNames: Object.keys(endpoint.headers ?? {})
+    };
 }
-function parseMcpResponse(text, contentType) {
-    if (contentType.includes("text/event-stream")) {
-        const dataLines = text
-            .split(/\r?\n/)
-            .filter((line) => line.startsWith("data:"))
-            .map((line) => line.slice(5).trim())
-            .filter((line) => line && line !== "[DONE]");
-        return dataLines.map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return line;
-            }
-        });
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-function summarize(data) {
-    return truncate(typeof data === "string" ? data : JSON.stringify(data, null, 2), 6000);
+function agentDrivenResult(source, endpoint, skill) {
+    const request = {
+        mode: "agent-driven",
+        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
+    };
+    return {
+        source,
+        ok: true,
+        request,
+        responseSummary: `${source} is configured as an agent-driven MCP context source.`,
+        data: request
+    };
 }
 export class CodeGraphSource {
     config;
@@ -52,41 +28,10 @@ export class CodeGraphSource {
         this.config = config;
         this.queryLogPath = queryLogPath;
     }
-    async getImpactContext(task, skill, changedFiles) {
-        const request = {
-            type: "codegraph.impact",
-            task,
-            skill: skill.name,
-            queries: skill.contextQueries,
-            changedFiles
-        };
-        return this.query("codegraph", this.config.mcp.codegraph.url, request);
-    }
-    async query(source, url, request) {
-        try {
-            const data = await postJson(url, request, this.config.mcp.timeoutMs);
-            const result = {
-                source,
-                ok: true,
-                degraded: false,
-                request,
-                responseSummary: summarize(data),
-                data
-            };
-            await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
-            return result;
-        }
-        catch (error) {
-            const result = {
-                source,
-                ok: false,
-                degraded: true,
-                request,
-                error: error instanceof Error ? error.message : String(error)
-            };
-            await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
-            return result;
-        }
+    async getImpactContext(_task, skill) {
+        const result = agentDrivenResult("codegraph", this.config.mcp.codegraph, skill);
+        await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
+        return result;
     }
 }
 export class KnowledgeGraphSource {
@@ -96,38 +41,10 @@ export class KnowledgeGraphSource {
         this.config = config;
         this.queryLogPath = queryLogPath;
     }
-    async searchKnowledge(task, skill, codeContext) {
-        const request = {
-            type: "knowledge.search",
-            task,
-            skill: skill.name,
-            queries: skill.contextQueries,
-            codeContext
-        };
-        try {
-            const data = await postJson(this.config.mcp.knowledgeGraph.url, request, this.config.mcp.timeoutMs);
-            const result = {
-                source: "knowledgeGraph",
-                ok: true,
-                degraded: false,
-                request,
-                responseSummary: summarize(data),
-                data
-            };
-            await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
-            return result;
-        }
-        catch (error) {
-            const result = {
-                source: "knowledgeGraph",
-                ok: false,
-                degraded: true,
-                request,
-                error: error instanceof Error ? error.message : String(error)
-            };
-            await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
-            return result;
-        }
+    async searchKnowledge(_task, skill) {
+        const result = agentDrivenResult("knowledgeGraph", this.config.mcp.knowledgeGraph, skill);
+        await appendFile(this.queryLogPath, `${JSON.stringify(result)}\n`, "utf8");
+        return result;
     }
 }
 export class ContextSource {
@@ -139,7 +56,7 @@ export class ContextSource {
     }
     async searchTaskContext(task, skill) {
         const codeContext = await this.codeGraph.getImpactContext(task, skill);
-        const knowledgeContext = await this.knowledgeGraph.searchKnowledge(task, skill, codeContext.data ?? codeContext.error);
+        const knowledgeContext = await this.knowledgeGraph.searchKnowledge(task, skill);
         return { codeContext, knowledgeContext };
     }
 }

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