patchwarden 0.6.4 → 1.5.0

package/dist/controlCenter.js

@@ -12,7 +12,7 @@
  * Port override: PATCHWARDEN_CONTROL_PORT=<n>  or  --port <n>
  */
 import { createServer, get as httpGet } from "node:http";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
@@ -25,6 +25,10 @@ import { readWatcherStatus } from "./watcherStatus.js";
 import { redactSensitiveContent } from "./security/contentRedaction.js";
 import { guardWorkspacePath } from "./security/pathGuard.js";
 import { auditTask } from "./tools/auditTask.js";
+import { getProjectPolicySummary } from "./policy/projectPolicy.js";
+import { safeDirectSummary } from "./tools/safeViews.js";
+import { toSafeTaskLineage } from "./tools/taskLineage.js";
+import { listEvidencePacks, readEvidencePack } from "./tools/evidencePack.js";
 import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "./version.js";
 // ── Paths ─────────────────────────────────────────────────────────
 const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -231,6 +235,26 @@ function readJsonFileSafe(filePath) {
         return null;
     }
 }
+function isPathInside(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function readJsonFileSafeUnder(root, relPath) {
+    const base = resolve(root);
+    const target = resolve(base, relPath);
+    if (!isPathInside(base, target) || !existsSync(target))
+        return null;
+    try {
+        const realBase = realpathSync(base);
+        const realTarget = realpathSync(target);
+        if (!isPathInside(realBase, realTarget))
+            return null;
+        return readJsonFileSafe(realTarget);
+    }
+    catch {
+        return null;
+    }
+}
 function readTextFileSafe(filePath) {
     if (!existsSync(filePath))
         return null;
@@ -419,6 +443,7 @@ function resolveWorkspaceRootSafe() {
 }
 const TERMINAL_TASK_STATUSES = new Set([
     "done",
+    "done_by_agent",
     "failed",
     "failed_verification",
     "failed_scope_violation",
@@ -901,6 +926,105 @@ function handleStaleTasks(res) {
         sendJson(res, 200, { stale_tasks: [], total: 0, reason: errorMessage(err) });
     }
 }
+function handleLineages(res) {
+    try {
+        const root = join(config.workspaceRoot, ".patchwarden", "lineages");
+        if (!existsSync(root)) {
+            sendJson(res, 200, { lineages: [], total: 0, reason: null });
+            return;
+        }
+        const lineages = readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => readJsonFileSafeUnder(root, join(entry.name, "lineage.json")))
+            .filter((entry) => entry !== null)
+            .map((entry) => toSafeTaskLineage(entry, 6))
+            .sort((a, b) => b.updated_at.localeCompare(a.updated_at))
+            .slice(0, 50);
+        sendJson(res, 200, { lineages, total: lineages.length, reason: null });
+    }
+    catch (err) {
+        sendJson(res, 200, { lineages: [], total: 0, reason: errorMessage(err) });
+    }
+}
+function handleLineageDetail(res, lineageId) {
+    try {
+        if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
+            sendJson(res, 400, { error: "Invalid lineage id" });
+            return;
+        }
+        const data = readJsonFileSafeUnder(join(config.workspaceRoot, ".patchwarden", "lineages"), join(lineageId, "lineage.json"));
+        if (!data) {
+            sendJson(res, 404, { error: "Lineage not found" });
+            return;
+        }
+        sendJson(res, 200, toSafeTaskLineage(data, 20));
+    }
+    catch (err) {
+        sendJson(res, 200, { lineage_id: lineageId, error: errorMessage(err) });
+    }
+}
+function handleProjectPolicy(res, repoPath) {
+    try {
+        sendJson(res, 200, getProjectPolicySummary(repoPath || "."));
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            repo_path: repoPath || ".",
+            valid: false,
+            issues: [{ code: "policy_unavailable", severity: "error", field: "repo_path", message: errorMessage(err) }],
+        });
+    }
+}
+function handleReleaseStatus(res, repoPath) {
+    try {
+        const policy = getProjectPolicySummary(repoPath || ".");
+        sendJson(res, 200, {
+            repo_path: repoPath || ".",
+            resolved_repo_path: policy.resolved_repo_path,
+            policy_valid: policy.valid,
+            policy_issue_count: policy.issues.length,
+            policy_issues: policy.issues.slice(0, 10),
+            release_readiness: policy.release_readiness,
+            next_action: policy.valid && policy.release_readiness.version_consistent !== false
+                ? "Run release_check or release_prepare from the full MCP profile when ready."
+                : "Fix project-policy or version consistency issues before release preparation.",
+            remote_write_performed: false,
+        });
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            repo_path: repoPath || ".",
+            policy_valid: false,
+            error: errorMessage(err),
+            remote_write_performed: false,
+        });
+    }
+}
+function handleEvidencePacks(res) {
+    try {
+        sendJson(res, 200, listEvidencePacks({ max_items: 50 }));
+    }
+    catch (err) {
+        sendJson(res, 200, { evidence_packs: [], total: 0, reason: errorMessage(err) });
+    }
+}
+function handleEvidencePackDetail(res, lineageId) {
+    try {
+        if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
+            sendJson(res, 400, { error: "Invalid lineage id" });
+            return;
+        }
+        const pack = readEvidencePack(lineageId);
+        if (!pack) {
+            sendJson(res, 404, { error: "Evidence pack not found" });
+            return;
+        }
+        sendJson(res, 200, pack);
+    }
+    catch (err) {
+        sendJson(res, 200, { lineage_id: lineageId, error: errorMessage(err), bounded: true });
+    }
+}
 /**
  * Reconcile a stale task. Does NOT delete the task. Reads the task files,
  * decides whether it is safe to mark the task as stale/archived, writes a
@@ -928,13 +1052,19 @@ function handleReconcile(res, taskId) {
         const statusData = readJsonFileSafe(statusPath) ?? {};
         const runtimeData = readJsonFileSafe(runtimePath) ?? {};
         const watcher = readWatcherStatusSafe();
+        const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+        const taskStatus = String(statusData.status || "pending");
+        const taskAcceptanceStatus = taskStatus === "done_by_agent"
+            ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE.includes(statusData.acceptance_status) ? statusData.acceptance_status : "pending")
+            : null;
         const taskEntry = {
             task_id: taskId,
             plan_id: String(statusData.plan_id || ""),
             title: "",
             agent: String(statusData.agent || ""),
-            status: String(statusData.status || "pending"),
+            status: taskStatus,
             phase: String(runtimeData.phase || statusData.phase || "queued"),
+            acceptance_status: taskAcceptanceStatus,
             created_at: String(statusData.created_at || ""),
             updated_at: String(statusData.updated_at || ""),
             workspace_root: String(statusData.workspace_root || config.workspaceRoot),
@@ -1072,13 +1202,19 @@ function handleTaskDetail(res, taskId) {
         let stale = null;
         if (statusData) {
             const watcher = readWatcherStatusSafe();
+            const VALID_ACCEPTANCE2 = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+            const taskStatus2 = String(statusData.status || "pending");
+            const taskAcceptanceStatus2 = taskStatus2 === "done_by_agent"
+                ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE2.includes(statusData.acceptance_status) ? statusData.acceptance_status : "pending")
+                : null;
             const entry = {
                 task_id: taskId,
                 plan_id: String(statusData.plan_id || ""),
                 title: "",
                 agent: String(statusData.agent || ""),
-                status: String(statusData.status || "pending"),
+                status: taskStatus2,
                 phase: String(runtimeData?.phase || statusData.phase || "queued"),
+                acceptance_status: taskAcceptanceStatus2,
                 created_at: String(statusData.created_at || ""),
                 updated_at: String(statusData.updated_at || ""),
                 workspace_root: String(statusData.workspace_root || config.workspaceRoot),
@@ -1485,6 +1621,27 @@ function handleDirectSessionDetail(res, sessionId) {
         sendJson(res, 200, { session_id: sessionId, error: errorMessage(err) });
     }
 }
+function handleDirectSessionSafeSummary(res, sessionId) {
+    try {
+        if (sessionId === "." ||
+            sessionId === ".." ||
+            sessionId.includes("/") ||
+            sessionId.includes("\\") ||
+            sessionId.includes("\0")) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        sendJson(res, 200, safeDirectSummary(sessionId, { max_items: 12 }));
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            session_id: sessionId,
+            error: errorMessage(err),
+            large_logs_omitted: true,
+            diff_omitted: true,
+        });
+    }
+}
 function parseReviewVerdict(content) {
     // independent-review.md format: "**Verdict**: PASS" (case-insensitive)
     const m = content.match(/\*\*Verdict\*\*\s*:\s*([A-Za-z]+)/);
@@ -1774,6 +1931,46 @@ async function handleRequest(req, res) {
         handleStaleTasks(res);
         return;
     }
+    if (method === "GET" && pathname === "/api/lineages") {
+        handleLineages(res);
+        return;
+    }
+    const lineageMatch = pathname.match(/^\/api\/lineages\/([^/]+)$/);
+    if (method === "GET" && lineageMatch) {
+        let lineageId;
+        try {
+            lineageId = decodeURIComponent(lineageMatch[1]);
+        }
+        catch {
+            lineageId = lineageMatch[1];
+        }
+        handleLineageDetail(res, lineageId);
+        return;
+    }
+    if (method === "GET" && pathname === "/api/project-policy") {
+        handleProjectPolicy(res, parsedUrl.searchParams.get("repo_path") || ".");
+        return;
+    }
+    if (method === "GET" && pathname === "/api/release/status") {
+        handleReleaseStatus(res, parsedUrl.searchParams.get("repo_path") || ".");
+        return;
+    }
+    if (method === "GET" && pathname === "/api/evidence-packs") {
+        handleEvidencePacks(res);
+        return;
+    }
+    const evidencePackMatch = pathname.match(/^\/api\/evidence-packs\/([^/]+)$/);
+    if (method === "GET" && evidencePackMatch) {
+        let lineageId;
+        try {
+            lineageId = decodeURIComponent(evidencePackMatch[1]);
+        }
+        catch {
+            lineageId = evidencePackMatch[1];
+        }
+        handleEvidencePackDetail(res, lineageId);
+        return;
+    }
     const taskMatch = pathname.match(/^\/api\/tasks\/([^/]+)$/);
     if (method === "GET" && taskMatch) {
         let taskId;
@@ -1832,6 +2029,18 @@ async function handleRequest(req, res) {
         handleDirectSessions(res);
         return;
     }
+    const directSessionSummaryMatch = pathname.match(/^\/api\/direct-sessions\/([^/]+)\/summary$/);
+    if (method === "GET" && directSessionSummaryMatch) {
+        let sessionId;
+        try {
+            sessionId = decodeURIComponent(directSessionSummaryMatch[1]);
+        }
+        catch {
+            sessionId = directSessionSummaryMatch[1];
+        }
+        handleDirectSessionSafeSummary(res, sessionId);
+        return;
+    }
     const directSessionMatch = pathname.match(/^\/api\/direct-sessions\/([^/]+)$/);
     if (method === "GET" && directSessionMatch) {
         let sessionId;

package/dist/direct/directSessionStore.d.ts

@@ -13,6 +13,8 @@ export interface DirectSessionVerificationRun {
     exit_code: number | null;
     passed: boolean;
     timed_out: boolean;
+    redacted?: boolean;
+    redaction_categories?: string[];
     stdout_tail: string;
     stderr_tail: string;
     started_at: string;

package/dist/direct/directVerification.js

@@ -40,6 +40,13 @@ export async function runDirectVerification(input) {
         exit_code: result.exitCode,
         passed,
         timed_out: result.timedOut,
+        redacted: stdoutRedacted.redacted || stderrRedacted.redacted,
+        redaction_categories: [
+            ...new Set([
+                ...stdoutRedacted.redaction_categories,
+                ...stderrRedacted.redaction_categories,
+            ]),
+        ],
         stdout_tail: stdoutTail,
         stderr_tail: stderrTail,
         started_at: startedAt,

package/dist/doctor.js

@@ -18,6 +18,9 @@ import { guardPlanContent } from "./security/planGuard.js";
 import { TASK_READ_ONLY_FILES } from "./tools/getTaskFile.js";
 import { getToolDefs } from "./tools/registry.js";
 import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, selectToolsForProfile } from "./tools/toolCatalog.js";
+import { buildToolRegistry } from "./tools/toolRegistry.js";
+import { runAllSchemaDriftChecks } from "./tools/schemaDriftCheck.js";
+import { runReleaseGateCheck } from "./release/releaseGate.js";
 import { PATCHWARDEN_VERSION } from "./version.js";
 // ── State ──────────────────────────────────────────────────────────
 let ok = 0;
@@ -218,7 +221,7 @@ async function main() {
         const coreTools = selectToolsForProfile(fullTools, "chatgpt_core", config?.enableDirectProfile);
         const createSchema = coreTools.find((tool) => tool.name === "create_task")?.inputSchema;
         const waitSchema = coreTools.find((tool) => tool.name === "wait_for_task")?.inputSchema;
-        check("Full tool profile exposes 30 tools", fullTools.length === 30, `${fullTools.length} tools`);
+        check("Full tool profile exposes 64 tools", fullTools.length === 64, `${fullTools.length} tools`);
         check(`chatgpt_core profile exposes the exact ${CHATGPT_CORE_TOOL_NAMES.length}-tool manifest`, JSON.stringify(coreTools.map((tool) => tool.name)) === JSON.stringify(CHATGPT_CORE_TOOL_NAMES), coreTools.map((tool) => tool.name).join(", "));
         check("Core task schemas expose inline_plan, verify_commands, and wait aliases", Boolean(createSchema?.properties?.inline_plan &&
             createSchema?.properties?.verify_commands &&
@@ -235,6 +238,25 @@ async function main() {
             results.push(`[OK]   chatgpt_direct enabled check skipped (enableDirectProfile=false)`);
             ok++;
         }
+        // 16. Schema drift 检查（v0.9.0）—— warn 级别，不阻断 doctor:ci
+        // 用 fullTools 同时构建 registry 和 toolDefs Map，确保 schema digest 比对基准一致。
+        const driftRegistry = buildToolRegistry(fullTools);
+        const driftToolDefs = new Map();
+        for (const tool of fullTools) {
+            driftToolDefs.set(tool.name, { inputSchema: tool.inputSchema });
+        }
+        const driftResult = runAllSchemaDriftChecks(driftRegistry, driftToolDefs);
+        if (driftResult.ok) {
+            results.push(`[OK]   Schema drift check — no drift detected`);
+            ok++;
+        }
+        else {
+            // 每个 warning 单独输出为 WARN，与其他自检项的多警告模式一致
+            for (const w of driftResult.warnings) {
+                results.push(`[WARN] Schema drift: ${w}`);
+                warn++;
+            }
+        }
     }
     finally {
         if (previousProfile === undefined)
@@ -242,6 +264,15 @@ async function main() {
         else
             process.env.PATCHWARDEN_TOOL_PROFILE = previousProfile;
     }
+    // 17. Release gate module loadable (v1.0.0) — module integrity only.
+    // Does NOT execute local_ready (would recurse into doctor:ci).
+    try {
+        const releaseGateReady = typeof runReleaseGateCheck === "function";
+        check("Release gate module loadable", releaseGateReady, releaseGateReady ? "runReleaseGateCheck exported" : "runReleaseGateCheck missing or invalid");
+    }
+    catch (error) {
+        check("Release gate module loadable", false, error instanceof Error ? error.message : String(error));
+    }
     // 9. HTTP port check
     const httpPort = config?.http?.port || 7331;
     try {

package/dist/goal/acceptanceEngine.d.ts

@@ -0,0 +1,62 @@
+/**
+ * v0.7.2: 验收引擎 — 基于证据推导 4 级验收结论。
+ *
+ * 输入：status.json、task_meta（goal/scope/forbidden/verification/done_evidence）、
+ *       audit checks（pass/warn/fail）、release claims、artifact 信息
+ * 输出：ACCEPTED / NEEDS_FIX / REJECTED / BLOCKED_BY_APPROVAL
+ *       + reasons + required_evidence + next_suggested_task
+ *
+ * 决策规则：
+ *   1. 存在 fail 级检查项 → REJECTED
+ *   2. 存在 release claims 但无法验证远端 → BLOCKED_BY_APPROVAL
+ *   3. 存在 warn 级检查项或文档不同步 → NEEDS_FIX
+ *   4. 所有检查通过 → ACCEPTED
+ */
+import type { AcceptanceStatus } from "../tools/createTask.js";
+export type AcceptanceVerdict = "ACCEPTED" | "NEEDS_FIX" | "REJECTED" | "BLOCKED_BY_APPROVAL";
+export interface AcceptanceCheck {
+    name: string;
+    result: "pass" | "warn" | "fail";
+    detail: string;
+}
+export interface AcceptanceEvidence {
+    task_id: string;
+    task_status: string;
+    result_md_exists: boolean;
+    result_json_exists: boolean;
+    verify_json_exists: boolean;
+    test_log_exists: boolean;
+    git_diff_exists: boolean;
+    verify_status: "passed" | "failed" | "skipped" | null;
+    new_out_of_scope_changes: Array<{
+        path: string;
+        change: string;
+    }>;
+    goal: string | null;
+    scope: string[] | null;
+    forbidden: string[] | null;
+    verification: string[] | null;
+    done_evidence: string[] | null;
+    artifact_status: string | null;
+    release_claims_unverified: boolean;
+    checks: AcceptanceCheck[];
+}
+export interface AcceptanceResult {
+    verdict: AcceptanceVerdict;
+    acceptance_status: AcceptanceStatus;
+    reason: string;
+    reasons: string[];
+    required_evidence: string[];
+    next_suggested_task: string;
+    fail_checks: AcceptanceCheck[];
+    warn_checks: AcceptanceCheck[];
+}
+/**
+ * 核心验收决策函数。
+ * 输入所有证据，输出 4 级验收结论。
+ */
+export declare function evaluateAcceptance(evidence: AcceptanceEvidence): AcceptanceResult;
+/**
+ * 将 AcceptanceVerdict 映射到 AcceptanceStatus（用于回写 status.json）。
+ */
+export declare function verdictToStatus(verdict: AcceptanceVerdict): AcceptanceStatus;

package/dist/goal/acceptanceEngine.js

@@ -0,0 +1,103 @@
+/**
+ * v0.7.2: 验收引擎 — 基于证据推导 4 级验收结论。
+ *
+ * 输入：status.json、task_meta（goal/scope/forbidden/verification/done_evidence）、
+ *       audit checks（pass/warn/fail）、release claims、artifact 信息
+ * 输出：ACCEPTED / NEEDS_FIX / REJECTED / BLOCKED_BY_APPROVAL
+ *       + reasons + required_evidence + next_suggested_task
+ *
+ * 决策规则：
+ *   1. 存在 fail 级检查项 → REJECTED
+ *   2. 存在 release claims 但无法验证远端 → BLOCKED_BY_APPROVAL
+ *   3. 存在 warn 级检查项或文档不同步 → NEEDS_FIX
+ *   4. 所有检查通过 → ACCEPTED
+ */
+// ── 验收决策 ──────────────────────────────────────────────────────
+/**
+ * 核心验收决策函数。
+ * 输入所有证据，输出 4 级验收结论。
+ */
+export function evaluateAcceptance(evidence) {
+    const reasons = [];
+    const requiredEvidence = [];
+    const failChecks = [];
+    const warnChecks = [];
+    // 收集 fail 和 warn 检查项
+    for (const check of evidence.checks) {
+        if (check.result === "fail") {
+            failChecks.push(check);
+        }
+        else if (check.result === "warn") {
+            warnChecks.push(check);
+        }
+    }
+    // ── Rule 1: fail 级检查项 → REJECTED ──────────────────────
+    if (failChecks.length > 0) {
+        for (const check of failChecks) {
+            reasons.push(`[FAIL] ${check.name}: ${check.detail}`);
+        }
+        return {
+            verdict: "REJECTED",
+            acceptance_status: "rejected",
+            reason: `${failChecks.length} fail-level check(s): ${failChecks.map((c) => c.name).join(", ")}`,
+            reasons,
+            required_evidence: requiredEvidence.length > 0 ? requiredEvidence : ["Fix all fail-level issues and re-run audit_task"],
+            next_suggested_task: `Fix fail-level issues: ${failChecks.map((c) => c.name).join(", ")}`,
+            fail_checks: failChecks,
+            warn_checks: warnChecks,
+        };
+    }
+    // ── Rule 2: release claims 无法验证 → BLOCKED_BY_APPROVAL ──
+    if (evidence.release_claims_unverified) {
+        reasons.push("[BLOCKED] Release claims detected but remote state cannot be verified");
+        requiredEvidence.push("Verify remote release state (npm publish, GitHub release, git tag)");
+        return {
+            verdict: "BLOCKED_BY_APPROVAL",
+            acceptance_status: "blocked",
+            reason: "Release claims require manual verification of remote state",
+            reasons,
+            required_evidence: requiredEvidence,
+            next_suggested_task: "Manually verify remote release state, then re-run audit_task",
+            fail_checks: failChecks,
+            warn_checks: warnChecks,
+        };
+    }
+    // ── Rule 3: warn 级检查项 → NEEDS_FIX ──────────────────────
+    if (warnChecks.length > 0) {
+        for (const check of warnChecks) {
+            reasons.push(`[WARN] ${check.name}: ${check.detail}`);
+        }
+        return {
+            verdict: "NEEDS_FIX",
+            acceptance_status: "needs_fix",
+            reason: `${warnChecks.length} warn-level check(s) require fixes: ${warnChecks.map((c) => c.name).join(", ")}`,
+            reasons,
+            required_evidence: requiredEvidence.length > 0 ? requiredEvidence : ["Resolve all warn-level issues"],
+            next_suggested_task: `Fix warn-level issues: ${warnChecks.map((c) => c.name).join(", ")}`,
+            fail_checks: failChecks,
+            warn_checks: warnChecks,
+        };
+    }
+    // ── Rule 4: 所有检查通过 → ACCEPTED ───────────────────────
+    return {
+        verdict: "ACCEPTED",
+        acceptance_status: "accepted",
+        reason: "All acceptance checks passed",
+        reasons: ["All checks passed, no warnings or failures"],
+        required_evidence: [],
+        next_suggested_task: "Task accepted. Proceed to next goal or task.",
+        fail_checks: failChecks,
+        warn_checks: warnChecks,
+    };
+}
+/**
+ * 将 AcceptanceVerdict 映射到 AcceptanceStatus（用于回写 status.json）。
+ */
+export function verdictToStatus(verdict) {
+    switch (verdict) {
+        case "ACCEPTED": return "accepted";
+        case "REJECTED": return "rejected";
+        case "NEEDS_FIX": return "needs_fix";
+        case "BLOCKED_BY_APPROVAL": return "blocked";
+    }
+}

package/dist/goal/acceptanceTemplate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * v0.7.2: ACCEPTANCE.md 模板生成 — 人类可读的验收报告导出。
+ *
+ * 将 AcceptanceResult 渲染为 Markdown，落盘到 .patchwarden/tasks/{task_id}/ACCEPTANCE.md。
+ */
+import type { AcceptanceResult, AcceptanceEvidence } from "./acceptanceEngine.js";
+/**
+ * 生成 ACCEPTANCE.md 内容。
+ */
+export declare function renderAcceptanceMarkdown(taskId: string, result: AcceptanceResult, evidence: AcceptanceEvidence): string;

package/dist/goal/acceptanceTemplate.js

@@ -0,0 +1,104 @@
+/**
+ * v0.7.2: ACCEPTANCE.md 模板生成 — 人类可读的验收报告导出。
+ *
+ * 将 AcceptanceResult 渲染为 Markdown，落盘到 .patchwarden/tasks/{task_id}/ACCEPTANCE.md。
+ */
+import { PATCHWARDEN_VERSION } from "../version.js";
+/**
+ * 生成 ACCEPTANCE.md 内容。
+ */
+export function renderAcceptanceMarkdown(taskId, result, evidence) {
+    const lines = [];
+    const now = new Date().toISOString();
+    lines.push("# Acceptance Report — " + taskId);
+    lines.push("");
+    lines.push("Generated: " + now);
+    lines.push("");
+    // ── Verdict ──────────────────────────────────────────────
+    lines.push("## Verdict");
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("| --- | --- |");
+    lines.push("| Verdict | **" + result.verdict + "** |");
+    lines.push("| Acceptance Status | " + (result.acceptance_status ?? "null") + " |");
+    lines.push("| Reason | " + result.reason + " |");
+    lines.push("| Next Suggested Task | " + result.next_suggested_task + " |");
+    lines.push("");
+    // ── Evidence Summary ────────────────────────────────────
+    lines.push("## Evidence Summary");
+    lines.push("");
+    lines.push("| Evidence | Present |");
+    lines.push("| --- | --- |");
+    lines.push("| result.md | " + (evidence.result_md_exists ? "YES" : "NO") + " |");
+    lines.push("| result.json | " + (evidence.result_json_exists ? "YES" : "NO") + " |");
+    lines.push("| verify.json | " + (evidence.verify_json_exists ? "YES" : "NO") + " |");
+    lines.push("| test.log | " + (evidence.test_log_exists ? "YES" : "NO") + " |");
+    lines.push("| git.diff | " + (evidence.git_diff_exists ? "YES" : "NO") + " |");
+    lines.push("| verify_status | " + (evidence.verify_status ?? "N/A") + " |");
+    lines.push("| artifact_status | " + (evidence.artifact_status ?? "N/A") + " |");
+    lines.push("| out_of_scope_changes | " + evidence.new_out_of_scope_changes.length + " |");
+    lines.push("| release_claims_unverified | " + (evidence.release_claims_unverified ? "YES" : "NO") + " |");
+    lines.push("");
+    // ── Task Metadata ────────────────────────────────────────
+    if (evidence.goal || evidence.scope || evidence.forbidden || evidence.verification || evidence.done_evidence) {
+        lines.push("## Task Acceptance Criteria");
+        lines.push("");
+        if (evidence.goal) {
+            lines.push("- **Goal**: " + evidence.goal);
+        }
+        if (evidence.scope && evidence.scope.length > 0) {
+            lines.push("- **Scope**: " + evidence.scope.join(", "));
+        }
+        if (evidence.forbidden && evidence.forbidden.length > 0) {
+            lines.push("- **Forbidden**: " + evidence.forbidden.join(", "));
+        }
+        if (evidence.verification && evidence.verification.length > 0) {
+            lines.push("- **Verification**: " + evidence.verification.join(", "));
+        }
+        if (evidence.done_evidence && evidence.done_evidence.length > 0) {
+            lines.push("- **Done Evidence**: " + evidence.done_evidence.join(", "));
+        }
+        lines.push("");
+    }
+    // ── Fail Checks ─────────────────────────────────────────
+    if (result.fail_checks.length > 0) {
+        lines.push("## Fail-Level Checks");
+        lines.push("");
+        for (const check of result.fail_checks) {
+            lines.push("- **" + check.name + "**: " + check.detail);
+        }
+        lines.push("");
+    }
+    // ── Warn Checks ─────────────────────────────────────────
+    if (result.warn_checks.length > 0) {
+        lines.push("## Warn-Level Checks");
+        lines.push("");
+        for (const check of result.warn_checks) {
+            lines.push("- **" + check.name + "**: " + check.detail);
+        }
+        lines.push("");
+    }
+    // ── Reasons ─────────────────────────────────────────────
+    if (result.reasons.length > 0) {
+        lines.push("## Reasons");
+        lines.push("");
+        for (const reason of result.reasons) {
+            lines.push("- " + reason);
+        }
+        lines.push("");
+    }
+    // ── Required Evidence ────────────────────────────────────
+    if (result.required_evidence.length > 0) {
+        lines.push("## Required Evidence");
+        lines.push("");
+        for (const reqEvidence of result.required_evidence) {
+            lines.push("- " + reqEvidence);
+        }
+        lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push("This report was generated by PatchWarden v" + PATCHWARDEN_VERSION + " acceptanceEngine.");
+    lines.push("");
+    return lines.join("\n");
+}