site-agent-pro 1.0.0

package/dist/core/aggregateReport.js

@@ -0,0 +1,382 @@
+import path from "node:path";
+import { config } from "../config.js";
+import { renderHtmlReport } from "../reporting/html.js";
+import { renderMarkdownReport } from "../reporting/markdown.js";
+import { resolveRunDir, writeJson, writeText } from "../utils/files.js";
+const IMPACT_ORDER = ["minor", "moderate", "serious", "critical"];
+const COVERAGE_ORDER = ["blocked", "inferred", "verified"];
+function clampScore(value) {
+    return Math.min(10, Math.max(1, Math.round(value)));
+}
+function average(values) {
+    if (values.length === 0) {
+        return 1;
+    }
+    return clampScore(values.reduce((sum, value) => sum + value, 0) / values.length);
+}
+function normalizeKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function ensureSentence(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function overallFeeling(score) {
+    if (score >= 8) {
+        return "smooth";
+    }
+    if (score >= 6) {
+        return "mostly okay";
+    }
+    if (score >= 4) {
+        return "mixed";
+    }
+    return "frustrating";
+}
+function isInternalWeakness(value) {
+    return /model evaluator did not finish|request timed out|current quota|429\b|run budget/i.test(value);
+}
+function formatAgentRunSource(agentRun) {
+    return agentRun.profileLabel ? `${agentRun.label} (${agentRun.profileLabel})` : agentRun.label;
+}
+function formatTaskStatus(status) {
+    switch (status) {
+        case "success":
+            return "succeeded";
+        case "partial_success":
+            return "partially succeeded";
+        case "failed":
+        default:
+            return "failed";
+    }
+}
+function buildTaskOutcomeSummary(taskResults) {
+    if (taskResults.length === 0) {
+        return "";
+    }
+    const successCount = taskResults.filter((task) => task.status === "success").length;
+    const partialCount = taskResults.filter((task) => task.status === "partial_success").length;
+    const failedCount = taskResults.filter((task) => task.status === "failed").length;
+    const perTask = taskResults
+        .slice(0, 5)
+        .map((task) => `${task.name} ${formatTaskStatus(task.status)}`)
+        .join("; ");
+    return ensureSentence(`Accepted task outcomes across the panel: ${successCount} succeeded, ${partialCount} partially succeeded, and ${failedCount} failed.${perTask ? ` Per task: ${perTask}.` : ""}`);
+}
+function summarizeRankedItems(items, limit) {
+    const counts = new Map();
+    items.forEach((item, index) => {
+        const key = normalizeKey(item);
+        if (!key) {
+            return;
+        }
+        const existing = counts.get(key);
+        if (existing) {
+            existing.count += 1;
+            return;
+        }
+        counts.set(key, { count: 1, sample: item, firstSeen: index });
+    });
+    return Array.from(counts.values())
+        .sort((left, right) => right.count - left.count || left.firstSeen - right.firstSeen)
+        .slice(0, limit)
+        .map((entry) => entry.sample);
+}
+function chooseImpact(left, right) {
+    const leftIndex = left ? IMPACT_ORDER.indexOf(left) : -1;
+    const rightIndex = right ? IMPACT_ORDER.indexOf(right) : -1;
+    return rightIndex > leftIndex ? right : left;
+}
+function coverageScore(siteChecks) {
+    return Object.values(siteChecks.coverage).reduce((sum, coverage) => sum + COVERAGE_ORDER.indexOf(coverage.status), 0);
+}
+function pickBestSiteChecks(results) {
+    const best = [...results].sort((left, right) => coverageScore(right.siteChecks) - coverageScore(left.siteChecks))[0];
+    return best?.siteChecks ?? {
+        generatedAt: new Date().toISOString(),
+        baseUrl: results[0]?.siteChecks.baseUrl ?? "",
+        finalResolvedUrl: null,
+        coverage: {
+            performance: { status: "blocked", summary: "Performance checks were unavailable in the aggregate run.", evidence: [], blockers: [] },
+            seo: { status: "blocked", summary: "SEO checks were unavailable in the aggregate run.", evidence: [], blockers: [] },
+            uiux: { status: "inferred", summary: "UI and UX findings rely on the aggregate interaction evidence.", evidence: [], blockers: [] },
+            security: { status: "blocked", summary: "Security checks were unavailable in the aggregate run.", evidence: [], blockers: [] },
+            technicalHealth: { status: "inferred", summary: "Technical health relies on the aggregate runtime evidence.", evidence: [], blockers: [] },
+            mobileOptimization: { status: "blocked", summary: "Mobile checks were unavailable in the aggregate run.", evidence: [], blockers: [] },
+            contentQuality: { status: "blocked", summary: "Content checks were unavailable in the aggregate run.", evidence: [], blockers: [] },
+            cro: { status: "inferred", summary: "CRO findings rely on the aggregate interaction evidence.", evidence: [], blockers: [] }
+        },
+        performance: { desktop: null, mobile: null, failedRequestCount: 0, imageFailureCount: 0, apiFailureCount: 0, navigationErrorCount: 0, stalledInteractionCount: 0, evidence: [] },
+        seo: {
+            robotsTxt: { url: "", ok: false, statusCode: null, note: "Unavailable." },
+            sitemap: { url: "", ok: false, statusCode: null, note: "Unavailable." },
+            brokenLinkCount: 0,
+            checkedLinkCount: 0,
+            brokenLinks: [],
+            evidence: []
+        },
+        security: { https: false, secureTransportVerified: false, initialStatusCode: null, securityHeaders: [], missingHeaders: [], evidence: [] },
+        technicalHealth: { framework: null, consoleErrorCount: 0, consoleWarningCount: 0, pageErrorCount: 0, apiFailureCount: 0, evidence: [] },
+        mobileOptimization: { desktop: null, mobile: null, responsiveVerdict: "blocked", evidence: [] },
+        contentQuality: { readabilityScore: null, readabilityLabel: "Blocked", wordCount: 0, longParagraphCount: 0, mediaCount: 0, evidence: [] },
+        cro: { ctaCount: 0, primaryCtas: [], formCount: 0, submitControlCount: 0, trustSignalCount: 0, evidence: [] }
+    };
+}
+function mergeAccessibility(results) {
+    const grouped = new Map();
+    let errorCount = 0;
+    for (const result of results) {
+        if (result.accessibility.error) {
+            errorCount += 1;
+        }
+        for (const violation of result.accessibility.violations) {
+            const existing = grouped.get(violation.id);
+            if (existing) {
+                existing.nodes += violation.nodes;
+                existing.impact = chooseImpact(existing.impact ?? null, violation.impact ?? null) ?? undefined;
+                continue;
+            }
+            grouped.set(violation.id, { ...violation });
+        }
+    }
+    return {
+        violations: Array.from(grouped.values()).sort((left, right) => right.nodes - left.nodes || left.id.localeCompare(right.id)),
+        ...(errorCount > 0 ? { error: `Accessibility auditing reported issues in ${errorCount} of ${results.length} completed agent runs.` } : {})
+    };
+}
+function aggregateTaskResults(results) {
+    const taskNames = Array.from(new Set(results.flatMap((result) => result.report.task_results.map((task) => task.name))));
+    const aggregatedTasks = taskNames.map((taskName) => {
+        const taskReports = results
+            .map((result) => ({
+            agentRun: result.agentRun,
+            reportTask: result.report.task_results.find((task) => task.name === taskName) ?? null,
+            rawTask: result.taskResults.find((task) => task.name === taskName) ?? null
+        }))
+            .filter((entry) => entry.reportTask || entry.rawTask);
+        const statusCounts = {
+            success: taskReports.filter((entry) => (entry.reportTask?.status ?? entry.rawTask?.status) === "success").length,
+            partial_success: taskReports.filter((entry) => (entry.reportTask?.status ?? entry.rawTask?.status) === "partial_success").length,
+            failed: taskReports.filter((entry) => (entry.reportTask?.status ?? entry.rawTask?.status) === "failed").length
+        };
+        const status = statusCounts.success > 0 && statusCounts.failed === 0 && statusCounts.partial_success === 0
+            ? "success"
+            : statusCounts.failed === taskReports.length
+                ? "failed"
+                : "partial_success";
+        const evidence = taskReports
+            .flatMap((entry) => {
+            const reportEvidence = entry.reportTask?.evidence ?? [];
+            if (reportEvidence.length > 0) {
+                return reportEvidence.map((item) => `${formatAgentRunSource(entry.agentRun)}: ${item}`);
+            }
+            const fallbackReason = entry.reportTask?.reason ?? entry.rawTask?.reason;
+            return fallbackReason ? [`${formatAgentRunSource(entry.agentRun)}: ${fallbackReason}`] : [];
+        })
+            .slice(0, 8);
+        const finalUrl = taskReports.find((entry) => entry.rawTask?.finalUrl)?.rawTask?.finalUrl ?? "";
+        const finalTitle = taskReports.find((entry) => entry.rawTask?.finalTitle)?.rawTask?.finalTitle ?? "";
+        return {
+            reportTask: {
+                name: taskName,
+                status,
+                reason: `${statusCounts.success} success, ${statusCounts.partial_success} partial, and ${statusCounts.failed} failed across ${taskReports.length} agent perspectives.`,
+                evidence
+            },
+            syntheticRun: {
+                name: taskName,
+                status,
+                finalUrl,
+                finalTitle,
+                history: [],
+                reason: `${statusCounts.success} success, ${statusCounts.partial_success} partial, and ${statusCounts.failed} failed across ${taskReports.length} agent perspectives.`
+            }
+        };
+    });
+    return {
+        taskResults: aggregatedTasks.map((task) => task.reportTask),
+        syntheticRuns: aggregatedTasks.map((task) => task.syntheticRun)
+    };
+}
+function aggregateGameplaySummary(results) {
+    const gameplaySummaries = results
+        .map((result) => result.report.gameplay_summary)
+        .filter((summary) => Boolean(summary));
+    if (gameplaySummaries.length === 0) {
+        return undefined;
+    }
+    const roundsRequested = gameplaySummaries.reduce((sum, summary) => sum + summary.roundsRequested, 0);
+    const roundsRecorded = gameplaySummaries.reduce((sum, summary) => sum + summary.roundsRecorded, 0);
+    const wins = gameplaySummaries.reduce((sum, summary) => sum + summary.wins, 0);
+    const losses = gameplaySummaries.reduce((sum, summary) => sum + summary.losses, 0);
+    const draws = gameplaySummaries.reduce((sum, summary) => sum + summary.draws, 0);
+    const inconclusiveRounds = gameplaySummaries.reduce((sum, summary) => sum + summary.inconclusiveRounds, 0);
+    const howToPlayConfirmed = gameplaySummaries.some((summary) => summary.howToPlayConfirmed);
+    const replayConfirmed = gameplaySummaries.some((summary) => summary.replayConfirmed);
+    const evidence = gameplaySummaries.flatMap((summary) => summary.evidence).slice(0, 8);
+    return {
+        roundsRequested,
+        roundsRecorded,
+        wins,
+        losses,
+        draws,
+        inconclusiveRounds,
+        howToPlayConfirmed,
+        replayConfirmed,
+        summary: `Across ${gameplaySummaries.length} gameplay perspective(s), the run recorded ${roundsRecorded}/${roundsRequested} requested rounds: ${wins} wins, ${losses} losses, ${draws} draws, and ${inconclusiveRounds} inconclusive round(s).`,
+        evidence
+    };
+}
+function buildAggregateReport(submission, results) {
+    const completedAgentCount = results.length;
+    const failedAgentCount = submission.failedAgentCount;
+    const firstStrength = summarizeRankedItems(results.flatMap((result) => result.report.strengths), 6);
+    const firstWeakness = summarizeRankedItems(results.flatMap((result) => result.report.weaknesses), 6);
+    const firstFixes = summarizeRankedItems(results.flatMap((result) => result.report.top_fixes), 6);
+    const accessibility = mergeAccessibility(results);
+    const siteChecks = pickBestSiteChecks(results);
+    const { taskResults, syntheticRuns } = aggregateTaskResults(results);
+    const gameplaySummary = aggregateGameplaySummary(results);
+    const overallScore = average(results.map((result) => result.report.overall_score));
+    const visitorFacingWeaknesses = firstWeakness.filter((item) => !isInternalWeakness(item));
+    const primaryWeakness = visitorFacingWeaknesses[0];
+    const taskOutcomeSummary = buildTaskOutcomeSummary(taskResults);
+    const report = {
+        overall_score: overallScore,
+        summary: [
+            `I checked ${submission.url} from ${completedAgentCount} visitor perspective${completedAgentCount === 1 ? "" : "s"}, and overall the experience felt ${overallFeeling(overallScore)} at ${overallScore}/10.`,
+            taskOutcomeSummary,
+            gameplaySummary ? ensureSentence(gameplaySummary.summary) : "",
+            primaryWeakness ? ensureSentence(primaryWeakness) : "",
+            failedAgentCount > 0 ? `${failedAgentCount} perspective${failedAgentCount === 1 ? "" : "s"} failed before the visit could fully finish.` : ""
+        ]
+            .filter(Boolean)
+            .join(" "),
+        scores: {
+            clarity: average(results.map((result) => result.report.scores.clarity)),
+            navigation: average(results.map((result) => result.report.scores.navigation)),
+            trust: average(results.map((result) => result.report.scores.trust)),
+            friction: average(results.map((result) => result.report.scores.friction)),
+            conversion_readiness: average(results.map((result) => result.report.scores.conversion_readiness)),
+            accessibility_basics: average(results.map((result) => result.report.scores.accessibility_basics))
+        },
+        strengths: firstStrength,
+        weaknesses: firstWeakness,
+        task_results: taskResults,
+        top_fixes: firstFixes,
+        ...(gameplaySummary ? { gameplay_summary: gameplaySummary } : {})
+    };
+    const rawEvents = [
+        {
+            type: "batch_summary",
+            time: new Date().toISOString(),
+            completedAgentCount,
+            failedAgentCount,
+            note: `Batch task panel finished with ${completedAgentCount} completed agent runs and ${failedAgentCount} failed agent runs.`
+        },
+        ...results.map((result) => ({
+            type: "agent_batch_result",
+            time: result.agentRun.completedAt ?? new Date().toISOString(),
+            agentId: result.agentRun.id,
+            agentLabel: result.agentRun.label,
+            profileLabel: result.agentRun.profileLabel,
+            personaName: result.agentRun.personaName,
+            runId: result.runId,
+            overallScore: result.report.overall_score,
+            note: result.report.summary
+        }))
+    ];
+    return {
+        report,
+        taskRuns: syntheticRuns,
+        accessibility,
+        siteChecks,
+        rawEvents
+    };
+}
+export function createAggregateRun(submission, results) {
+    const aggregateStartedAt = submission.startedAt ?? new Date().toISOString();
+    const runDir = resolveRunDir(submission.url);
+    const runId = path.basename(runDir);
+    const aggregatePersona = submission.customTasks.length > 0
+        ? `Task panel: ${submission.customTasks[0]}${submission.customTasks.length > 1 ? ` + ${submission.customTasks.length - 1} more` : ""}`
+        : `${submission.agentCount}-agent task panel`;
+    const { report, taskRuns, accessibility, siteChecks, rawEvents } = buildAggregateReport(submission, results);
+    const timeZone = config.deviceTimezone;
+    const inputs = {
+        baseUrl: submission.url,
+        persona: aggregatePersona,
+        instructionText: submission.instructionText,
+        instructionFileName: submission.instructionFileName,
+        headed: submission.headed,
+        mobile: submission.mobile,
+        ignoreHttpsErrors: submission.ignoreHttpsErrors,
+        llmProvider: config.llmProvider,
+        model: config.model,
+        startedAt: aggregateStartedAt,
+        maxRunDurationMs: config.maxSessionDurationMs,
+        maxRunDurationSeconds: Math.round(config.maxSessionDurationMs / 1000),
+        browserExecutionBudgetMs: config.browserExecutionBudgetMs,
+        reportingReserveMs: config.reportingReserveMs,
+        maxRunDurationClamped: false,
+        deviceTimezone: config.deviceTimezone,
+        synchronizedTimezone: timeZone,
+        batchRole: "aggregate",
+        parentSubmissionId: submission.id,
+        agentCount: submission.agentCount,
+        completedAgentCount: submission.completedAgentCount,
+        failedAgentCount: submission.failedAgentCount,
+        customTasks: submission.customTasks,
+        aggregatedFromRunIds: results.map((result) => result.runId),
+        agentRuns: submission.agentRuns.map((agentRun) => ({
+            ...agentRun,
+            runDir: null
+        }))
+    };
+    writeJson(path.join(runDir, "inputs.json"), inputs);
+    writeJson(path.join(runDir, "raw-events.json"), rawEvents);
+    writeJson(path.join(runDir, "task-results.json"), taskRuns);
+    writeJson(path.join(runDir, "accessibility.json"), accessibility);
+    writeJson(path.join(runDir, "site-checks.json"), siteChecks);
+    writeJson(path.join(runDir, "report.json"), report);
+    writeText(path.join(runDir, "report.html"), renderHtmlReport({
+        website: submission.url,
+        persona: aggregatePersona,
+        acceptedTasks: submission.customTasks,
+        instructionText: submission.instructionText,
+        report,
+        taskResults: taskRuns,
+        accessibility,
+        siteChecks,
+        rawEvents,
+        runId,
+        startedAt: aggregateStartedAt,
+        mobile: submission.mobile,
+        timeZone
+    }));
+    writeText(path.join(runDir, "report.md"), renderMarkdownReport({
+        website: submission.url,
+        persona: aggregatePersona,
+        acceptedTasks: submission.customTasks,
+        instructionText: submission.instructionText,
+        report,
+        taskResults: taskRuns,
+        accessibility,
+        siteChecks,
+        rawEvents,
+        startedAt: aggregateStartedAt,
+        mobile: submission.mobile,
+        timeZone
+    }));
+    return {
+        runDir,
+        runId,
+        report,
+        taskResults: taskRuns,
+        accessibility,
+        siteChecks
+    };
+}

package/dist/core/audit.js

@@ -0,0 +1,30 @@
+import axeCore from "axe-core";
+import { AccessibilityResultSchema } from "../schemas/types.js";
+export async function runAccessibilityAudit(page) {
+    try {
+        await page.addScriptTag({ content: axeCore.source });
+        const results = await page.evaluate(`(async () => {
+      const axe = globalThis.axe;
+      if (!axe) {
+        throw new Error("axe-core did not load into the page context.");
+      }
+
+      return axe.run(document);
+    })()`);
+        return AccessibilityResultSchema.parse({
+            violations: results.violations.map((violation) => ({
+                id: violation.id,
+                impact: violation.impact ?? null,
+                description: violation.description,
+                help: violation.help,
+                nodes: violation.nodes.length
+            }))
+        });
+    }
+    catch (error) {
+        return AccessibilityResultSchema.parse({
+            error: error instanceof Error ? error.message : "Unknown accessibility audit error",
+            violations: []
+        });
+    }
+}

package/dist/core/customTaskSuite.js

@@ -0,0 +1,148 @@
+import { TaskSuiteSchema } from "../schemas/types.js";
+import { classifyTaskText, inferGameplayConfigFromTask } from "./taskHeuristics.js";
+import { parseTaskDirectives } from "./taskDirectives.js";
+const RUN_WIDE_CONSTRAINT_PATTERNS = [
+    /^(?:do not|don't|never|avoid|without)\b/i,
+    /^stop before\b/i,
+    /^(?:no more than|at most)\b/i,
+    /^(?:use|keep using|reuse)\s+(?:the\s+)?same\b/i,
+    /^(?:only create|create only)\b/i,
+    /\b(?:single|same|one)\s+(?:profile|account|identity)\b/i
+];
+function buildTaskName(task, index) {
+    const firstClause = task.split(/[.!?]/, 1)[0]?.trim() || task;
+    const words = firstClause.split(/\s+/).filter(Boolean);
+    const compactLabel = words.length <= 8 ? firstClause : `${words.slice(0, 8).join(" ").trimEnd()}...`;
+    const shortened = compactLabel.length > 72 ? `${compactLabel.slice(0, 69).trimEnd()}...` : compactLabel;
+    return `Task ${index}: ${shortened}`;
+}
+function stripTaskPrefix(value) {
+    return value.replace(/^Task \d+:\s*/, "").trim();
+}
+function buildPersonaName(tasks) {
+    const firstTask = stripTaskPrefix(buildTaskName(tasks[0] ?? "submitted task", 1));
+    if (tasks.length === 1) {
+        return `Task-focused visitor: ${firstTask}`;
+    }
+    return `Task-focused visitor: ${firstTask} + ${tasks.length - 1} more`;
+}
+function isRunWideConstraint(task) {
+    return RUN_WIDE_CONSTRAINT_PATTERNS.some((pattern) => pattern.test(task.trim()));
+}
+function partitionTaskDirectives(tasks) {
+    const actionTasks = [];
+    const runWideConstraints = [];
+    for (const task of tasks) {
+        if (isRunWideConstraint(task)) {
+            runWideConstraints.push(task);
+            continue;
+        }
+        actionTasks.push(task);
+    }
+    return { actionTasks, runWideConstraints };
+}
+function collapseSequentialFormFlowTasks(tasks) {
+    if (tasks.length < 2 || tasks.length > 6) {
+        return tasks;
+    }
+    const directivesByTask = tasks.map((task) => parseTaskDirectives(task));
+    if (directivesByTask.some((directives) => directives.length === 0)) {
+        return tasks;
+    }
+    const flattenedDirectives = directivesByTask.flat();
+    const includesFormFlowStep = flattenedDirectives.some((directive) => directive.action === "fill_visible_form" || directive.action === "type_field" || directive.action === "submit");
+    if (!includesFormFlowStep) {
+        return tasks;
+    }
+    return [tasks.join("; ")];
+}
+function isNairaCryptoExchangeTask(task) {
+    return /\b(?:buy|sell)\s+flow\b/i.test(task) && /\bnaira|ngn\b/i.test(task) && /\bcrypto|token|wallet\b/i.test(task);
+}
+function isExchangeMonitoringTask(task) {
+    return /\bexchange-flow monitoring\b|\bmonitoring evidence\b/i.test(task) && /\bevents?|logs?\b/i.test(task);
+}
+export function buildCustomTaskSuite(tasks) {
+    const { actionTasks, runWideConstraints } = partitionTaskDirectives(tasks);
+    const collapsedActionTasks = collapseSequentialFormFlowTasks(actionTasks);
+    const effectiveTasks = collapsedActionTasks.length > 0 ? collapsedActionTasks : tasks;
+    const globalConstraintNotes = actionTasks.length > 0
+        ? runWideConstraints.map((constraint) => `Run-wide user constraint: ${constraint}`)
+        : [];
+    return TaskSuiteSchema.parse({
+        persona: {
+            name: buildPersonaName(effectiveTasks),
+            intent: `Visit the supplied website like a realistic, attentive human who first understands what the site appears to be for, then completes only the submitted tasks. Let the submitted task list set your priorities instead of any predefined agent profile. Requested tasks: ${effectiveTasks.join(" | ")}${globalConstraintNotes.length > 0 ? ` Run-wide constraints: ${runWideConstraints.join(" | ")}` : ""}`,
+            constraints: [
+                "First understand what the supplied site appears to help users do before attempting the accepted tasks.",
+                "Use the provided task list as the primary navigation plan for the visit.",
+                "Treat any run-wide user constraint as a hard guardrail that cannot be violated to satisfy a later task.",
+                "Do not assume a predefined agent personality or profile beyond what the submitted tasks require.",
+                "Use the site understanding only to interpret the accepted tasks, not to invent new ones.",
+                "Use only visible page information and honest interaction evidence.",
+                "Behave like a realistic first-time visitor rather than a rigid script runner.",
+                "When a task contains explicit named controls or ordered action verbs, follow those literally in order. Only choose a reasonable visible path when the user did not specify the next step.",
+                "Confirm whether the requested destination, content, or state actually appears before claiming success.",
+                "If a task stalls, dead-ends, loops, or becomes misleading, verify that before moving on.",
+                "Do not enter personal, financial, or secret information unless the accepted task explicitly requires harmless test wallet, bank, or amount values for a flow QA check.",
+                "For exchange-flow QA tasks, stop before making any real Naira payment, crypto transfer, purchase, or irreversible payout.",
+                "Use harmless test input only when typing is necessary to evaluate a public interaction safely.",
+                "Record blockers honestly when a task requires login, payment, invite-only access, or other gated access.",
+                "Give a direct, evidence-based account of which requested tasks worked, partially worked, or failed.",
+                ...globalConstraintNotes
+            ]
+        },
+        tasks: effectiveTasks.map((task, index) => {
+            const taskProfile = classifyTaskText(task);
+            const gameplay = inferGameplayConfigFromTask(task);
+            const successCondition = isNairaCryptoExchangeTask(task)
+                ? "The agent can safely exercise the requested exchange direction with harmless test values, verify the amount preview, required destination details, payment/address display card, copy behavior, and stop before any real money or crypto is transferred."
+                : isExchangeMonitoringTask(task)
+                    ? "The agent can report whether relevant console logs, debug messages, analytics events, or visible emitted-event evidence appeared for the important exchange-flow stages."
+                    : gameplay?.rounds
+                        ? `The agent can reach a fair playable state, record ${gameplay.rounds} visible round outcome(s), and honestly report the wins, losses, or draws that actually appeared.`
+                        : taskProfile.engagement
+                            ? "The agent can follow the visible path, meaningfully use the live controls it reaches, and honestly report what visibly happened."
+                            : taskProfile.instructionFocus
+                                ? "The agent can confirm the visible rules or instructions, honestly report what they said, and verify whether the site reached a playable state."
+                                : "The agent can attempt this requested task on the live site, describe the visible outcome honestly, and confirm whether the expected destination, content, or state appeared.";
+            const failureSignals = [
+                "the site does not provide a clear visible path to complete the requested task",
+                "the journey stalls, loops, errors, or becomes misleading before the task can be evaluated",
+                "the task requires login, payment, or private information before a safe stopping point",
+                "the expected page, content, or success state never clearly appears",
+                "the final output cannot clearly explain what happened when attempting the task",
+                ...(globalConstraintNotes.length > 0 ? ["the run violates a run-wide user constraint while attempting this task"] : []),
+                ...(taskProfile.engagement
+                    ? ["the run never produces clear evidence of meaningful interaction with the live controls"]
+                    : []),
+                ...(gameplay?.rounds
+                    ? [
+                        "the gameplay path never reaches a clearly playable state",
+                        "the requested wins, losses, draws, or round outcomes cannot be visibly confirmed"
+                    ]
+                    : []),
+                ...(taskProfile.instructionFocus
+                    ? ["the visible rules, instructions, or how-to-play guidance cannot be clearly confirmed"]
+                    : []),
+                ...(isNairaCryptoExchangeTask(task)
+                    ? [
+                        "the flow does not request the required wallet or bank destination before showing payment details",
+                        "the quoted conversion preview, account card, business wallet address, or copy control cannot be confirmed",
+                        "the flow attempts to require or trigger a real payment or crypto transfer during the test"
+                    ]
+                    : []),
+                ...(isExchangeMonitoringTask(task)
+                    ? ["no relevant monitoring log, emitted event, debug message, or console evidence can be observed for the requested exchange stages"]
+                    : [])
+            ];
+            return {
+                name: buildTaskName(task, index + 1),
+                goal: task,
+                success_condition: successCondition,
+                failure_signals: failureSignals,
+                ...(gameplay ? { gameplay } : {})
+            };
+        })
+    });
+}