ace-swarm 2.1.2 → 2.2.0

package/dist/tools-framework.js

@@ -3,7 +3,7 @@
  * plus new run_tests and validate_framework tools.
  */
 import { z } from "zod";
-import { ALL_MCP_CLIENTS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, bootstrapAceWorkspace, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, safeRead, wsPath, } from "./helpers.js";
+import { ALL_MCP_CLIENTS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, bootstrapAceWorkspace, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
 import { getRoleTitle, MCP_CLIENT_ENUM, scoreDomains, } from "./shared.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
 import { scanWorkspaceDelta } from "./index-store.js";
@@ -17,6 +17,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { auditPublicSurface } from "./public-surface.js";
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
+import { readAceTaskContractAssessment } from "./ace-autonomy.js";
 function getArtifactManifestEntries(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return [];
@@ -35,6 +36,232 @@ function getArtifactManifestEntries(payload) {
     }
     return [];
 }
+function readGateManifests(gatesDir) {
+    const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
+    const allGates = [];
+    for (const file of files) {
+        try {
+            const raw = readFileSync(resolve(gatesDir, file), "utf-8");
+            const gate = JSON.parse(raw);
+            if (gate.id)
+                allGates.push(gate);
+        }
+        catch {
+            /* skip corrupt manifests */
+        }
+    }
+    return allGates;
+}
+function evaluateGateTargets(targets) {
+    const results = [];
+    for (const gate of targets) {
+        if (gate.type === "executable" && gate.command.trim().length > 0) {
+            const testResult = runTestSuite(gate.command);
+            results.push({
+                id: gate.id,
+                type: gate.type,
+                ok: testResult.ok,
+                detail: testResult.ok
+                    ? `PASS (exit ${testResult.exit_code}, ${testResult.duration_ms}ms)`
+                    : `FAIL (exit ${testResult.exit_code}): ${testResult.output.slice(0, 500)}`,
+                invariant: gate.invariant,
+                evidence_requirement: gate.evidence_requirement,
+            });
+            continue;
+        }
+        if (gate.type === "artifact_scan") {
+            const evidenceReq = gate.evidence_requirement.trim();
+            const looksLikeProse = evidenceReq.includes(" ") &&
+                !/\.(md|json|ts|js|yaml|yml|ndjson|txt)\b/.test(evidenceReq) &&
+                !evidenceReq.includes("/");
+            const missing = [];
+            if (looksLikeProse) {
+                const knownArtifacts = [
+                    "STATUS.md",
+                    "EVIDENCE_LOG.md",
+                    "HANDOFF.json",
+                    "DECISIONS.md",
+                    "RISKS.md",
+                    "SCOPE.md",
+                    "TASK.md",
+                    "QUALITY_GATES.md",
+                    "SPEC_CONTRACT.json",
+                    "TEAL_CONFIG.md",
+                ];
+                const invariantLower = gate.invariant.toLowerCase();
+                const relevantArtifacts = knownArtifacts.filter((artifact) => invariantLower.includes(artifact.replace(/\.\w+$/, "").toLowerCase().replace(/_/g, " ")) || invariantLower.includes(artifact.toLowerCase()));
+                if (relevantArtifacts.length === 0) {
+                    missing.push(`(prose evidence cannot be auto-verified: "${evidenceReq.slice(0, 80)}")`);
+                }
+                else {
+                    for (const artifact of relevantArtifacts) {
+                        if (!existsSync(wsPath("agent-state", artifact))) {
+                            missing.push(artifact);
+                        }
+                    }
+                }
+            }
+            else {
+                const evidenceFiles = evidenceReq
+                    .split(/[+,&]/)
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                for (const ref of evidenceFiles) {
+                    const candidates = [wsPath("agent-state", ref), wsPath(ref)];
+                    const found = candidates.some((candidate) => existsSync(candidate));
+                    if (!found) {
+                        const asFile = ref.replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_./-]/g, "");
+                        const fileFound = existsSync(wsPath("agent-state", asFile));
+                        if (!fileFound)
+                            missing.push(ref);
+                    }
+                }
+            }
+            results.push({
+                id: gate.id,
+                type: gate.type,
+                ok: missing.length === 0,
+                detail: missing.length === 0
+                    ? "PASS (all evidence artifacts present)"
+                    : `FAIL (missing evidence: ${missing.join(", ")})`,
+                invariant: gate.invariant,
+                evidence_requirement: gate.evidence_requirement,
+            });
+            continue;
+        }
+        if (gate.type === "manual_review") {
+            results.push({
+                id: gate.id,
+                type: gate.type,
+                ok: false,
+                detail: "PENDING — requires manual review (not auto-enforceable, blocking until reviewed)",
+                invariant: gate.invariant,
+                evidence_requirement: gate.evidence_requirement,
+            });
+            continue;
+        }
+        results.push({
+            id: gate.id,
+            type: gate.type ?? "unknown",
+            ok: false,
+            detail: "Unknown gate type or no command specified",
+            invariant: gate.invariant,
+            evidence_requirement: gate.evidence_requirement,
+        });
+    }
+    return results;
+}
+function buildAdversarialClaim(result) {
+    switch (result.type) {
+        case "executable":
+            return `Executable gate ${result.id} failed its invariant check.`;
+        case "artifact_scan":
+            return `Artifact evidence for gate ${result.id} is not sufficient to trust the invariant.`;
+        case "manual_review":
+            return `Gate ${result.id} still depends on human review before the invariant can be trusted.`;
+        default:
+            return `Gate ${result.id} could not be verified cleanly.`;
+    }
+}
+function inferRouteHint(result) {
+    if (result.type === "executable")
+        return "agent-builder";
+    if (result.type === "artifact_scan" &&
+        result.detail.toLowerCase().includes("prose evidence cannot be auto-verified")) {
+        return "agent-spec";
+    }
+    if (result.type === "artifact_scan")
+        return "agent-ops";
+    if (result.type === "manual_review")
+        return "agent-skeptic";
+    return undefined;
+}
+function buildAdversarialReview(results, reviewFocus) {
+    const candidates = results
+        .filter((result) => !result.ok)
+        .map((result) => ({
+        gate_id: result.id,
+        gate_type: result.type,
+        claim: buildAdversarialClaim(result),
+        detail: result.detail,
+        invariant: result.invariant,
+        evidence_requirement: result.evidence_requirement,
+        route_hint: inferRouteHint(result),
+    }));
+    const disproved = [];
+    const confirmed = [];
+    for (const finding of candidates) {
+        if (finding.gate_type === "manual_review") {
+            disproved.push({
+                ...finding,
+                reason: "Pending manual review alone is not enough to confirm an actionable defect.",
+            });
+            continue;
+        }
+        if (finding.gate_type === "artifact_scan" &&
+            finding.detail.toLowerCase().includes("prose evidence cannot be auto-verified")) {
+            disproved.push({
+                ...finding,
+                reason: "The evidence contract is too vague to confirm a defect without stronger artifacts.",
+            });
+            continue;
+        }
+        confirmed.push(finding);
+    }
+    return {
+        mode: "skeptic_adversarial",
+        focus: reviewFocus?.trim() || undefined,
+        candidates,
+        disproved,
+        confirmed,
+        summary: {
+            candidate_count: candidates.length,
+            disproved_count: disproved.length,
+            confirmed_count: confirmed.length,
+            actionable_gate_ids: confirmed.map((finding) => finding.gate_id),
+        },
+    };
+}
+async function appendEvidenceLogEntrySafe(review) {
+    const timestamp = new Date().toISOString();
+    const anchor = `#ts:${timestamp}`;
+    const evidenceRef = `agent-state/EVIDENCE_LOG.md${anchor}`;
+    return withFileLock("agent-state/EVIDENCE_LOG.md", () => {
+        const existing = safeRead("agent-state/EVIDENCE_LOG.md");
+        const seed = existing.startsWith("[FILE NOT FOUND]") || existing.startsWith("[ACCESS DENIED]")
+            ? "# EVIDENCE LOG\n\nAppend-only validation evidence.\n\n## Entries\n"
+            : existing.trimEnd();
+        const lines = [
+            "",
+            `[${timestamp}] Skeptic adversarial review via execute_gates`,
+            `- evidence_ref: ${anchor}`,
+            ...(review.focus ? [`- focus: ${review.focus}`] : []),
+            `- candidates: ${review.summary.candidate_count}`,
+            `- disproved: ${review.summary.disproved_count}`,
+            `- confirmed: ${review.summary.confirmed_count}`,
+            `- actionable_gate_ids: ${review.summary.actionable_gate_ids.length > 0
+                ? review.summary.actionable_gate_ids.join(", ")
+                : "none"}`,
+            "- bug_hunter_candidates:",
+            ...(review.candidates.length > 0
+                ? review.candidates.map((finding) => `  - ${finding.gate_id} [${finding.gate_type}]: ${finding.claim} (${finding.detail})`)
+                : ["  - none"]),
+            "- disprover_results:",
+            ...(review.disproved.length > 0
+                ? review.disproved.map((finding) => `  - ${finding.gate_id}: ${finding.reason ?? "candidate rejected"}`)
+                : ["  - none"]),
+            "- adjudicator_confirmed:",
+            ...(review.confirmed.length > 0
+                ? review.confirmed.map((finding) => {
+                    const route = finding.route_hint ? ` route_hint=${finding.route_hint}` : "";
+                    return `  - ${finding.gate_id}: ${finding.detail}.${route}`;
+                })
+                : ["  - none"]),
+        ];
+        const path = safeWrite("agent-state/EVIDENCE_LOG.md", `${seed}${lines.join("\n")}\n`);
+        return { path, evidenceRef };
+    });
+}
 export function registerFrameworkTools(server) {
     // ── Routing (improved with weighted scoring) ──────────────────────
     server.tool("route_task", "Determine which ACE agent(s) or skill should handle a task", {
@@ -129,6 +356,14 @@ export function registerFrameworkTools(server) {
         const route = routingMap[detected] ?? routingMap.mixed;
         const recommendedSkills = new Set(route.skills ?? []);
         const recommendedSubagents = new Set(route.subagents);
+        const taskContract = readAceTaskContractAssessment();
+        const stateConflictRequested = text.includes("contradict") ||
+            text.includes("conflict") ||
+            text.includes("misalign") ||
+            text.includes("drift") ||
+            text.includes("blocked");
+        const requiresGovernance = detected === "mixed" || !taskContract.ok || stateConflictRequested;
+        const activeRoute = requiresGovernance ? routingMap.mixed : route;
         if (text.includes("schema") || text.includes("contract")) {
             recommendedSubagents.add("spec");
             recommendedSkills.add("schema-forge");
@@ -232,6 +467,11 @@ export function registerFrameworkTools(server) {
             text.includes("fix")) {
             recommendedSubagents.add("builder");
         }
+        if (requiresGovernance) {
+            recommendedSubagents.add("skeptic");
+            recommendedSubagents.add("ops");
+            recommendedSubagents.add("memory");
+        }
         return {
             content: [
                 {
@@ -241,22 +481,38 @@ export function registerFrameworkTools(server) {
                         "",
                         `**Task:** ${description}`,
                         `**Detected Domain:** ${detected}`,
-                        `**Primary Swarm Agent(s):** ${route.swarm_agents
+                        `**Primary Swarm Agent(s):** ${activeRoute.swarm_agents
                             .map((agent) => `ACE-${getRoleTitle(agent)}`)
                             .join(", ")}`,
+                        "**Hierarchy Rule:** Top-level routing stays locked to ACE-Orchestrator, ACE-VOS, ACE-UI, or ACE-Coders. Composable agents are delegated specialists, not peer replacements.",
+                        `**Preflight Owner:** ACE-Orchestrator`,
+                        `**Task Contract:** ${taskContract.ok ? "aligned" : "attention required"}`,
                         `**Composable Subagents (Universal):** ${[...COMPOSABLE_AGENTS].join(", ")}`,
-                        `**Recommended Subagents:** ${[...recommendedSubagents].join(", ")}`,
-                        `**Pipeline:** ${route.pipeline}`,
-                        `**Recommended Prompt:** ${route.prompt}`,
+                        `**Recommended Delegated Subagents:** ${[...recommendedSubagents].join(", ")}`,
+                        `**Pipeline:** ${activeRoute.pipeline}`,
+                        `**Recommended Prompt:** ${activeRoute.prompt}`,
                         recommendedSkills.size > 0
                             ? `**Recommended Skills:** ${[...recommendedSkills].join(", ")}`
                             : "",
+                        ...(!taskContract.ok
+                            ? [
+                                "",
+                                "## Preflight Risks",
+                                ...taskContract.files.map((entry) => `- ${entry.path}: ${entry.valid ? "ok" : entry.note}`),
+                                ...taskContract.blockers.map((entry) => `- blocker: ${entry}`),
+                            ]
+                            : []),
+                        "",
+                        "## Preflight Expectations",
+                        "1. Recall current ACE context from TASK, SCOPE, QUALITY_GATES, STATUS, HANDOFF, and EVIDENCE artifacts.",
+                        "2. Validate the ACE quartet before dispatching substantial work.",
+                        "3. Route ambiguity or contract drift through skeptic/validation before handoff.",
                         "",
                         "## Next Steps",
-                        `1. Activate prompt: \`${route.prompt}\``,
-                        "2. Load shared kernel context with `get_kernel_artifact` (`directive_kernel`, `agent_registry`)",
-                        "3. Generate a structured handoff with `create_handoff` when cross-role routing is needed",
-                        "4. Load role task pack with `get_task_pack`",
+                        `1. Activate prompt: \`${activeRoute.prompt}\``,
+                        "2. Run `validate_framework` and inspect current ACE state before cross-role dispatch.",
+                        "3. Load shared kernel context with `get_kernel_artifact` (`directive_kernel`, `agent_registry`)",
+                        "4. Generate a structured handoff with `create_handoff` only after preflight clears",
                     ]
                         .filter(Boolean)
                         .join("\n"),
@@ -452,6 +708,7 @@ export function registerFrameworkTools(server) {
             "agent-state/TASK.md",
             "agent-state/STATUS.md",
             "agent-state/SCOPE.md",
+            "agent-state/QUALITY_GATES.md",
             "agent-state/EVIDENCE_LOG.md",
             "agent-state/DECISIONS.md",
             "agent-state/RISKS.md",
@@ -640,6 +897,10 @@ export function registerFrameworkTools(server) {
         const checks = [];
         // Check: required state files exist
         const requiredFiles = [
+            "agent-state/TASK.md",
+            "agent-state/SCOPE.md",
+            "agent-state/QUALITY_GATES.md",
+            "agent-state/HANDOFF.json",
             "agent-state/STATUS.md",
             "agent-state/EVIDENCE_LOG.md",
             "agent-state/DECISIONS.md",
@@ -814,6 +1075,17 @@ export function registerFrameworkTools(server) {
                     : `${missingLinks.length} manifest entries missing provenance links in PROVENANCE_LOG.md`,
             });
         }
+        const taskContract = readAceTaskContractAssessment();
+        checks.push({
+            name: "task-contract:quartet",
+            ok: taskContract.ok,
+            detail: taskContract.ok
+                ? taskContract.summary
+                : [
+                    ...taskContract.files.map((entry) => `${entry.path}=${entry.valid ? "ok" : entry.note}`),
+                    ...taskContract.blockers,
+                ].join("; "),
+        });
         // Check: git status
         checks.push({
             name: "git-repo",
@@ -1002,7 +1274,15 @@ export function registerFrameworkTools(server) {
             .array(z.string())
             .optional()
             .describe("Specific gate IDs to run (e.g. ['gate-correctness']). Omit to run all registered gates."),
-    }, async ({ gate_ids }) => {
+        review_mode: z
+            .enum(["skeptic_adversarial"])
+            .optional()
+            .describe("Optional skeptic review overlay that keeps only surviving findings actionable."),
+        review_focus: z
+            .string()
+            .optional()
+            .describe("Optional short focus string persisted with skeptic adversarial review evidence."),
+    }, async ({ gate_ids, review_mode, review_focus }) => {
         const gatesDir = wsPath("agent-state", "MODULES", "gates");
         if (!existsSync(gatesDir)) {
             return {
@@ -1014,19 +1294,7 @@ export function registerFrameworkTools(server) {
                 ],
             };
         }
-        const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
-        const allGates = [];
-        for (const file of files) {
-            try {
-                const raw = readFileSync(resolve(gatesDir, file), "utf-8");
-                const gate = JSON.parse(raw);
-                if (gate.id)
-                    allGates.push(gate);
-            }
-            catch {
-                /* skip corrupt manifests */
-            }
-        }
+        const allGates = readGateManifests(gatesDir);
         // Filter to requested gates (or run all)
         const targets = gate_ids
             ? allGates.filter((g) => gate_ids.includes(g.id))
@@ -1041,110 +1309,24 @@ export function registerFrameworkTools(server) {
                 ],
             };
         }
-        const results = [];
-        for (const gate of targets) {
-            if (gate.type === "executable" && gate.command.trim().length > 0) {
-                // Run the command
-                const testResult = runTestSuite(gate.command);
-                results.push({
-                    id: gate.id,
-                    type: gate.type,
-                    ok: testResult.ok,
-                    detail: testResult.ok
-                        ? `PASS (exit ${testResult.exit_code}, ${testResult.duration_ms}ms)`
-                        : `FAIL (exit ${testResult.exit_code}): ${testResult.output.slice(0, 500)}`,
-                });
-            }
-            else if (gate.type === "artifact_scan") {
-                // Scan evidence requirement against existing files.
-                // Guard: if the evidence_requirement looks like prose (contains spaces
-                // and no path separators or file extensions), skip path-splitting and
-                // instead verify that the invariant-referenced state artifacts exist.
-                const evidenceReq = gate.evidence_requirement.trim();
-                const looksLikeProse = evidenceReq.includes(" ") &&
-                    !/\.(md|json|ts|js|yaml|yml|ndjson|txt)\b/.test(evidenceReq) &&
-                    !evidenceReq.includes("/");
-                let missing = [];
-                if (looksLikeProse) {
-                    // Prose evidence — extract known artifact names from the invariant
-                    // instead of blindly splitting prose into file paths.
-                    const knownArtifacts = [
-                        "STATUS.md", "EVIDENCE_LOG.md", "HANDOFF.json", "DECISIONS.md",
-                        "RISKS.md", "SCOPE.md", "TASK.md", "QUALITY_GATES.md",
-                        "SPEC_CONTRACT.json", "TEAL_CONFIG.md",
-                    ];
-                    // Check that at least some key artifacts referenced in the invariant exist
-                    const invariantLower = gate.invariant.toLowerCase();
-                    const relevantArtifacts = knownArtifacts.filter((a) => invariantLower.includes(a.replace(/\.\w+$/, "").toLowerCase().replace(/_/g, " "))
-                        || invariantLower.includes(a.toLowerCase()));
-                    if (relevantArtifacts.length === 0) {
-                        // No specific artifacts detectable from invariant; treat as insufficient evidence
-                        missing.push(`(prose evidence cannot be auto-verified: "${evidenceReq.slice(0, 80)}")`);
-                    }
-                    else {
-                        for (const artifact of relevantArtifacts) {
-                            if (!existsSync(wsPath("agent-state", artifact))) {
-                                missing.push(artifact);
-                            }
-                        }
-                    }
-                }
-                else {
-                    // Structured evidence — split by delimiters and look up as file paths
-                    const evidenceFiles = evidenceReq
-                        .split(/[+,&]/)
-                        .map((s) => s.trim())
-                        .filter(Boolean);
-                    for (const ref of evidenceFiles) {
-                        const candidates = [
-                            wsPath("agent-state", ref),
-                            wsPath(ref),
-                        ];
-                        const found = candidates.some((c) => existsSync(c));
-                        if (!found) {
-                            const asFile = ref.replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_./-]/g, "");
-                            const fileFound = existsSync(wsPath("agent-state", asFile));
-                            if (!fileFound)
-                                missing.push(ref);
-                        }
-                    }
-                }
-                results.push({
-                    id: gate.id,
-                    type: gate.type,
-                    ok: missing.length === 0,
-                    detail: missing.length === 0
-                        ? "PASS (all evidence artifacts present)"
-                        : `FAIL (missing evidence: ${missing.join(", ")})`,
-                });
-            }
-            else if (gate.type === "manual_review") {
-                // Manual review gates must NOT auto-pass — they are explicitly deferred
-                // and should be surfaced as pending rather than silently passed.
-                results.push({
-                    id: gate.id,
-                    type: gate.type,
-                    ok: false,
-                    detail: "PENDING — requires manual review (not auto-enforceable, blocking until reviewed)",
-                });
-            }
-            else {
-                results.push({
-                    id: gate.id,
-                    type: gate.type ?? "unknown",
-                    ok: false,
-                    detail: "Unknown gate type or no command specified",
-                });
-            }
-        }
+        const results = evaluateGateTargets(targets);
         const passed = results.filter((r) => r.ok).length;
         const failed = results.filter((r) => !r.ok).length;
-        const allOk = failed === 0;
+        const review = review_mode === "skeptic_adversarial"
+            ? buildAdversarialReview(results, review_focus)
+            : undefined;
+        const evidence = review_mode === "skeptic_adversarial" && review
+            ? await appendEvidenceLogEntrySafe(review)
+            : undefined;
+        const blockingFailures = review ? review.summary.confirmed_count : failed;
+        const allOk = blockingFailures === 0;
         await appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: "GATES_EXECUTED",
             status: allOk ? "pass" : "fail",
-            summary: `Gates executed: ${passed}/${results.length} passed`,
+            summary: review
+                ? `Gates executed with skeptic review: ${passed}/${results.length} passed, ${review.summary.confirmed_count} confirmed findings`
+                : `Gates executed: ${passed}/${results.length} passed`,
             payload: {
                 gates_run: results.map((r) => r.id),
                 gate_results: results.map((r) => ({
@@ -1154,27 +1336,83 @@ export function registerFrameworkTools(server) {
                 })),
                 passed,
                 failed,
-                evidence_ref: "agent-state/MODULES/gates/",
+                evidence_ref: evidence?.evidenceRef ?? "agent-state/MODULES/gates/",
+                ...(review
+                    ? {
+                        review: {
+                            mode: review.mode,
+                            focus: review.focus,
+                            candidate_count: review.summary.candidate_count,
+                            disproved_count: review.summary.disproved_count,
+                            confirmed_count: review.summary.confirmed_count,
+                            actionable_gate_ids: review.summary.actionable_gate_ids,
+                            candidates: review.candidates,
+                            disproved: review.disproved,
+                            confirmed: review.confirmed,
+                            evidence_ref: evidence?.evidenceRef,
+                        },
+                    }
+                    : {}),
             },
             objective_id: "gate-execution",
         });
         const ledger = await appendRunLedgerEntrySafe({
             tool: "execute_gates",
             category: allOk ? "info" : "regression",
-            message: `Gate execution: ${passed}/${results.length} passed`,
-            artifacts: results.map((r) => `agent-state/MODULES/gates/${r.id}.json`),
-            metadata: { passed, failed, gate_ids: results.map((r) => r.id) },
+            message: review
+                ? `Gate execution with skeptic review: ${review.summary.confirmed_count} confirmed findings`
+                : `Gate execution: ${passed}/${results.length} passed`,
+            artifacts: [
+                ...results.map((r) => `agent-state/MODULES/gates/${r.id}.json`),
+                ...(evidence ? ["agent-state/EVIDENCE_LOG.md"] : []),
+            ],
+            metadata: {
+                passed,
+                failed,
+                gate_ids: results.map((r) => r.id),
+                ...(review
+                    ? {
+                        review_mode: review.mode,
+                        review_focus: review.focus,
+                        candidate_count: review.summary.candidate_count,
+                        disproved_count: review.summary.disproved_count,
+                        confirmed_count: review.summary.confirmed_count,
+                        actionable_gate_ids: review.summary.actionable_gate_ids,
+                        evidence_ref: evidence?.evidenceRef,
+                    }
+                    : {}),
+            },
         });
         return {
             content: [
                 {
                     type: "text",
                     text: [
-                        allOk
-                            ? `✅ All gates passed: ${passed}/${results.length}`
-                            : `❌ Gate failures: ${failed}/${results.length} failed`,
+                        review
+                            ? allOk
+                                ? `✅ Skeptic adversarial review cleared: ${review.summary.confirmed_count} confirmed findings`
+                                : `❌ Skeptic adversarial review found ${review.summary.confirmed_count} confirmed finding${review.summary.confirmed_count === 1 ? "" : "s"}`
+                            : allOk
+                                ? `✅ All gates passed: ${passed}/${results.length}`
+                                : `❌ Gate failures: ${failed}/${results.length} failed`,
                         `Run ledger: ${ledger.path} (${ledger.entry.id})`,
+                        ...(evidence ? [`Evidence: ${evidence.path} (${evidence.evidenceRef})`] : []),
                         "",
+                        ...(review
+                            ? [
+                                `Review mode: ${review.mode}`,
+                                ...(review.focus ? [`Review focus: ${review.focus}`] : []),
+                                `- bug-hunter candidates: ${review.summary.candidate_count}`,
+                                `- disproved candidates: ${review.summary.disproved_count}`,
+                                `- confirmed findings: ${review.summary.confirmed_count}`,
+                                ...review.disproved.map((finding) => `- disproved ${finding.gate_id}: ${finding.reason ?? "candidate rejected"}`),
+                                ...review.confirmed.map((finding) => {
+                                    const route = finding.route_hint ? ` (route ${finding.route_hint})` : "";
+                                    return `- confirmed ${finding.gate_id}: ${finding.detail}${route}`;
+                                }),
+                                "",
+                            ]
+                            : []),
                         ...results.map((r) => `- ${r.ok ? "✅" : "❌"} ${r.id} [${r.type}]: ${r.detail}`),
                     ].join("\n"),
                 },