coding-agent-harness 1.0.4 → 1.0.6

package/dist/lib/preset-resource-contracts.mjs

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+// @ts-ignore core-shared remains a JS runtime dependency until its migration PR.
+import { readFileSafe, toPosix } from "./core-shared.mjs";
+export function validatePresetResourcesForTask(target, task, presetPackage) {
+    const failures = [];
+    const taskRelativePath = String(task.path || "").replace(/^TARGET:/, "").replace(/^\/+/, "");
+    if (!taskRelativePath)
+        return failures;
+    const taskDir = path.join(target.projectRoot, taskRelativePath);
+    const referenceIndex = readFileSafe(path.join(taskDir, "references/INDEX.md"));
+    const referenceRows = parseMarkdownRows(referenceIndex, ["ID", "Path"]);
+    const artifactIndex = readFileSafe(path.join(taskDir, "artifacts/INDEX.md"));
+    const artifactRows = parseMarkdownRows(artifactIndex, ["ID", "Path"]);
+    const taskPlan = task.taskPlanPath ? readFileSafe(path.join(target.projectRoot, String(task.taskPlanPath).replace(/^TARGET:/, "").replace(/^\/+/, ""))) : "";
+    const requiredReadRows = parseMarkdownRows(taskPlan, ["Reference", "Path"]);
+    const expectedReferencePaths = new Map();
+    for (const resource of Object.values(presetPackage.resources?.references || {})) {
+        const relativePath = toPosix(path.join(taskRelativePath, resource.path));
+        expectedReferencePaths.set(resource.index.id, `TARGET:${relativePath}`);
+        if (!fs.existsSync(path.join(target.projectRoot, relativePath))) {
+            failures.push(`${task.path} ${task.taskPreset} preset resource missing: TARGET:${relativePath}`);
+        }
+        if (!hasIndexedResource(referenceRows, resource.index.id, `TARGET:${relativePath}`)) {
+            failures.push(`${task.path} ${task.taskPreset} preset reference index missing ${resource.index.id}`);
+        }
+    }
+    for (const resource of Object.values(presetPackage.resources?.artifacts || {})) {
+        const relativePath = toPosix(path.join(taskRelativePath, resource.path));
+        if (!fs.existsSync(path.join(target.projectRoot, relativePath))) {
+            failures.push(`${task.path} ${task.taskPreset} preset resource missing: TARGET:${relativePath}`);
+        }
+        if (!hasIndexedResource(artifactRows, resource.index.id, `TARGET:${relativePath}`)) {
+            failures.push(`${task.path} ${task.taskPreset} preset artifact index missing ${resource.index.id}`);
+        }
+    }
+    for (const requiredRead of presetPackage.context?.requiredReads || []) {
+        const expectedPath = expectedReferencePaths.get(requiredRead);
+        if (!referenceRows.some((row) => row.ID === requiredRead && (!expectedPath || row.Path === expectedPath))) {
+            failures.push(`${task.path} ${task.taskPreset} preset required read missing from references index: ${requiredRead}`);
+        }
+        if (!requiredReadRows.some((row) => row.Reference === requiredRead && (!expectedPath || row.Path === expectedPath))) {
+            failures.push(`${task.path} ${task.taskPreset} preset required read missing from task plan: ${requiredRead}`);
+        }
+    }
+    return failures;
+}
+function hasIndexedResource(rows, id, expectedPath) {
+    return rows.some((row) => row.ID === id && row.Path === expectedPath);
+}
+function parseMarkdownRows(markdown, requiredColumns) {
+    const rows = [];
+    const lines = String(markdown || "").split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        const next = lines[index + 1]?.trim() || "";
+        if (!isTableRow(line) || !isTableSeparator(next))
+            continue;
+        const header = splitTableRow(line);
+        if (!requiredColumns.every((column) => header.includes(column)))
+            continue;
+        index += 2;
+        while (index < lines.length && isTableRow(lines[index].trim())) {
+            const cells = splitTableRow(lines[index].trim());
+            if (cells.length === header.length)
+                rows.push(Object.fromEntries(header.map((column, cellIndex) => [column, cells[cellIndex] || ""])));
+            index += 1;
+        }
+        index -= 1;
+    }
+    return rows;
+}
+function isTableRow(line) {
+    return line.startsWith("|") && line.endsWith("|");
+}
+function isTableSeparator(line) {
+    if (!isTableRow(line))
+        return false;
+    return splitTableRow(line).every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function splitTableRow(line) {
+    return line.slice(1, -1).split("|").map((cell) => cell.trim());
+}

package/dist/lib/review-confirm-git-gate.mjs

@@ -0,0 +1,244 @@
+import path from "node:path";
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+// @ts-ignore core-shared remains a JS runtime dependency until its migration PR.
+import { toPosix } from "./core-shared.mjs";
+export class ReviewConfirmGitGateError extends Error {
+    code;
+    status;
+    details;
+    recovery;
+    constructor(message, { code = "review-confirm-git-gate-failed", status = 409, details = {}, recovery = [] } = {}) {
+        super(message);
+        this.name = "ReviewConfirmGitGateError";
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.recovery = recovery;
+    }
+}
+export function prepareReviewConfirmGitGate(projectRoot, allowedFilesAbs) {
+    const root = path.resolve(projectRoot);
+    const resolvedGitRoot = requireGitRoot(root);
+    if (real(resolvedGitRoot) !== real(root)) {
+        throw new ReviewConfirmGitGateError("Target must be the Git repository root for review confirmation auto-commit.", {
+            code: "git-root-mismatch",
+            details: { targetRoot: root, gitRoot: resolvedGitRoot },
+            recovery: [
+                "Run review-confirm from the repository root for the target task.",
+                "For private harness tasks, run against the private harness repository root, not the public parent.",
+            ],
+        });
+    }
+    const gitRoot = root;
+    const allowedPaths = allowedFilesAbs.map((filePath) => toPosix(path.relative(gitRoot, path.resolve(filePath))));
+    assertAllowedPaths(allowedPaths);
+    assertCleanWorkingTree(gitRoot);
+    assertCommitIdentity(gitRoot);
+    return { gitRoot, allowedPaths };
+}
+export function commitReviewConfirmationGate(gate, { taskId, reviewPath, writeFinalAudit, message = "" }) {
+    const subjectSuffix = taskId.replace(/[^A-Za-z0-9._/-]+/g, "-");
+    assertOnlyAllowedChanged(gate.gitRoot, gate.allowedPaths);
+    git(gate.gitRoot, ["add", "--", ...gate.allowedPaths]);
+    assertOnlyAllowedStaged(gate.gitRoot, gate.allowedPaths);
+    const confirmCommit = commit(gate.gitRoot, `chore: confirm review ${subjectSuffix}`, {
+        recovery: [
+            "Review confirmation files were written but not committed.",
+            `Inspect and either fix hooks then run: git add -- ${gate.allowedPaths.join(" ")} && git commit`,
+            "Or manually revert the written review confirmation files if the confirmation should not proceed.",
+        ],
+    });
+    writeFinalAudit(confirmCommit);
+    const reviewRelativePath = toPosix(path.relative(gate.gitRoot, path.resolve(reviewPath)));
+    git(gate.gitRoot, ["add", "--", reviewRelativePath]);
+    assertOnlyAllowedStaged(gate.gitRoot, gate.allowedPaths);
+    const auditCommit = commit(gate.gitRoot, `chore: record review confirmation audit ${subjectSuffix}`, {
+        recovery: [
+            "The confirmation commit was created, but final audit metadata could not be committed.",
+            `Confirmation commit SHA: ${confirmCommit}`,
+            `Fix hooks, then stage ${reviewRelativePath} and commit the audit metadata.`,
+        ],
+    });
+    assertCleanWorkingTree(gate.gitRoot);
+    return {
+        commitSha: confirmCommit,
+        auditCommitSha: auditCommit,
+        auditStatus: "committed",
+        allowedPaths: gate.allowedPaths,
+        message,
+    };
+}
+export function validateReviewConfirmationGitAudit({ projectRoot, taskId, reviewPath, progressPath, commitSha }) {
+    const issues = [];
+    const addIssue = (code) => issues.push(code);
+    const root = projectRoot ? path.resolve(projectRoot) : "";
+    const reviewRelativePath = root && reviewPath ? toPosix(path.relative(root, path.resolve(reviewPath))) : "";
+    const progressRelativePath = root && progressPath ? toPosix(path.relative(root, path.resolve(progressPath))) : "";
+    const expectedPaths = [reviewRelativePath, progressRelativePath].filter(Boolean).sort();
+    if (!root)
+        addIssue("git-audit-context-missing");
+    if (!commitSha)
+        addIssue("git-audit-commit-missing");
+    if (issues.length > 0)
+        return { valid: false, issues };
+    const gitRootResult = git(root, ["rev-parse", "--show-toplevel"], { allowFailure: true });
+    if (gitRootResult.status !== 0) {
+        return { valid: false, issues: ["git-audit-repository-missing"] };
+    }
+    const gitRoot = path.resolve(gitRootResult.stdout.trim());
+    if (real(gitRoot) !== real(root))
+        addIssue("git-audit-root-mismatch");
+    const commitResult = git(root, ["rev-parse", "--verify", `${commitSha}^{commit}`], { allowFailure: true });
+    if (commitResult.status !== 0) {
+        return { valid: false, issues: [...issues, "git-audit-commit-missing"] };
+    }
+    const fullCommitSha = commitResult.stdout.trim();
+    const reachable = git(root, ["merge-base", "--is-ancestor", fullCommitSha, "HEAD"], { allowFailure: true });
+    if (reachable.status !== 0)
+        addIssue("git-audit-commit-not-reachable");
+    const subject = git(root, ["show", "-s", "--format=%s", fullCommitSha], { allowFailure: true }).stdout.trim();
+    const expectedSubject = `chore: confirm review ${String(taskId || "").replace(/[^A-Za-z0-9._/-]+/g, "-")}`;
+    if (subject !== expectedSubject)
+        addIssue("git-audit-subject-mismatch");
+    const changedPaths = git(root, ["diff-tree", "--no-commit-id", "--name-only", "-r", fullCommitSha], { allowFailure: true }).stdout
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map(toPosix)
+        .sort();
+    if (expectedPaths.length === 0)
+        addIssue("git-audit-allowlist-missing");
+    if (changedPaths.join("\n") !== expectedPaths.join("\n"))
+        addIssue("git-audit-allowlist-mismatch");
+    return {
+        valid: issues.length === 0,
+        issues,
+        commitSha: fullCommitSha,
+        changedPaths,
+        expectedPaths,
+        subject,
+    };
+}
+function requireGitRoot(root) {
+    const result = git(root, ["rev-parse", "--show-toplevel"], { allowFailure: true });
+    if (result.status !== 0) {
+        throw new ReviewConfirmGitGateError("Review confirmation auto-commit requires a Git repository.", {
+            code: "git-repository-missing",
+            details: { root, stderr: result.stderr.trim() },
+            recovery: ["Initialize Git for the target project or run review-confirm from the correct repository root."],
+        });
+    }
+    return path.resolve(result.stdout.trim());
+}
+function assertAllowedPaths(paths) {
+    const disallowed = paths.filter((relativePath) => {
+        if (!relativePath || relativePath.startsWith("../") || path.isAbsolute(relativePath))
+            return true;
+        if (relativePath === "AGENTS.md" || relativePath === "CLAUDE.md")
+            return true;
+        if (relativePath === "docs" || relativePath.startsWith("docs/"))
+            return false;
+        if (relativePath === ".harness-private" || relativePath.startsWith(".harness-private/"))
+            return true;
+        return false;
+    });
+    if (disallowed.length > 0) {
+        throw new ReviewConfirmGitGateError("Review confirmation write allowlist contains forbidden paths.", {
+            code: "git-allowlist-forbidden-path",
+            details: { disallowed },
+            recovery: ["Limit review-confirm writes to the current task INDEX.md file."],
+        });
+    }
+}
+function assertCleanWorkingTree(gitRoot) {
+    const entries = statusEntries(gitRoot);
+    if (entries.length > 0) {
+        throw new ReviewConfirmGitGateError("Git working tree is not clean; refusing review confirmation auto-commit.", {
+            code: "git-dirty-working-tree",
+            details: { entries },
+            recovery: [
+                "Commit, move, or intentionally discard unrelated changes before review-confirm.",
+                "Do not stash/reset automatically; resolve ownership of the dirty files first.",
+            ],
+        });
+    }
+}
+function assertCommitIdentity(gitRoot) {
+    const name = git(gitRoot, ["config", "--get", "user.name"], { allowFailure: true }).stdout.trim();
+    const email = git(gitRoot, ["config", "--get", "user.email"], { allowFailure: true }).stdout.trim();
+    if (!name || !email) {
+        throw new ReviewConfirmGitGateError("Git commit identity is missing; refusing review confirmation auto-commit.", {
+            code: "git-identity-missing",
+            details: { hasName: Boolean(name), hasEmail: Boolean(email) },
+            recovery: [
+                "Set a local Git identity for this repository:",
+                "git config user.name \"Your Name\"",
+                "git config user.email \"you@example.com\"",
+            ],
+        });
+    }
+}
+function assertOnlyAllowedChanged(gitRoot, allowedPaths) {
+    const entries = statusEntries(gitRoot);
+    const outside = entries.filter((entry) => !allowedPaths.includes(entry.path));
+    if (outside.length > 0) {
+        throw new ReviewConfirmGitGateError("Review confirmation produced changes outside the write allowlist.", {
+            code: "git-allowlist-violation",
+            details: { entries, allowedPaths },
+            recovery: [
+                "Inspect the extra files and do not commit them through review-confirm.",
+                "Revert only the unintended review-confirm side effects, then retry.",
+            ],
+        });
+    }
+}
+function assertOnlyAllowedStaged(gitRoot, allowedPaths) {
+    const entries = statusEntries(gitRoot);
+    const stagedOutside = entries.filter((entry) => entry.index !== " " && !allowedPaths.includes(entry.path));
+    if (stagedOutside.length > 0) {
+        throw new ReviewConfirmGitGateError("Git index contains staged files outside the review confirmation allowlist.", {
+            code: "git-index-allowlist-violation",
+            details: { stagedOutside, allowedPaths },
+            recovery: ["Unstage unrelated files before retrying review-confirm."],
+        });
+    }
+}
+function commit(gitRoot, message, { recovery }) {
+    const result = git(gitRoot, ["commit", "-m", message], { allowFailure: true });
+    if (result.status !== 0) {
+        throw new ReviewConfirmGitGateError("Git commit failed during review confirmation auto-commit.", {
+            code: "git-commit-failed",
+            details: { stdout: result.stdout.trim(), stderr: result.stderr.trim() },
+            recovery,
+        });
+    }
+    return git(gitRoot, ["rev-parse", "HEAD"]).stdout.trim();
+}
+function statusEntries(gitRoot) {
+    const output = git(gitRoot, ["status", "--porcelain=v1", "--untracked-files=all"]).stdout;
+    return output.split(/\r?\n/).filter(Boolean).map((line) => ({
+        index: line.slice(0, 1),
+        worktree: line.slice(1, 2),
+        path: parseStatusPath(line.slice(3)),
+        raw: line,
+    }));
+}
+function parseStatusPath(value) {
+    const unquoted = value.replace(/^"|"$/g, "");
+    const renamed = unquoted.includes(" -> ") ? unquoted.split(" -> ").pop() : unquoted;
+    return renamed || "";
+}
+function git(cwd, args, { allowFailure = false } = {}) {
+    const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+    if (!allowFailure && result.status !== 0) {
+        throw new ReviewConfirmGitGateError(`git ${args.join(" ")} failed`, {
+            code: "git-command-failed",
+            details: { stdout: result.stdout.trim(), stderr: result.stderr.trim() },
+            recovery: ["Inspect the Git error and retry review-confirm after resolving it."],
+        });
+    }
+    return result;
+}
+function real(filePath) {
+    return fs.realpathSync(filePath);
+}

package/dist/lib/status-builder.mjs

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import path from "node:path";
+import { normalizeTarget, toPosix } from "./core-shared.mjs";
+import { capabilityDefinitions, readCapabilityRegistry } from "./capability-registry.mjs";
+import { summarizeGitState } from "./git-status-summary.mjs";
+import { collectTasks, taskCutoverCounters } from "./task-scanner.mjs";
+export function buildStatusData(targetInput, options = {}) {
+    const target = targetInput?.projectRoot ? targetInput : normalizeTarget(targetInput);
+    const validationMode = options.validationMode || "data-only";
+    const gitState = options.gitState || summarizeGitState(target);
+    const registry = options.capabilityState?.registry || readCapabilityRegistry(target);
+    const detected = options.capabilityState?.detected || [];
+    const capabilityWarnings = options.capabilityState?.warnings || [];
+    const failures = [...(options.failures || [])];
+    const warnings = [...(options.warnings || [])];
+    const legacy = options.legacy || { status: "skipped", code: 0, stdout: "", stderr: "" };
+    const tasks = options.tasks || collectTasks(target, {
+        requireGeneratedScaffoldProvenance: options.requireGeneratedScaffoldProvenance === true,
+        taskPlanPaths: options.taskPlanPaths,
+        closeoutContent: options.closeoutContent,
+    });
+    const briefReady = tasks.filter((task) => task.briefSource === "standalone").length;
+    const briefMissing = tasks.length - briefReady;
+    const capabilityNames = new Map(registry.capabilities.map((capability) => [capability.name, capability]));
+    for (const capability of detected) {
+        if (!capabilityNames.has(capability))
+            capabilityNames.set(capability, { name: capability, state: "configured" });
+    }
+    const cutoverCounters = taskCutoverCounters(tasks);
+    const fullCutoverEligible = validationMode === "validated" &&
+        failures.length === 0 &&
+        warnings.length === 0 &&
+        cutoverCounters.legacyVisualOnlyCount === 0 &&
+        cutoverCounters.unknownClassificationCount === 0 &&
+        cutoverCounters.weakBriefCount === 0 &&
+        cutoverCounters.missingCanonicalVisualMapCount === 0;
+    return {
+        project: {
+            name: path.basename(target.projectRoot),
+            root: `TARGET:${target.docsOnly ? toPosix(path.relative(target.projectRoot, target.docsRoot)) : "."}`,
+            docsOnly: target.docsOnly,
+        },
+        schemaVersion: 2,
+        generatedAt: options.generatedAt || new Date().toISOString(),
+        mode: registry.mode,
+        checkState: {
+            status: failures.length > 0 ? "fail" : warnings.length > 0 ? "warn" : "pass",
+            validationMode,
+            failures: failures.length,
+            warnings: warnings.length,
+            details: { failures, warnings },
+            legacy,
+        },
+        git: gitState.summary,
+        summary: {
+            tasks: tasks.length,
+            briefCoverage: {
+                ready: briefReady,
+                missing: briefMissing,
+                total: tasks.length,
+            },
+            visualMapCoverage: {
+                canonical: tasks.filter((task) => task.visualMapSource === "canonical").length,
+                legacyOnly: cutoverCounters.legacyVisualOnlyCount,
+                missing: tasks.filter((task) => task.visualMapStatus === "missing").length,
+                total: tasks.length,
+            },
+            fullCutoverEligible,
+            legacyVisualOnlyCount: cutoverCounters.legacyVisualOnlyCount,
+            unknownClassificationCount: cutoverCounters.unknownClassificationCount,
+            weakBriefCount: cutoverCounters.weakBriefCount,
+            visualMapRequiredCount: cutoverCounters.visualMapRequiredCount,
+            missingCanonicalVisualMapCount: cutoverCounters.missingCanonicalVisualMapCount,
+        },
+        capabilities: [...capabilityNames.values()].map((capability) => ({
+            name: capability.name,
+            state: capability.state || "configured",
+            dependencyStatus: capabilityDefinitions[capability.name]?.dependencies.every((dependency) => capabilityNames.has(dependency))
+                ? "valid"
+                : "invalid",
+            warnings: capabilityWarnings.filter((warning) => warning.includes(capability.name)),
+        })),
+        tasks,
+        handoffs: tasks.flatMap((task) => task.handoffs || []),
+        recentActivity: tasks.slice(0, 8).map((task) => ({ at: new Date().toISOString(), type: "task", summary: task.title })),
+    };
+}

package/{scripts → dist}/lib/status-dashboard-renderer.mjs

@@ -1,24 +1,24 @@
+import { implementationPhases } from "./phase-kind.mjs";
 export function renderDashboard(status) {
-  const taskCards = status.tasks
-    .map((task) => {
-      const phases = task.phases
-        .map(
-          (phase) => `<div class="phase ${escapeHtml(phase.state)}">
-            <div class="phase-top"><strong>${escapeHtml(phase.id)}</strong><span>${phase.completion}%</span></div>
+    const taskCards = status.tasks
+        .map((task) => {
+        const phases = task.phases
+            .map((phase) => `<div class="phase ${escapeHtml(phase.state)} ${escapeHtml(phase.kind || "execution")}">
+            <div class="phase-top"><strong>${escapeHtml(phase.id)}</strong><span>${escapeHtml(phase.kind || "execution")} · ${phase.completion}%</span></div>
             <div class="phase-output">${escapeHtml(phase.output)}</div>
             <div class="meter"><i style="width:${phase.completion}%"></i></div>
-            <div class="muted">${escapeHtml(phase.state)} · evidence ${escapeHtml(phase.evidenceStatus)}</div>
-          </div>`,
-        )
-        .join("");
-      const risks = task.risks
-        .map((risk) => `<span class="risk ${risk.open || risk.blocksRelease ? "open" : ""}">${escapeHtml(risk.severity)} ${escapeHtml(risk.summary)}</span>`)
-        .join("");
-      const evidence = task.evidence
-        .map((item) => `<span class="evidence">${escapeHtml(item.type)} · ${escapeHtml(item.summary)}</span>`)
-        .join("");
-      const evidenceMeter = evidenceCompletion(task.phases);
-      return `<section class="task">
+            <div class="muted">${escapeHtml(phase.state)} · actor ${escapeHtml(phase.actor || "agent")} · evidence ${escapeHtml(phase.evidenceStatus)}</div>
+            ${phase.exitCommand ? `<div class="muted">exit ${escapeHtml(phase.exitCommand)}</div>` : ""}
+          </div>`)
+            .join("");
+        const risks = task.risks
+            .map((risk) => `<span class="risk ${risk.open || risk.blocksRelease ? "open" : ""}">${escapeHtml(risk.severity)} ${escapeHtml(risk.summary)}</span>`)
+            .join("");
+        const evidence = task.evidence
+            .map((item) => `<span class="evidence">${escapeHtml(item.type)} · ${escapeHtml(item.summary)}</span>`)
+            .join("");
+        const evidenceMeter = evidenceCompletion(task.phases);
+        return `<section class="task">
         <div class="task-head">
           <div><h2>${escapeHtml(task.title)}</h2><p>${escapeHtml(task.path)}</p></div>
           <div class="score">${task.completion}%</div>
@@ -29,19 +29,19 @@ export function renderDashboard(status) {
         <div class="risks">${risks || '<span class="ok">No open visual risk</span>'}</div>
       </section>`;
     })
-    .join("");
-  const chips = status.capabilities
-    .map((capability) => `<span class="chip ${escapeHtml(capability.state)}">${escapeHtml(capability.name)} · ${escapeHtml(capability.state)}</span>`)
-    .join("");
-  const failures = status.checkState.details.failures.map((failure) => `<li>${escapeHtml(failure)}</li>`).join("");
-  const warnings = status.checkState.details.warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join("");
-  const handoffs = status.handoffs
-    .map((handoff) => `<span class="handoff">${escapeHtml(handoff.state)} · ${escapeHtml(handoff.summary)}</span>`)
-    .join("");
-  const activity = status.recentActivity
-    .map((item) => `<li><strong>${escapeHtml(item.type)}</strong> ${escapeHtml(item.summary)}</li>`)
-    .join("");
-  return `<!doctype html>
+        .join("");
+    const chips = status.capabilities
+        .map((capability) => `<span class="chip ${escapeHtml(capability.state)}">${escapeHtml(capability.name)} · ${escapeHtml(capability.state)}</span>`)
+        .join("");
+    const failures = status.checkState.details.failures.map((failure) => `<li>${escapeHtml(failure)}</li>`).join("");
+    const warnings = status.checkState.details.warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join("");
+    const handoffs = status.handoffs
+        .map((handoff) => `<span class="handoff">${escapeHtml(handoff.state)} · ${escapeHtml(handoff.summary)}</span>`)
+        .join("");
+    const activity = status.recentActivity
+        .map((item) => `<li><strong>${escapeHtml(item.type)}</strong> ${escapeHtml(item.summary)}</li>`)
+        .join("");
+    return `<!doctype html>
 <html lang="zh-CN">
 <head>
   <meta charset="utf-8">
@@ -81,22 +81,23 @@ export function renderDashboard(status) {
   <section class="panel"><h2>Failures</h2><ul>${failures || "<li>None</li>"}</ul><h2>Warnings</h2><ul>${warnings || "<li>None</li>"}</ul></section>
 </main></body></html>`;
 }
-
 function escapeHtml(value) {
-  return String(value ?? "")
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;");
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
 }
-
-function evidenceCompletion(phases) {
-  const scored = phases.filter((phase) => phase.state !== "skipped");
-  if (scored.length === 0) return 0;
-  const score = scored.reduce((sum, phase) => {
-    if (["present", "waived"].includes(phase.evidenceStatus)) return sum + 100;
-    if (phase.evidenceStatus === "partial") return sum + 50;
-    return sum;
-  }, 0);
-  return Math.round(score / scored.length);
+function evidenceCompletion(phases = []) {
+    const scored = implementationPhases(phases);
+    if (scored.length === 0)
+        return 0;
+    const score = scored.reduce((sum, phase) => {
+        if (["present", "waived"].includes(String(phase.evidenceStatus)))
+            return sum + 100;
+        if (phase.evidenceStatus === "partial")
+            return sum + 50;
+        return sum;
+    }, 0);
+    return Math.round(score / scored.length);
 }