@tea-agent/loop-agent 0.1.0

package/dist/workflows/dag/knowledge-curator.js

@@ -0,0 +1,162 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { auditSkillMarkdownContent } from "../../governance/skill-safety.js";
+import { repairArtifactSchema } from "./repair-artifact.js";
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeScopeShape(fixScope) {
+    if (fixScope.length === 0)
+        return "none";
+    return fixScope
+        .map((scope) => scope.replace(/[^/]+$/g, "*"))
+        .sort()
+        .join(", ");
+}
+function parseLegacyArtifact(raw) {
+    // Preserve completed-run learning from pre-REPAIR_ARTIFACT_JSON supervisor output.
+    const block = raw.supervisorStructuredBlock;
+    if (!block)
+        return undefined;
+    const failureClass = block.FAILURE_CLASS ?? "unknown";
+    const parsedFailureClass = repairArtifactSchema.shape.failureClass.safeParse(failureClass);
+    if (!parsedFailureClass.success)
+        return undefined;
+    return {
+        schemaVersion: 1,
+        verdict: "request-revision",
+        failureClass: parsedFailureClass.data,
+        rootCause: block.ROOT_CAUSE ?? "Legacy supervisor block did not record rootCause.",
+        fixScope: block.FIX_SCOPE ? block.FIX_SCOPE.split(",").map((item) => item.trim()).filter(Boolean) : [],
+        invariant: block.INVARIANT ?? "Preserve verified behavior.",
+        evidenceRefs: raw.runId ? [raw.runId] : [],
+        rawLogFallbackAllowed: true,
+    };
+}
+function extractRepairArtifact(raw) {
+    const parsed = repairArtifactSchema.safeParse(raw.repairArtifact);
+    if (parsed.success)
+        return parsed.data;
+    return parseLegacyArtifact(raw);
+}
+function addPattern(patterns, runId, artifact) {
+    const fixScopeShape = normalizeScopeShape(artifact.fixScope);
+    const key = [
+        artifact.failureClass,
+        fixScopeShape,
+        artifact.invariant.toLowerCase(),
+    ].join("|");
+    const existing = patterns.get(key);
+    if (existing) {
+        existing.count += 1;
+        if (!existing.sourceRunIds.includes(runId))
+            existing.sourceRunIds.push(runId);
+        for (const ref of artifact.evidenceRefs) {
+            if (!existing.evidenceRefs.includes(ref))
+                existing.evidenceRefs.push(ref);
+        }
+        if (!existing.rootCauses.includes(artifact.rootCause)) {
+            existing.rootCauses.push(artifact.rootCause);
+        }
+        return;
+    }
+    patterns.set(key, {
+        key,
+        failureClass: artifact.failureClass,
+        fixScopeShape,
+        invariant: artifact.invariant,
+        sourceRunIds: [runId],
+        evidenceRefs: [...artifact.evidenceRefs],
+        rootCauses: [artifact.rootCause],
+        count: 1,
+    });
+}
+export function formatKnowledgeProposalMarkdown(patterns) {
+    const lines = [
+        "# loop-agent Learned Guidance Proposal",
+        "",
+        "Status: human-gated proposal",
+        "",
+        "This proposal is generated from completed convergence patterns. It is advisory process guidance only; it does not modify accepted learned skill files.",
+        "",
+        "## Candidate Patterns",
+        "",
+    ];
+    for (const pattern of patterns) {
+        lines.push(`### ${pattern.failureClass} / ${pattern.fixScopeShape}`, "", `- count: ${pattern.count}`, `- source runs: ${pattern.sourceRunIds.join(", ")}`, `- invariant: ${pattern.invariant}`, `- root causes: ${pattern.rootCauses.join("; ")}`, `- evidence refs: ${pattern.evidenceRefs.length > 0 ? pattern.evidenceRefs.join(", ") : "(none)"}`, "- when to apply: use when the failure class, bounded fix scope, and invariant match a new supervised DAG repair round.", "- when not to apply: do not apply when the task has different ownership boundaries, missing full verification, or higher-risk public contract changes.", "- safety notes: keep guidance Markdown-only, advisory, and subordinate to writeSet governance and final shell verification.", "");
+    }
+    if (patterns.length === 0) {
+        lines.push("No accepted convergence patterns were found.", "");
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function curateKnowledgePatterns(input) {
+    const patternsPath = path.join(input.repoRoot, ".harness", "knowledge", "patterns.jsonl");
+    if (!(await exists(patternsPath))) {
+        return {
+            ok: true,
+            patternsPath,
+            patternCount: 0,
+            safetyFindings: [],
+            message: "no patterns.jsonl found; no proposal generated",
+        };
+    }
+    const raw = await readFile(patternsPath, "utf-8");
+    const grouped = new Map();
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const parsed = JSON.parse(line);
+        if (parsed.type !== "dag-convergence-repair")
+            continue;
+        if (parsed.terminalReason && parsed.terminalReason !== "hard-verify-pass")
+            continue;
+        const artifact = extractRepairArtifact(parsed);
+        if (!artifact || artifact.verdict !== "request-revision")
+            continue;
+        addPattern(grouped, parsed.runId ?? "unknown-run", artifact);
+    }
+    const patterns = Array.from(grouped.values()).sort((a, b) => a.key.localeCompare(b.key));
+    const proposalMarkdown = formatKnowledgeProposalMarkdown(patterns);
+    const outputPath = input.outputPath
+        ? path.resolve(input.repoRoot, input.outputPath)
+        : undefined;
+    const safetyFindings = auditSkillMarkdownContent({
+        repoRoot: input.repoRoot,
+        filePath: outputPath ?? path.join(input.repoRoot, ".harness", "knowledge", "learned-proposal.md"),
+        content: proposalMarkdown,
+        profile: "learned",
+    });
+    if (safetyFindings.length > 0) {
+        return {
+            ok: false,
+            patternsPath,
+            outputPath,
+            patternCount: patterns.length,
+            proposalMarkdown,
+            safetyFindings,
+            message: "proposal failed skill safety audit",
+        };
+    }
+    if (outputPath) {
+        await mkdir(path.dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, proposalMarkdown, "utf-8");
+    }
+    return {
+        ok: true,
+        patternsPath,
+        outputPath,
+        patternCount: patterns.length,
+        proposalMarkdown,
+        safetyFindings,
+        message: patterns.length === 0
+            ? "patterns found but none qualified for proposal"
+            : "proposal generated",
+    };
+}

package/dist/workflows/dag/lifecycle.js

@@ -0,0 +1,484 @@
+import { access, mkdir, readFile, readdir, rename, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { parseDagSpec } from "./types.js";
+const DAG_LIFECYCLE_SCAN_ORDER = [
+    "paused",
+    "active",
+    "completed",
+];
+const PAUSED_APPROVAL_FLOW_HINT = "Use dag approve / dag reject, then dag resume when approved.";
+export const DAG_RUNS_DIR = path.join(".harness", "dag-runs");
+export function getDagRunDir(cwd, lifecycle, runId) {
+    return path.join(cwd, DAG_RUNS_DIR, lifecycle, runId);
+}
+export async function dagRunDirExists(runDir) {
+    try {
+        await access(runDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readDagRunState(runDir) {
+    const raw = JSON.parse(await readFile(path.join(runDir, "state.json"), "utf-8"));
+    return raw;
+}
+export async function writeDagRunState(runDir, state) {
+    await writeFile(path.join(runDir, "state.json"), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+export async function readDagRunSpec(runDir) {
+    const raw = JSON.parse(await readFile(path.join(runDir, "run.json"), "utf-8"));
+    return parseDagSpec(raw);
+}
+export async function locateDagRun(cwd, runId) {
+    for (const lifecycle of ["paused", "active", "completed"]) {
+        const runDir = getDagRunDir(cwd, lifecycle, runId);
+        if (await dagRunDirExists(runDir)) {
+            return { lifecycle, runDir };
+        }
+    }
+    return undefined;
+}
+export async function explainPausedRunLookupFailure(cwd, runId) {
+    const located = await locateDagRun(cwd, runId);
+    if (!located) {
+        return `paused dag run not found: ${runId}`;
+    }
+    if (located.lifecycle === "completed") {
+        let detail = `dag run ${runId} is already completed`;
+        try {
+            const state = await readDagRunState(located.runDir);
+            detail += ` (status=${state.status}`;
+            if (state.failureCategory) {
+                detail += `, failureCategory=${state.failureCategory}`;
+            }
+            detail += ")";
+        }
+        catch {
+            // keep base message
+        }
+        return `${detail}; approve/reject require a paused run`;
+    }
+    if (located.lifecycle === "active") {
+        try {
+            const state = await readDagRunState(located.runDir);
+            if (state.status === "running" && state.humanDecisionNodeId) {
+                return `dag run ${runId} is active and awaiting dag resume (already approved)`;
+            }
+            return `dag run ${runId} is active (status=${state.status}); approve/reject require paused lifecycle`;
+        }
+        catch {
+            return `dag run ${runId} is active but state.json is unreadable`;
+        }
+    }
+    return `paused dag run not found: ${runId}`;
+}
+export async function requirePausedDagRun(cwd, runId) {
+    const runDir = getDagRunDir(cwd, "paused", runId);
+    if (!(await dagRunDirExists(runDir))) {
+        throw new Error(await explainPausedRunLookupFailure(cwd, runId));
+    }
+    const state = await readDagRunState(runDir);
+    if (state.runId !== runId) {
+        throw new Error(`run-id mismatch in paused run: expected ${runId}, got ${state.runId}`);
+    }
+    if (state.status !== "paused") {
+        throw new Error(`dag run ${runId} is not paused (status=${state.status})`);
+    }
+    if (!state.pausedByNodeId) {
+        throw new Error(`dag run ${runId} is paused but missing pausedByNodeId`);
+    }
+    const spec = await readDagRunSpec(runDir);
+    return { runDir, state, spec };
+}
+export async function requireActiveDagRun(cwd, runId) {
+    const runDir = getDagRunDir(cwd, "active", runId);
+    if (!(await dagRunDirExists(runDir))) {
+        throw new Error(`active dag run not found: ${runId}`);
+    }
+    const state = await readDagRunState(runDir);
+    if (state.runId !== runId) {
+        throw new Error(`run-id mismatch in active run: expected ${runId}, got ${state.runId}`);
+    }
+    const spec = await readDagRunSpec(runDir);
+    return { runDir, state, spec };
+}
+export async function assertDagRunTransferTargetAvailable(targetRunDir) {
+    try {
+        await access(targetRunDir);
+    }
+    catch {
+        return;
+    }
+    throw new Error(`refusing to transfer dag run because target already exists: ${targetRunDir}`);
+}
+export async function transferDagRunDir(sourceRunDir, targetRunDir) {
+    await mkdir(path.dirname(targetRunDir), { recursive: true });
+    await assertDagRunTransferTargetAvailable(targetRunDir);
+    await rename(sourceRunDir, targetRunDir);
+    return targetRunDir;
+}
+export async function readHumanEscalation(runDir, nodeId) {
+    const escalationPath = path.join(runDir, nodeId, "human-escalation.json");
+    const raw = JSON.parse(await readFile(escalationPath, "utf-8"));
+    if (!raw.humanEscalation?.options?.length) {
+        throw new Error(`missing human escalation options for node ${nodeId}`);
+    }
+    return raw;
+}
+export async function writeHumanApprovalArtifact(input) {
+    const nodeDir = path.join(input.runDir, input.nodeId);
+    await mkdir(nodeDir, { recursive: true });
+    const artifactPath = path.join(nodeDir, "human-approval.json");
+    await writeFile(artifactPath, `${JSON.stringify(input.artifact, null, 2)}\n`, "utf-8");
+    return artifactPath;
+}
+export async function writeHumanRejectionArtifact(input) {
+    const nodeDir = path.join(input.runDir, input.nodeId);
+    await mkdir(nodeDir, { recursive: true });
+    const artifactPath = path.join(nodeDir, "human-rejection.json");
+    await writeFile(artifactPath, `${JSON.stringify(input.artifact, null, 2)}\n`, "utf-8");
+    return artifactPath;
+}
+export async function readHumanApprovalArtifact(runDir, nodeId) {
+    const artifactPath = path.join(runDir, nodeId, "human-approval.json");
+    const raw = JSON.parse(await readFile(artifactPath, "utf-8"));
+    return raw;
+}
+export function humanApprovalExists(runDir, nodeId) {
+    return path.join(runDir, nodeId, "human-approval.json");
+}
+export async function humanApprovalArtifactExists(runDir, nodeId) {
+    try {
+        await access(humanApprovalExists(runDir, nodeId));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const TERMINAL_RUN_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+]);
+export function isTerminalDagRunStatus(status) {
+    return TERMINAL_RUN_STATUSES.has(status);
+}
+function listPendingNodeIds(state) {
+    return Object.values(state.nodes)
+        .filter((node) => node.status === "PENDING")
+        .map((node) => node.id);
+}
+function listFinishedNodeIds(state) {
+    return Object.values(state.nodes)
+        .filter((node) => node.status === "FINISHED")
+        .map((node) => node.id);
+}
+export function deriveOperatorNextAction(input) {
+    if (input.healthIssues.some((issue) => issue.severity === "error")) {
+        return "Inspect health issues with dag doctor before approve/reject/resume.";
+    }
+    if (input.lifecycle === "paused" && input.state.status === "paused") {
+        return PAUSED_APPROVAL_FLOW_HINT;
+    }
+    if (input.lifecycle === "active" &&
+        input.state.status === "running" &&
+        input.state.humanDecisionNodeId) {
+        return input.hasHumanApproval
+            ? "Run is approved; use dag resume to continue."
+            : "Missing human-approval.json; do not resume until approval artifacts are restored.";
+    }
+    if (input.lifecycle === "active" &&
+        input.state.status === "running" &&
+        !input.state.humanDecisionNodeId) {
+        return "Monitor in-progress active run; no approve/resume action yet.";
+    }
+    if (input.lifecycle === "active" &&
+        isTerminalDagRunStatus(input.state.status)) {
+        return "Stale active directory detected; review harness playbook and archive or remove after inspection.";
+    }
+    if (input.lifecycle === "completed") {
+        if (input.state.failureCategory === "human-rejected") {
+            return "Run was human-rejected; revise contract and start a new run.";
+        }
+        if (input.state.status === "finished") {
+            return "Run completed; no lifecycle action required.";
+        }
+        return "Inspect completed run artifacts before any retry.";
+    }
+    return "Inspect run facts with dag status and dag report --json.";
+}
+export async function detectDagRunHealthIssues(input) {
+    const issues = [];
+    const { runId, lifecycle, runDir, state } = input;
+    if (state.runId !== runId) {
+        issues.push({
+            code: "run-id-mismatch",
+            severity: "error",
+            message: `state.runId=${state.runId} does not match directory runId=${runId}`,
+            advisoryAction: "Inspect state.json and directory naming; do not auto-mutate completed facts.",
+        });
+    }
+    if (lifecycle === "active" && isTerminalDagRunStatus(state.status)) {
+        issues.push({
+            code: "terminal-in-active",
+            severity: "warning",
+            message: `Run has terminal status=${state.status} but remains under active/`,
+            advisoryAction: "Review and archive to completed/ or remove stale directory per harness playbook.",
+        });
+    }
+    if (lifecycle === "active" && state.status === "paused") {
+        issues.push({
+            code: "paused-in-active",
+            severity: "warning",
+            message: "Run status=paused but directory is active/; expected paused/",
+            advisoryAction: "Inspect with dag doctor; approve/reject/resume may fail until facts are consistent.",
+        });
+    }
+    if (lifecycle === "paused" && state.status !== "paused") {
+        issues.push({
+            code: "lifecycle-status-mismatch",
+            severity: "warning",
+            message: `Run is under paused/ but status=${state.status}`,
+            advisoryAction: "Use dag doctor; approve/reject/resume may fail until lifecycle facts are consistent.",
+        });
+    }
+    if (lifecycle === "active" &&
+        state.status === "running" &&
+        state.humanDecisionNodeId) {
+        const hasApproval = await humanApprovalArtifactExists(runDir, state.humanDecisionNodeId);
+        if (!hasApproval) {
+            issues.push({
+                code: "missing-approval-artifact",
+                severity: "error",
+                message: `humanDecisionNodeId=${state.humanDecisionNodeId} but human-approval.json is missing`,
+                advisoryAction: "Do not resume; inspect node artifacts and re-approve if needed.",
+            });
+        }
+    }
+    if (lifecycle === "completed" &&
+        (state.status === "running" || state.status === "paused")) {
+        issues.push({
+            code: "non-terminal-in-completed",
+            severity: "warning",
+            message: `Run is under completed/ but status=${state.status}`,
+            advisoryAction: "Historical facts may be inconsistent; treat as manual-review only.",
+        });
+    }
+    return issues;
+}
+async function listRunsInLifecycleDir(repoRoot, lifecycle) {
+    const lifecycleDir = getDagRunDir(repoRoot, lifecycle, "");
+    try {
+        await access(lifecycleDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = await readdir(lifecycleDir, { withFileTypes: true });
+    const located = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === ".gitkeep")
+            continue;
+        const runDir = path.join(lifecycleDir, entry.name);
+        try {
+            await access(path.join(runDir, "state.json"));
+        }
+        catch {
+            located.push({
+                runId: entry.name,
+                lifecycle,
+                runDir,
+            });
+            continue;
+        }
+        located.push({ runId: entry.name, lifecycle, runDir });
+    }
+    return located;
+}
+export async function listAllDagRunEntries(repoRoot) {
+    const located = [];
+    for (const lifecycle of DAG_LIFECYCLE_SCAN_ORDER) {
+        located.push(...(await listRunsInLifecycleDir(repoRoot, lifecycle)));
+    }
+    return located.sort((left, right) => {
+        const lifecycleCompare = DAG_LIFECYCLE_SCAN_ORDER.indexOf(left.lifecycle)
+            - DAG_LIFECYCLE_SCAN_ORDER.indexOf(right.lifecycle);
+        if (lifecycleCompare !== 0)
+            return lifecycleCompare;
+        return left.runId.localeCompare(right.runId);
+    });
+}
+export async function buildDagOperatorRunSummary(entry) {
+    let state;
+    try {
+        state = await readDagRunState(entry.runDir);
+    }
+    catch {
+        const healthIssues = [
+            {
+                code: "missing-state-json",
+                severity: "error",
+                message: `Run directory ${entry.runId} is missing readable state.json`,
+                advisoryAction: "Inspect directory contents; do not approve/resume until state facts exist.",
+            },
+        ];
+        return {
+            runId: entry.runId,
+            title: entry.runId,
+            lifecycle: entry.lifecycle,
+            status: "pending",
+            pausedByNodeId: null,
+            pauseReason: null,
+            failureCategory: null,
+            humanDecisionNodeId: null,
+            pendingNodes: [],
+            finishedNodes: [],
+            healthIssues,
+            nextRecommendedAction: deriveOperatorNextAction({
+                lifecycle: entry.lifecycle,
+                state: {
+                    version: 1,
+                    title: entry.runId,
+                    runId: entry.runId,
+                    cwd: "",
+                    startedAt: "",
+                    status: "pending",
+                    ranks: [],
+                    nodes: {},
+                },
+                hasHumanApproval: false,
+                healthIssues,
+            }),
+        };
+    }
+    const healthIssues = await detectDagRunHealthIssues({
+        runId: entry.runId,
+        lifecycle: entry.lifecycle,
+        runDir: entry.runDir,
+        state,
+    });
+    const hasHumanApproval = state.humanDecisionNodeId
+        ? await humanApprovalArtifactExists(entry.runDir, state.humanDecisionNodeId)
+        : false;
+    return {
+        runId: state.runId,
+        title: state.title,
+        lifecycle: entry.lifecycle,
+        status: state.status,
+        startedAt: state.startedAt,
+        finishedAt: state.finishedAt,
+        pausedByNodeId: state.pausedByNodeId ?? null,
+        pauseReason: state.pauseReason ?? null,
+        failureCategory: state.failureCategory ?? null,
+        humanDecisionNodeId: state.humanDecisionNodeId ?? null,
+        pendingNodes: listPendingNodeIds(state),
+        finishedNodes: listFinishedNodeIds(state),
+        healthIssues,
+        nextRecommendedAction: deriveOperatorNextAction({
+            lifecycle: entry.lifecycle,
+            state,
+            hasHumanApproval,
+            healthIssues,
+        }),
+        approvalFlow: entry.lifecycle === "paused" && state.status === "paused"
+            ? PAUSED_APPROVAL_FLOW_HINT
+            : undefined,
+    };
+}
+export async function buildDagStatusReport(repoRoot, runId) {
+    const located = await locateDagRun(repoRoot, runId);
+    if (!located) {
+        throw new Error(`dag run not found: ${runId}`);
+    }
+    const summary = await buildDagOperatorRunSummary({ ...located, runId });
+    const hasHumanApproval = summary.humanDecisionNodeId
+        ? await humanApprovalArtifactExists(located.runDir, summary.humanDecisionNodeId)
+        : false;
+    return {
+        ...summary,
+        runDir: located.runDir,
+        escalationArtifactPath: summary.pausedByNodeId
+            ? path.join(located.runDir, summary.pausedByNodeId, "human-escalation.json")
+            : null,
+        hasHumanApproval,
+    };
+}
+function collectDoctorRecommendedActions(runs) {
+    const actions = new Set();
+    for (const run of runs) {
+        if (run.nextRecommendedAction) {
+            actions.add(run.nextRecommendedAction);
+        }
+        for (const issue of run.healthIssues) {
+            actions.add(issue.advisoryAction);
+        }
+    }
+    if (actions.size === 0) {
+        actions.add("No DAG runtime entries found under .harness/dag-runs/.");
+    }
+    return [...actions];
+}
+export async function buildDagDoctorReport(repoRoot) {
+    const entries = await listAllDagRunEntries(repoRoot);
+    const runs = await Promise.all(entries.map(buildDagOperatorRunSummary));
+    const healthIssueCount = runs.reduce((count, run) => count + run.healthIssues.length, 0);
+    return {
+        schemaVersion: 1,
+        summary: {
+            active: runs.filter((run) => run.lifecycle === "active").length,
+            paused: runs.filter((run) => run.lifecycle === "paused").length,
+            completed: runs.filter((run) => run.lifecycle === "completed").length,
+            healthIssueCount,
+        },
+        runs,
+        recommendedActions: collectDoctorRecommendedActions(runs),
+        advisoryOnly: true,
+    };
+}
+export function parseDagStatusArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag status --run-id <id>");
+    }
+    let runId;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag status flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId) {
+        throw new Error("dag status requires --run-id <id>");
+    }
+    return { runId };
+}
+export async function runDagStatus(repoRoot, rawArgs) {
+    const parsed = parseDagStatusArgs(rawArgs);
+    const report = await buildDagStatusReport(repoRoot, parsed.runId);
+    console.log(JSON.stringify(report, null, 2));
+}
+export function parseDagDoctorArgs(args) {
+    for (const arg of args) {
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag doctor flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    return {};
+}
+export async function runDagDoctor(repoRoot, rawArgs) {
+    parseDagDoctorArgs(rawArgs);
+    const report = await buildDagDoctorReport(repoRoot);
+    console.log(JSON.stringify(report, null, 2));
+}