@tea-agent/loop-agent 0.1.0

package/dist/workflows/dag/validate.js

@@ -0,0 +1,527 @@
+import { DEFAULT_DAG_EXECUTOR_MODELS, ENV_VAR_NAME_PATTERN, } from "./types.js";
+import { resolveShellCommands } from "../../executors/shell-executor.js";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { topoSortToRanks } from "./topo.js";
+const GOVERNANCE_WARNING_TYPES = new Set([
+    "read-only-missing-artifacts-forbidden",
+    "read-only-prompt-mentions-artifact-writes",
+    "shell-dag-active-check-repo-without-env",
+    "shell-verdict-gate-summary-md-source",
+    "shell-verdict-gate-grep-pattern",
+    "shell-verdict-gate-multi-command-state",
+    "shell-verdict-gate-handwritten-inline",
+]);
+const ROOT_ARTIFACT_PATH_PROBES = [
+    "artifacts/修改记录.md",
+    "artifacts/验证结果.md",
+    "artifacts/_probe_.md",
+];
+const ARTIFACT_WRITE_SIGNAL_PATTERNS = [
+    "artifacts/",
+    "修改记录.md",
+    "验证结果.md",
+];
+function isGovernanceWarning(issue) {
+    return GOVERNANCE_WARNING_TYPES.has(issue.type);
+}
+export function collectGovernanceWarnings(issues) {
+    return issues.filter(isGovernanceWarning);
+}
+function collectBlockingIssues(issues, options = {}) {
+    if (options.strictGovernance) {
+        return [...issues];
+    }
+    return issues.filter((issue) => !isGovernanceWarning(issue));
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function probePathsForWriteSetEntry(entry) {
+    const normalized = normalizePath(entry);
+    if (!normalized.includes("*")) {
+        return [normalized];
+    }
+    const concrete = normalized
+        .replace(/\/\*\*$/, "/_probe_")
+        .replace(/\*\*$/, "_probe_")
+        .replace(/\*/g, "_");
+    return Array.from(new Set([normalized, concrete]));
+}
+function writeSetEntryWithinAllowed(entry, allowedPaths) {
+    const probes = probePathsForWriteSetEntry(entry);
+    return probes.some((probe) => allowedPaths.some((allowed) => pathMatchesPattern(probe, allowed)));
+}
+function writeSetEntryHitsForbidden(entry, forbiddenPaths) {
+    const probes = probePathsForWriteSetEntry(entry);
+    return probes.some((probe) => forbiddenPaths.some((forbidden) => pathMatchesPattern(probe, forbidden)));
+}
+function forbiddenPathsExcludeRootArtifacts(forbiddenPaths) {
+    return ROOT_ARTIFACT_PATH_PROBES.some((probe) => forbiddenPaths.some((forbidden) => pathMatchesPattern(probe, forbidden)));
+}
+function promptMentionsRootArtifactWrite(prompt) {
+    const lower = prompt.toLowerCase();
+    for (const signal of ARTIFACT_WRITE_SIGNAL_PATTERNS) {
+        const normalizedSignal = signal.toLowerCase();
+        const index = lower.indexOf(normalizedSignal);
+        if (index === -1)
+            continue;
+        const context = lower.slice(Math.max(0, index - 48), index + 96);
+        const negated = /(do not|don't|must not|should not|禁止|不得|不要|不应).{0,48}(write|edit|modify|create|update|artifacts|修改记录|验证结果)/i.test(context) ||
+            /不(改|写|更新|创建|编辑).{0,48}(artifacts|修改记录|验证结果)/i.test(context);
+        if (negated)
+            continue;
+        const hasWriteVerb = /(write|update|create|edit|modify|save|append|record|output).{0,64}(artifacts|修改记录|验证结果)/i.test(context) ||
+            /(artifacts|修改记录|验证结果).{0,64}(write|update|create|edit|modify|save|append|record|output)/i.test(context) ||
+            /(写入|写|更新|修改|保存|追加|记录|输出).{0,64}(artifacts|修改记录|验证结果)/i.test(context) ||
+            /(artifacts|修改记录|验证结果).{0,64}(写入|写|更新|修改|保存|追加|记录|输出)/i.test(context);
+        if (hasWriteVerb) {
+            return signal;
+        }
+    }
+    return undefined;
+}
+function shellCommandRunsCheckRepo(command) {
+    return /(^|[\s/])check-repo\.sh(\s|$)|(^|\s)bash\s+scripts\/check-repo\.sh(\s|$)/.test(command);
+}
+function shellCommandSetsActiveDagEnv(command) {
+    return /(^|[^A-Za-z0-9_])HARNESS_ALLOW_ACTIVE_DAG_RUNS=1(\s|;|&&|$)/.test(command);
+}
+function shellCommandUsesSummaryMdVerdictSource(command) {
+    return (/result\.summary\.md/.test(command) &&
+        (/\bVERDICT\b/i.test(command) ||
+            /\.harness\/dag-runs\/active/.test(command) ||
+            /\bgate\b/i.test(command)));
+}
+function shellCommandUsesGrepVerdictSearch(command) {
+    return (/\bgrep\b/.test(command) &&
+        (/\bVERDICT\b/.test(command) || /grep.*VERDICT|VERDICT.*grep/.test(command)));
+}
+function shellCommandReadsActiveOrCurrentRunJson(command) {
+    return (/\.harness\/dag-runs\/active/.test(command) ||
+        /\bHARNESS_DAG_RUN_DIR\b/.test(command) ||
+        /find\s+\.harness\/dag-runs\/active/.test(command));
+}
+function shellCommandUsesVerdictJsonParser(command) {
+    return (/assistantText\s*\?\?\s*raw\.stdout/.test(command) ||
+        /raw\.assistantText\s*\|\|\s*raw\.stdout/.test(command) ||
+        /raw\.assistantText\s*\?\?\s*raw\.stdout/.test(command) ||
+        /assistantText\s*\|\|\s*raw\.stdout/.test(command) ||
+        /assistantText\s*\|\|\s*stdout/.test(command));
+}
+function shellCommandLooksLikeHandWrittenVerdictGate(command) {
+    return (shellCommandReadsActiveOrCurrentRunJson(command) &&
+        (/\bVERDICT\b/i.test(command) ||
+            shellCommandUsesVerdictJsonParser(command)));
+}
+function shellCommandsLookLikeMultiCommandVerdictGate(commands) {
+    if (commands.length <= 1)
+        return false;
+    const combined = commands.join("\n");
+    return (shellCommandReadsActiveOrCurrentRunJson(combined) &&
+        (/\bVERDICT\b/i.test(combined) ||
+            shellCommandUsesVerdictJsonParser(combined)));
+}
+function validateVerdictGateConfig(task, spec, issues) {
+    const verdictGate = task.shell?.verdictGate;
+    if (!verdictGate) {
+        return;
+    }
+    if (task.executor !== "shell") {
+        issues.push({
+            type: "invalid-verdict-gate-config",
+            message: `task ${task.id} shell.verdictGate requires executor=shell`,
+        });
+        return;
+    }
+    const upstreamIds = new Set(task.depends_on);
+    if (!upstreamIds.has(verdictGate.fromNodeId)) {
+        issues.push({
+            type: "invalid-verdict-gate-config",
+            message: `task ${task.id} shell.verdictGate.fromNodeId "${verdictGate.fromNodeId}" must appear in depends_on`,
+        });
+    }
+    const upstreamTask = spec.tasks.find((candidate) => candidate.id === verdictGate.fromNodeId);
+    if (upstreamTask && upstreamTask.executor === "shell") {
+        issues.push({
+            type: "invalid-verdict-gate-config",
+            message: `task ${task.id} shell.verdictGate.fromNodeId "${verdictGate.fromNodeId}" must reference a non-shell upstream verdict node`,
+        });
+    }
+    for (const accepted of verdictGate.accept) {
+        if (accepted.trim().length === 0) {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate.accept entries must be non-empty`,
+            });
+            break;
+        }
+    }
+}
+function validateRepairArtifactGateConfig(task, spec, issues) {
+    const repairArtifactGate = task.shell?.repairArtifactGate;
+    if (!repairArtifactGate)
+        return;
+    if (task.executor !== "shell") {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate requires executor=shell`,
+        });
+        return;
+    }
+    const upstreamIds = new Set(task.depends_on);
+    if (!upstreamIds.has(repairArtifactGate.fromNodeId)) {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate.fromNodeId "${repairArtifactGate.fromNodeId}" must appear in depends_on`,
+        });
+    }
+    const upstream = spec.tasks.find((candidate) => candidate.id === repairArtifactGate.fromNodeId);
+    if (!upstream)
+        return;
+    if (upstream.executor === "shell") {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate.fromNodeId "${repairArtifactGate.fromNodeId}" must reference a non-shell upstream artifact node`,
+        });
+    }
+}
+function validateShellVerdictGateGovernance(task, commands, issues) {
+    if (task.executor !== "shell") {
+        return;
+    }
+    const explicitCommands = (task.shell?.commands ?? []).filter((command) => command.trim().length > 0);
+    for (const command of commands) {
+        if (shellCommandUsesSummaryMdVerdictSource(command)) {
+            issues.push({
+                type: "shell-verdict-gate-summary-md-source",
+                message: `task ${task.id} shell command reads result.summary.md for verdict gating; use shell.verdictGate and canonical <fromNodeId>.json instead`,
+            });
+        }
+        if (shellCommandUsesGrepVerdictSearch(command)) {
+            issues.push({
+                type: "shell-verdict-gate-grep-pattern",
+                message: `task ${task.id} shell command uses grep-based VERDICT search; use shell.verdictGate with exact accept matching instead`,
+            });
+        }
+    }
+    if (shellCommandsLookLikeMultiCommandVerdictGate(explicitCommands)) {
+        issues.push({
+            type: "shell-verdict-gate-multi-command-state",
+            message: `task ${task.id} spreads verdict gate state across multiple shell.commands entries; use shell.verdictGate so the gate is a single command`,
+        });
+    }
+    if (!task.shell?.verdictGate &&
+        explicitCommands.some(shellCommandLooksLikeHandWrittenVerdictGate)) {
+        issues.push({
+            type: "shell-verdict-gate-handwritten-inline",
+            message: `task ${task.id} uses fragile inline verdict gate shell; prefer shell.verdictGate with fromNodeId and accept`,
+        });
+    }
+}
+function writeSetEntriesOverlap(a, b) {
+    if (pathMatchesPattern(a, b) || pathMatchesPattern(b, a)) {
+        return true;
+    }
+    const probesA = probePathsForWriteSetEntry(a);
+    const probesB = probePathsForWriteSetEntry(b);
+    return probesA.some((probeA) => probesB.some((probeB) => probeA === probeB ||
+        pathMatchesPattern(probeA, b) ||
+        pathMatchesPattern(probeB, a)));
+}
+function shouldValidateWritePolicy(spec, task) {
+    return (spec.version === 2 ||
+        task.writePolicy !== undefined ||
+        task.writeSet !== undefined);
+}
+function resolveWritePolicy(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy;
+}
+function validateTaskWritePolicy(task, spec, issues) {
+    if (!shouldValidateWritePolicy(spec, task)) {
+        return;
+    }
+    const writePolicy = resolveWritePolicy(task, spec);
+    const writeSet = task.writeSet ?? [];
+    const allowedPaths = task.allowedPaths ?? [];
+    const forbiddenPaths = task.forbiddenPaths ?? [];
+    if (writePolicy === "read-only") {
+        if (!forbiddenPathsExcludeRootArtifacts(forbiddenPaths)) {
+            issues.push({
+                type: "read-only-missing-artifacts-forbidden",
+                message: `task ${task.id} is read-only but forbiddenPaths does not exclude artifacts/**; root artifacts are not per-node scratchpads`,
+            });
+        }
+        const artifactWriteSignal = promptMentionsRootArtifactWrite(task.subtask_prompt);
+        if (artifactWriteSignal) {
+            issues.push({
+                type: "read-only-prompt-mentions-artifact-writes",
+                message: `task ${task.id} is read-only but subtask_prompt mentions root artifact write target "${artifactWriteSignal}"; return findings in node output instead`,
+            });
+        }
+    }
+    if (writePolicy === "exclusive" && writeSet.length === 0) {
+        issues.push({
+            type: "missing-write-set",
+            message: `task ${task.id} (exclusive) requires a non-empty writeSet`,
+        });
+        return;
+    }
+    if (writeSet.length === 0) {
+        return;
+    }
+    for (const entry of writeSet) {
+        if (forbiddenPaths.length > 0 &&
+            writeSetEntryHitsForbidden(entry, forbiddenPaths)) {
+            issues.push({
+                type: "write-set-forbidden",
+                message: `task ${task.id} writeSet entry "${entry}" matches forbiddenPaths`,
+            });
+            continue;
+        }
+        if (allowedPaths.length > 0 &&
+            !writeSetEntryWithinAllowed(entry, allowedPaths)) {
+            issues.push({
+                type: "write-set-out-of-scope",
+                message: `task ${task.id} writeSet entry "${entry}" is outside allowedPaths`,
+            });
+        }
+    }
+}
+function validateSameRankWriteSetConflicts(spec, ranks, issues) {
+    const taskById = new Map(spec.tasks.map((task) => [task.id, task]));
+    for (const rank of ranks) {
+        const exclusiveWriters = rank
+            .map((id) => taskById.get(id))
+            .filter((task) => {
+            if (!task)
+                return false;
+            if (!shouldValidateWritePolicy(spec, task))
+                return false;
+            return resolveWritePolicy(task, spec) === "exclusive";
+        });
+        for (let i = 0; i < exclusiveWriters.length; i += 1) {
+            for (let j = i + 1; j < exclusiveWriters.length; j += 1) {
+                const left = exclusiveWriters[i];
+                const right = exclusiveWriters[j];
+                const leftSet = left.writeSet ?? [];
+                const rightSet = right.writeSet ?? [];
+                for (const leftEntry of leftSet) {
+                    for (const rightEntry of rightSet) {
+                        if (writeSetEntriesOverlap(leftEntry, rightEntry)) {
+                            issues.push({
+                                type: "write-set-overlap",
+                                message: `tasks ${left.id} and ${right.id} have overlapping writeSet entries at same rank: "${leftEntry}" and "${rightEntry}"`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function isWriteGuardedAgentTask(task) {
+    return (task?.executor === "cursor" ||
+        (task?.executor === "pi" && task.toolProfile === "write"));
+}
+function validateSameRankAgentAttributionRisks(spec, ranks, issues) {
+    const taskById = new Map(spec.tasks.map((task) => [task.id, task]));
+    for (const rank of ranks) {
+        const guardedTasks = rank
+            .map((id) => taskById.get(id))
+            .filter(isWriteGuardedAgentTask);
+        const hasExclusiveWriter = guardedTasks.some((task) => resolveWritePolicy(task, spec) === "exclusive");
+        if (!hasExclusiveWriter)
+            continue;
+        for (const task of guardedTasks) {
+            const policy = resolveWritePolicy(task, spec) ?? "read-only";
+            if (policy === "read-only" || policy === "none") {
+                issues.push({
+                    type: "same-rank-writer-attribution-risk",
+                    message: `same rank mixes read-only ${task.executor} task ${task.id} with a write-capable agent; add depends_on or run serially to avoid write attribution risk`,
+                });
+            }
+        }
+    }
+}
+function validateShellTaskConfig(task, spec, issues) {
+    if (task.executor !== "shell") {
+        return;
+    }
+    const shell = task.shell;
+    if (!shell) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, and/or shell.commands`,
+        });
+        return;
+    }
+    const commands = resolveShellCommands(shell);
+    if (commands.length === 0) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, and/or non-empty shell.commands`,
+        });
+    }
+    if (commands.some((command) => command.trim().length === 0)) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires non-empty shell command strings`,
+        });
+    }
+    const envAllowlist = shell.envAllowlist ?? [];
+    const runsRepoGovernance = commands.some(shellCommandRunsCheckRepo);
+    const hasActiveDagEnv = envAllowlist.includes("HARNESS_ALLOW_ACTIVE_DAG_RUNS") ||
+        commands.some(shellCommandSetsActiveDagEnv);
+    if (runsRepoGovernance && !hasActiveDagEnv) {
+        issues.push({
+            type: "shell-dag-active-check-repo-without-env",
+            message: `shell task ${task.id} runs check-repo.sh but does not set HARNESS_ALLOW_ACTIVE_DAG_RUNS=1; this can fail inside an active DAG`,
+        });
+    }
+    for (const envName of envAllowlist) {
+        if (!ENV_VAR_NAME_PATTERN.test(envName)) {
+            issues.push({
+                type: "invalid-shell-env",
+                message: `shell task ${task.id} envAllowlist entry "${envName}" is not a valid env var name`,
+            });
+        }
+    }
+    const timeoutMs = shell.timeoutMs;
+    if (timeoutMs !== undefined && !Number.isInteger(timeoutMs)) {
+        issues.push({
+            type: "invalid-shell-timeout",
+            message: `shell task ${task.id} timeoutMs must be an integer`,
+        });
+    }
+    const cwd = shell.cwd;
+    if (cwd &&
+        (cwd.startsWith("/") || normalizePath(cwd).split("/").includes(".."))) {
+        issues.push({
+            type: "shell-cwd-out-of-scope",
+            message: `shell task ${task.id} cwd must be relative to the DAG cwd and stay within it`,
+        });
+    }
+    validateVerdictGateConfig(task, spec, issues);
+    validateRepairArtifactGateConfig(task, spec, issues);
+    validateShellVerdictGateGovernance(task, commands, issues);
+}
+function validateStaticTaskConfig(task, issues) {
+    if (task.executor !== "static") {
+        return;
+    }
+    const staticConfig = task.static;
+    if (!staticConfig?.resultMarkdown?.trim()) {
+        issues.push({
+            type: "missing-static-config",
+            message: `static task ${task.id} requires static.resultMarkdown`,
+        });
+    }
+}
+function validateDecisionGateTaskConfig(task, issues) {
+    if (!task.decisionGate?.enabled) {
+        return;
+    }
+    if (task.executor !== "pi") {
+        issues.push({
+            type: "invalid-decision-gate-executor",
+            message: `task ${task.id} decisionGate requires executor=pi`,
+        });
+    }
+}
+export function collectExecutorModelWarnings(spec) {
+    const warnings = [];
+    const executors = Object.keys(DEFAULT_DAG_EXECUTOR_MODELS);
+    for (const executor of executors) {
+        const actualByComplexity = spec.executorModels?.[executor];
+        if (!actualByComplexity) {
+            continue;
+        }
+        for (const [complexityKey, actual] of Object.entries(actualByComplexity)) {
+            if (actual === undefined) {
+                continue;
+            }
+            const expected = DEFAULT_DAG_EXECUTOR_MODELS[executor][complexityKey];
+            if (actual !== expected) {
+                warnings.push({
+                    executor,
+                    complexity: complexityKey,
+                    expected,
+                    actual,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+export function collectForbiddenExecutorIssues(spec, forbiddenExecutors) {
+    if (forbiddenExecutors.length === 0)
+        return [];
+    const forbidden = new Set(forbiddenExecutors);
+    const rawTasks = spec.tasks ?? [];
+    return spec.tasks
+        .filter((task) => forbidden.has(task.executor))
+        .map((task, index) => ({
+        executor: task.executor,
+        taskId: task.id,
+        implicitDefault: rawTasks[index]?.executor === undefined,
+    }));
+}
+export function validateDagSpec(spec) {
+    const issues = [];
+    if (spec.tasks.length === 0) {
+        issues.push({
+            type: "empty-tasks",
+            message: "DAG must contain at least one task",
+        });
+        return issues;
+    }
+    const ids = new Set();
+    for (const task of spec.tasks) {
+        if (ids.has(task.id)) {
+            issues.push({
+                type: "duplicate-id",
+                message: `duplicate task id: ${task.id}`,
+            });
+        }
+        ids.add(task.id);
+    }
+    for (const task of spec.tasks) {
+        for (const dep of task.depends_on) {
+            if (dep === task.id) {
+                issues.push({
+                    type: "self-dependency",
+                    message: `task ${task.id} depends on itself`,
+                });
+            }
+            if (!ids.has(dep)) {
+                issues.push({
+                    type: "missing-dependency",
+                    message: `task ${task.id} depends on unknown id: ${dep}`,
+                });
+            }
+        }
+    }
+    const { hasCycle, cycleNodes, ranks } = topoSortToRanks(spec);
+    if (hasCycle) {
+        issues.push({
+            type: "cycle",
+            message: `cycle detected involving: ${cycleNodes.join(", ")}`,
+        });
+        return issues;
+    }
+    for (const task of spec.tasks) {
+        validateTaskWritePolicy(task, spec, issues);
+        validateShellTaskConfig(task, spec, issues);
+        validateStaticTaskConfig(task, issues);
+        validateDecisionGateTaskConfig(task, issues);
+    }
+    validateSameRankWriteSetConflicts(spec, ranks, issues);
+    validateSameRankAgentAttributionRisks(spec, ranks, issues);
+    return issues;
+}
+export function assertValidDagSpec(spec, options = {}) {
+    const issues = collectBlockingIssues(options.issues ?? validateDagSpec(spec), options);
+    if (issues.length > 0) {
+        throw new Error(`invalid DAG: ${issues.map((issue) => issue.message).join("; ")}`);
+    }
+}

package/dist/workflows/dynamic/artifacts.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export const evidenceRefSchema = z.object({
+    path: z.string().min(1),
+    kind: z.string().optional(),
+    status: z.string().optional(),
+    summary: z.string().min(1),
+});
+export const findingSchema = z.object({
+    id: z.string().min(1),
+    sourceNodeId: z.string().min(1),
+    targetRef: z.string().min(1),
+    title: z.string().min(1),
+    severity: z.enum(["low", "medium", "high", "critical"]),
+    evidence: z.array(evidenceRefSchema).default([]),
+    recommendation: z.string().min(1),
+});
+export const verificationSchema = z.object({
+    findingId: z.string().min(1),
+    verifierNodeId: z.string().min(1),
+    status: z.enum(["verified", "refuted", "uncertain"]),
+    reason: z.string().min(1),
+    evidence: z.array(evidenceRefSchema).default([]),
+});
+export const workflowReportSchema = z.object({
+    summary: z.string().min(1),
+    verifiedFindings: z.array(findingSchema),
+    uncertainFindings: z.array(findingSchema),
+    refutedFindingsRef: z.string().optional(),
+    evidenceRefs: z.array(evidenceRefSchema).default([]),
+});
+export function buildVerifiedFindingsReport(input) {
+    const findingsById = new Map(input.findings.map((finding) => [finding.id, finding]));
+    const verifiedFindings = [];
+    const uncertainFindings = [];
+    const refutedFindings = [];
+    const evidenceRefs = [];
+    for (const verification of input.verifications) {
+        const finding = findingsById.get(verification.findingId);
+        if (!finding)
+            continue;
+        if (verification.verifierNodeId === finding.sourceNodeId) {
+            uncertainFindings.push(finding);
+            evidenceRefs.push(...verification.evidence);
+            continue;
+        }
+        if (verification.status === "verified") {
+            verifiedFindings.push(finding);
+        }
+        else if (verification.status === "uncertain") {
+            uncertainFindings.push(finding);
+        }
+        else {
+            refutedFindings.push(finding);
+        }
+        evidenceRefs.push(...verification.evidence);
+    }
+    const report = workflowReportSchema.parse({
+        summary: `${verifiedFindings.length} verified, ${uncertainFindings.length} uncertain, ${refutedFindings.length} refuted finding(s).`,
+        verifiedFindings,
+        uncertainFindings,
+        refutedFindingsRef: refutedFindings.length > 0 ? input.refutedFindingsRef : undefined,
+        evidenceRefs,
+    });
+    return { report, refutedFindings };
+}