site-agent-pro 1.0.0

package/dist/core/formHeuristics.js

@@ -0,0 +1,411 @@
+export const CHECK_FIELD_SENTINEL = "__SITE_AGENT_CHECK_FIELD__";
+const SELECT_PLACEHOLDER_PATTERN = /^(?:(?:please\s+)?(?:select|choose|pick)(?:\s+[a-z0-9][a-z0-9 -]*)?|--+|option)$/i;
+const DATE_CONTEXT_BLOCKLIST = /arrival|departure|return date|check[- ]?in|check[- ]?out|appointment|meeting|delivery|pickup|reservation|booking|schedule/i;
+const CODE_FIELD_PATTERN = /\b(?:coupon|promo|referral|invite|gift|discount|access)\b.*\b(?:code|token)\b|\b(?:coupon|promo|referral|invite|gift|discount)\b/;
+const PAYMENT_FIELD_PATTERN = /credit card|cardholder|card number|\bcvv\b|\bcvc\b|expiry|expiration|mm\/yy|mm-yy/;
+const PASSWORD_FIELD_PATTERN = /\bpassword\b|passcode|\bpin\b/i;
+const EMAIL_FIELD_PATTERN = /\bemail\b|e-mail/i;
+const PASSWORD_CONFIRMATION_PATTERN = /\bconfirm\b|re[- ]?(?:enter|type)|repeat|again|verify/i;
+const TEST_CRYPTO_WALLET_ADDRESS = "0x1111111111111111111111111111111111111111";
+const TEST_BANK_ACCOUNT_NUMBER = "0123456789";
+function normalizeFormText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function normalizeFormKey(value) {
+    return normalizeFormText(value).toLowerCase();
+}
+export function hasPasswordConfirmationCue(value) {
+    return PASSWORD_CONFIRMATION_PATTERN.test(normalizeFormText(value));
+}
+function normalizeLooseKey(value) {
+    return normalizeFormKey(value).replace(/[^a-z0-9]+/g, "");
+}
+function localEmailBase(email) {
+    return email.split("@", 1)[0] || "";
+}
+function buildFallbackUsername(identity) {
+    const emailBase = localEmailBase(identity.email).replace(/\+/g, "-").replace(/[^a-z0-9._-]+/gi, "");
+    if (emailBase) {
+        return emailBase.toLowerCase().slice(0, 24);
+    }
+    return `${identity.firstName}.${identity.lastName}`.replace(/[^a-z0-9._-]+/gi, "").toLowerCase().slice(0, 24);
+}
+export function buildSupplementalAccessProfile(identity) {
+    return {
+        username: identity.username?.trim() || buildFallbackUsername(identity),
+        age: "24",
+        website: "https://example.com",
+        occupation: "QA analyst",
+        bio: "Independent QA tester reviewing the signup flow.",
+        message: "Testing the signup flow for a product evaluation.",
+        birthDateIso: "1998-04-17",
+        birthDay: "17",
+        birthMonthNumber: "04",
+        birthMonthName: "April",
+        birthMonthShort: "Apr",
+        birthYear: "1998",
+        pronouns: "they/them",
+        gender: "Prefer not to say"
+    };
+}
+export function buildFormFieldKey(field) {
+    return normalizeFormKey([field.label, field.placeholder, field.name, field.id, field.autocomplete ?? "", field.inputType, field.inputMode ?? ""].join(" "));
+}
+export function scoreFormFieldTargetMatch(field, target) {
+    const normalizedTarget = normalizeFormKey(target);
+    if (!normalizedTarget) {
+        return 0;
+    }
+    const candidates = [field.label, field.placeholder, field.name, field.id, field.autocomplete ?? "", field.inputMode ?? ""]
+        .map((value) => normalizeFormKey(value))
+        .filter(Boolean);
+    let score = 0;
+    for (const candidate of candidates) {
+        if (candidate === normalizedTarget) {
+            score = Math.max(score, 120);
+        }
+        if (candidate.includes(normalizedTarget) || normalizedTarget.includes(candidate)) {
+            score = Math.max(score, 90);
+        }
+    }
+    if (field.inputType === normalizedTarget) {
+        score = Math.max(score, 110);
+    }
+    const fieldKey = buildFormFieldKey(field);
+    const targetWantsPassword = PASSWORD_FIELD_PATTERN.test(normalizedTarget);
+    const fieldLooksPasswordLike = field.inputType === "password" || PASSWORD_FIELD_PATTERN.test(fieldKey);
+    const targetWantsConfirm = hasPasswordConfirmationCue(target);
+    const fieldLooksLikeConfirm = hasPasswordConfirmationCue(fieldKey);
+    if (targetWantsPassword && fieldLooksPasswordLike) {
+        score = Math.max(score, targetWantsConfirm === fieldLooksLikeConfirm ? 130 : 85);
+    }
+    if (EMAIL_FIELD_PATTERN.test(normalizedTarget) && (field.inputType === "email" || EMAIL_FIELD_PATTERN.test(fieldKey))) {
+        score = Math.max(score, 130);
+    }
+    if (targetWantsConfirm) {
+        if (fieldLooksLikeConfirm) {
+            score += 70;
+        }
+        else if (fieldLooksPasswordLike) {
+            score -= 70;
+        }
+    }
+    if (!targetWantsConfirm && targetWantsPassword && fieldLooksLikeConfirm) {
+        score -= 40;
+    }
+    return score;
+}
+function stripLeadingZero(value) {
+    return value.replace(/^0+(\d)/, "$1");
+}
+function findOptionByCandidates(options, candidates) {
+    const normalizedCandidates = [...new Set(candidates.map((value) => normalizeFormKey(value)).filter(Boolean))];
+    const looseCandidates = [...new Set(candidates.map((value) => normalizeLooseKey(value)).filter(Boolean))];
+    if (normalizedCandidates.length === 0) {
+        return null;
+    }
+    for (const option of options) {
+        const normalizedOption = normalizeFormKey(option);
+        if (normalizedCandidates.includes(normalizedOption)) {
+            return option;
+        }
+    }
+    for (const option of options) {
+        const looseOption = normalizeLooseKey(option);
+        if (looseCandidates.includes(looseOption)) {
+            return option;
+        }
+    }
+    for (const option of options) {
+        const normalizedOption = normalizeFormKey(option);
+        if (normalizedCandidates.some((candidate) => normalizedOption.includes(candidate) || candidate.includes(normalizedOption))) {
+            return option;
+        }
+    }
+    for (const option of options) {
+        const looseOption = normalizeLooseKey(option);
+        if (looseCandidates.some((candidate) => looseOption.includes(candidate) || candidate.includes(looseOption))) {
+            return option;
+        }
+    }
+    return null;
+}
+function findAgeOption(options, age) {
+    for (const option of options) {
+        const normalized = normalizeFormKey(option);
+        const exactMatch = normalized.match(/\b(\d{1,2})\b/);
+        if (exactMatch && Number(exactMatch[1]) === age && !/[-+]/.test(normalized)) {
+            return option;
+        }
+        const rangeMatch = normalized.match(/(\d{1,2})\s*[-to]+\s*(\d{1,2})/);
+        if (rangeMatch) {
+            const lowerBound = Number(rangeMatch[1]);
+            const upperBound = Number(rangeMatch[2]);
+            if (Number.isFinite(lowerBound) && Number.isFinite(upperBound) && age >= lowerBound && age <= upperBound) {
+                return option;
+            }
+        }
+        const plusMatch = normalized.match(/(\d{1,2})\s*\+/);
+        if (plusMatch && age >= Number(plusMatch[1])) {
+            return option;
+        }
+    }
+    return null;
+}
+function getFirstRealOption(options) {
+    return options.find((option) => !SELECT_PLACEHOLDER_PATTERN.test(normalizeFormText(option))) ?? null;
+}
+function resolveStateCandidates(state) {
+    const normalized = normalizeFormKey(state);
+    if (normalized === "texas") {
+        return [state, "TX"];
+    }
+    if (normalized === "california") {
+        return [state, "CA"];
+    }
+    if (normalized === "new york") {
+        return [state, "NY"];
+    }
+    if (normalized === "florida") {
+        return [state, "FL"];
+    }
+    return [state];
+}
+export function findMatchingSelectOption(options, desiredValues) {
+    return findOptionByCandidates(options, desiredValues);
+}
+function inferSelectValue(field, identity, supplemental) {
+    if (field.options.length === 0) {
+        return null;
+    }
+    const key = buildFormFieldKey(field);
+    if (/country/.test(key)) {
+        return (findMatchingSelectOption(field.options, [identity.country, "United States of America", "United States", "USA", "US"]) ??
+            getFirstRealOption(field.options));
+    }
+    if (/state|province|region/.test(key)) {
+        return findMatchingSelectOption(field.options, resolveStateCandidates(identity.state)) ?? getFirstRealOption(field.options);
+    }
+    if (field.autocomplete === "bday-month" || /(?:birth|dob|bday).*(?:month)|month of birth|\bmonth\b/.test(key)) {
+        return (findMatchingSelectOption(field.options, [
+            supplemental.birthMonthName,
+            supplemental.birthMonthShort,
+            supplemental.birthMonthNumber,
+            stripLeadingZero(supplemental.birthMonthNumber)
+        ]) ?? getFirstRealOption(field.options));
+    }
+    if (field.autocomplete === "bday-day" || /(?:birth|dob|bday).*(?:day)|day of birth|\bday\b/.test(key)) {
+        return findMatchingSelectOption(field.options, [supplemental.birthDay, stripLeadingZero(supplemental.birthDay)]) ?? getFirstRealOption(field.options);
+    }
+    if (field.autocomplete === "bday-year" || /(?:birth|dob|bday).*(?:year)|year of birth|\byear\b/.test(key)) {
+        return findMatchingSelectOption(field.options, [supplemental.birthYear]) ?? getFirstRealOption(field.options);
+    }
+    if (/gender|sex/.test(key)) {
+        return (findMatchingSelectOption(field.options, [
+            supplemental.gender,
+            "Rather not say",
+            "Prefer not to answer",
+            "Other",
+            "Non-binary",
+            "Nonbinary",
+            "Male",
+            "Female"
+        ]) ?? getFirstRealOption(field.options));
+    }
+    if (/pronouns?/.test(key)) {
+        return (findMatchingSelectOption(field.options, [
+            supplemental.pronouns,
+            "Prefer not to say",
+            "Rather not say",
+            "They/them",
+            "They / them"
+        ]) ?? getFirstRealOption(field.options));
+    }
+    if (/age|age range/.test(key)) {
+        return findAgeOption(field.options, Number(supplemental.age)) ?? getFirstRealOption(field.options);
+    }
+    if (/occupation|job title|profession|role/.test(key)) {
+        return findMatchingSelectOption(field.options, [supplemental.occupation, "QA", "Tester", "Student"]) ?? getFirstRealOption(field.options);
+    }
+    return getFirstRealOption(field.options);
+}
+export function fitValueToField(field, value) {
+    const normalizedValue = normalizeFormText(value);
+    const maxLength = field.maxLength && field.maxLength > 0 ? field.maxLength : null;
+    if (!maxLength || normalizedValue.length <= maxLength) {
+        return normalizedValue;
+    }
+    const key = buildFormFieldKey({
+        label: field.label,
+        placeholder: field.placeholder,
+        name: field.name,
+        id: field.id,
+        autocomplete: field.autocomplete ?? "",
+        inputType: field.inputType,
+        inputMode: field.inputMode ?? ""
+    });
+    if (field.tag === "textarea" || ["text", "search"].includes(field.inputType) || /bio|about|summary|description|message|headline|title/.test(key)) {
+        return normalizedValue.slice(0, maxLength).trim();
+    }
+    return normalizedValue;
+}
+export function inferFormFieldValue(field, identity) {
+    const supplemental = buildSupplementalAccessProfile(identity);
+    const key = buildFormFieldKey(field);
+    if (PAYMENT_FIELD_PATTERN.test(key)) {
+        return null;
+    }
+    if (/\bwallet\b|\brecipient\b|\bcrypto\s+address\b|\baddress\s+(?:to\s+)?(?:receive|send)\b/.test(key)) {
+        return fitValueToField(field, TEST_CRYPTO_WALLET_ADDRESS);
+    }
+    if (/\bbank\b.*\baccount\b|\baccount\s+(?:number|no)\b|\bnuban\b/.test(key)) {
+        return fitValueToField(field, TEST_BANK_ACCOUNT_NUMBER);
+    }
+    if (/\b(?:token|contract)\b.*\baddress\b|\baddress\b.*\b(?:token|contract)\b/.test(key)) {
+        return null;
+    }
+    if (/\bnaira\b|\bngn\b|₦/.test(key) && /\bamount\b|spend|pay|receive|payout/.test(key)) {
+        return null;
+    }
+    if (/\bcrypto\b|\btoken\b|\busdt\b|\bbtc\b|\beth\b|\busdc\b/.test(key) && /\bamount\b|sell|receive|send/.test(key)) {
+        return null;
+    }
+    if (/\bamount\b/.test(key) && (field.inputType === "number" || field.inputMode === "numeric" || field.inputMode === "decimal")) {
+        return null;
+    }
+    if (field.inputType === "checkbox") {
+        if (field.checked) {
+            return null;
+        }
+        if (field.required || /agree|accept|terms|privacy|conditions|policy|consent|adult|human|acknowledge|confirm|over\s*(?:13|16|18|21)/.test(key)) {
+            return CHECK_FIELD_SENTINEL;
+        }
+        return null;
+    }
+    if (field.inputType === "radio") {
+        if (field.checked) {
+            return null;
+        }
+        // Picking the first visible radio option is a reasonable default for
+        // required signup groups like "experience level" when no model plan is available.
+        return CHECK_FIELD_SENTINEL;
+    }
+    if (field.tag === "select") {
+        const selectValue = inferSelectValue(field, identity, supplemental);
+        if (selectValue) {
+            return selectValue;
+        }
+    }
+    if (field.autocomplete === "email" || field.inputType === "email" || /\bemail\b|e-mail/.test(key)) {
+        return identity.email;
+    }
+    if (field.autocomplete === "username" || /\buser.?name\b|handle|screen.?name|user id/.test(key)) {
+        return fitValueToField(field, supplemental.username);
+    }
+    if (field.inputType === "password" || /\bpassword\b|passcode|pin\b/.test(key)) {
+        return identity.password;
+    }
+    if (/^names?$/.test(normalizeFormKey(field.label)) || /\bnames\b/.test(key)) {
+        return identity.fullName;
+    }
+    if (/first.?name|given.?name/.test(key)) {
+        return identity.firstName;
+    }
+    if (/last.?name|surname|family.?name/.test(key)) {
+        return identity.lastName;
+    }
+    if (/display.?name|profile.?name/.test(key)) {
+        return identity.fullName;
+    }
+    if (/full.?name|\bname\b/.test(key) && !/company|organization|business/.test(key)) {
+        return identity.fullName;
+    }
+    if (/pronouns?/.test(key)) {
+        return supplemental.pronouns;
+    }
+    if (/gender|sex/.test(key)) {
+        return supplemental.gender;
+    }
+    if (field.autocomplete === "bday" ||
+        /date of birth|dob|birthday/.test(key) ||
+        (field.inputType === "date" && !DATE_CONTEXT_BLOCKLIST.test(key))) {
+        return supplemental.birthDateIso;
+    }
+    if (field.autocomplete === "bday-year" || /(?:birth|dob|bday).*(?:year)|year of birth/.test(key)) {
+        return supplemental.birthYear;
+    }
+    if (field.autocomplete === "bday-month" || /(?:birth|dob|bday).*(?:month)|month of birth/.test(key)) {
+        return supplemental.birthMonthNumber;
+    }
+    if (field.autocomplete === "bday-day" || /(?:birth|dob|bday).*(?:day)|day of birth/.test(key)) {
+        return supplemental.birthDay;
+    }
+    if (/\bage\b|years?\b|how old/.test(key)) {
+        return supplemental.age;
+    }
+    if (field.inputType === "tel" || /phone|mobile|telephone|tel\b/.test(key)) {
+        return identity.phone;
+    }
+    if (field.inputType === "url" || /website|url|portfolio|linkedin|homepage/.test(key)) {
+        return supplemental.website;
+    }
+    if (/address.*line.*2|address 2|suite|unit|apt|apartment/.test(key)) {
+        return identity.addressLine2;
+    }
+    if (/street|address/.test(key)) {
+        return identity.addressLine1;
+    }
+    if (/city|town/.test(key)) {
+        return identity.city;
+    }
+    if (/state|province|region/.test(key)) {
+        return identity.state;
+    }
+    if (/zip|postal/.test(key)) {
+        return identity.postalCode;
+    }
+    if (/country/.test(key)) {
+        return identity.country;
+    }
+    if (/company|organization|business/.test(key)) {
+        return identity.company;
+    }
+    if (/occupation|job title|profession|role|what do you do/.test(key)) {
+        return supplemental.occupation;
+    }
+    if (/bio|about|summary|description|introduce yourself|tell us about yourself/.test(key)) {
+        return fitValueToField(field, supplemental.bio);
+    }
+    if (/message|why are you interested|why do you want|comment|notes?/.test(key)) {
+        return fitValueToField(field, supplemental.message);
+    }
+    if (field.required && CODE_FIELD_PATTERN.test(key)) {
+        return null;
+    }
+    if (field.required && field.tag === "textarea") {
+        return fitValueToField(field, supplemental.bio);
+    }
+    if (field.required && ["text", "search"].includes(field.inputType)) {
+        if (/headline|title/.test(key)) {
+            return fitValueToField(field, supplemental.occupation);
+        }
+        return fitValueToField(field, identity.fullName);
+    }
+    return null;
+}
+export function isPlaceholderFieldValue(field, value) {
+    if (field.inputType === "checkbox" || field.inputType === "radio") {
+        return !field.checked;
+    }
+    const normalizedValue = normalizeFormKey(value);
+    if (!normalizedValue) {
+        return true;
+    }
+    if (field.tag === "select" && SELECT_PLACEHOLDER_PATTERN.test(normalizedValue)) {
+        return true;
+    }
+    return false;
+}
+export function shouldCheckField(value) {
+    return value === CHECK_FIELD_SENTINEL;
+}

package/dist/core/gameplaySummary.js

@@ -0,0 +1,164 @@
+const HOW_TO_PLAY_PATTERNS = [/\bhow to play\b/i, /\brules?\b/i, /\binstructions?\b/i, /\btutorial\b/i, /\bhow it works\b/i];
+const REPLAY_PATTERNS = [/\bplay again\b/i, /\bnew game\b/i, /\brestart\b/i, /\bretry\b/i, /\bnext round\b/i];
+const ROUND_CONTEXT_PATTERNS = [
+    /\bgame over\b/i,
+    /\bround\b/i,
+    /\bscore\b/i,
+    /\bresult\b/i,
+    /\bplay again\b/i,
+    /\bnew game\b/i,
+    /\brestart\b/i,
+    /\bretry\b/i
+];
+const WIN_PATTERNS = [/\byou win\b/i, /\bvictory\b/i, /\bwon\b/i, /\bwinner\b/i, /\blevel complete\b/i];
+const LOSS_PATTERNS = [/\byou lose\b/i, /\blost\b/i, /\bdefeat\b/i, /\bgame over\b/i, /\bbetter luck next time\b/i];
+const DRAW_PATTERNS = [/\bdraw\b/i, /\btie\b/i, /\bstalemate\b/i];
+function normalizeText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function uniqueItems(items, limit) {
+    return [...new Set(items.map((item) => normalizeText(item)).filter(Boolean))].slice(0, limit);
+}
+function buildEntryText(entry) {
+    return normalizeText([
+        entry.title,
+        entry.url,
+        entry.decision.target,
+        entry.result.note,
+        entry.result.destinationTitle ?? "",
+        entry.result.destinationUrl ?? "",
+        entry.result.visibleTextSnippet ?? ""
+    ].join(" "));
+}
+function buildEntrySignature(entry, outcome) {
+    const rawSignature = normalizeText(`${outcome} ${entry.result.destinationTitle ?? ""} ${entry.result.visibleTextSnippet ?? ""} ${entry.result.note}`).toLowerCase();
+    return rawSignature.slice(0, 280);
+}
+function detectOutcome(entry) {
+    const text = buildEntryText(entry);
+    if (!text) {
+        return null;
+    }
+    const looksLikeRulesCopy = HOW_TO_PLAY_PATTERNS.some((pattern) => pattern.test(text));
+    const hasReplayCue = REPLAY_PATTERNS.some((pattern) => pattern.test(text));
+    const hasRoundContext = ROUND_CONTEXT_PATTERNS.some((pattern) => pattern.test(text));
+    if (!hasRoundContext) {
+        return null;
+    }
+    const isWin = WIN_PATTERNS.some((pattern) => pattern.test(text));
+    const isLoss = LOSS_PATTERNS.some((pattern) => pattern.test(text));
+    const isDraw = DRAW_PATTERNS.some((pattern) => pattern.test(text));
+    if (looksLikeRulesCopy && !hasReplayCue && !(isWin || isLoss || isDraw)) {
+        return null;
+    }
+    if (isDraw) {
+        return "draw";
+    }
+    if (isWin && !isLoss) {
+        return "win";
+    }
+    if (isLoss && !isWin) {
+        return "loss";
+    }
+    return null;
+}
+export function isGameplayTask(task) {
+    return Boolean(task.gameplay);
+}
+export function summarizeGameplayHistory(history) {
+    const evidence = [];
+    let wins = 0;
+    let losses = 0;
+    let draws = 0;
+    let howToPlayConfirmed = false;
+    let replayConfirmed = false;
+    let lastOutcomeSignature = "";
+    let lastOutcomeIndex = -100;
+    for (const [index, entry] of history.entries()) {
+        const text = buildEntryText(entry);
+        if (!text) {
+            continue;
+        }
+        if (!howToPlayConfirmed && HOW_TO_PLAY_PATTERNS.some((pattern) => pattern.test(text))) {
+            howToPlayConfirmed = true;
+            evidence.push(`Visible rules or how-to-play guidance appeared during step ${entry.step}.`);
+        }
+        if (!replayConfirmed && REPLAY_PATTERNS.some((pattern) => pattern.test(text))) {
+            replayConfirmed = true;
+            evidence.push(`A replay or restart path was visible during step ${entry.step}.`);
+        }
+        const outcome = detectOutcome(entry);
+        if (!outcome) {
+            continue;
+        }
+        const signature = buildEntrySignature(entry, outcome);
+        if (signature === lastOutcomeSignature && index - lastOutcomeIndex <= 1) {
+            continue;
+        }
+        lastOutcomeSignature = signature;
+        lastOutcomeIndex = index;
+        if (outcome === "win") {
+            wins += 1;
+        }
+        else if (outcome === "loss") {
+            losses += 1;
+        }
+        else {
+            draws += 1;
+        }
+        const label = outcome === "win" ? "win" : outcome === "loss" ? "loss" : "draw";
+        evidence.push(`Step ${entry.step} showed a visible ${label} state.`);
+    }
+    return {
+        roundsRecorded: wins + losses + draws,
+        wins,
+        losses,
+        draws,
+        howToPlayConfirmed,
+        replayConfirmed: replayConfirmed || wins + losses + draws > 1,
+        evidence: uniqueItems(evidence, 8)
+    };
+}
+export function deriveGameplaySummary(args) {
+    const gameplayTasks = args.suite.tasks.filter((task) => isGameplayTask(task));
+    const roundsRequested = Math.max(0, ...gameplayTasks.map((task) => task.gameplay?.rounds ?? 0));
+    if (roundsRequested <= 0) {
+        return undefined;
+    }
+    const gameplayTaskNames = new Set(gameplayTasks.map((task) => task.name));
+    const roundTaskNames = new Set(gameplayTasks.filter((task) => (task.gameplay?.rounds ?? 0) > 0).map((task) => task.name));
+    const relevantResults = args.taskResults.filter((task) => gameplayTaskNames.has(task.name));
+    const combinedHistory = relevantResults.flatMap((task) => task.history);
+    const roundHistory = args.taskResults.filter((task) => roundTaskNames.has(task.name)).flatMap((task) => task.history);
+    const combinedSummary = summarizeGameplayHistory(combinedHistory);
+    const roundSummary = summarizeGameplayHistory(roundHistory);
+    const inconclusiveRounds = Math.max(0, roundsRequested - roundSummary.roundsRecorded);
+    const blockerReason = relevantResults.find((task) => task.status !== "success" && normalizeText(task.reason))?.reason ??
+        (inconclusiveRounds > 0 ? "The requested number of clear round outcomes was not fully observed." : "");
+    const narrative = roundSummary.roundsRecorded >= roundsRequested
+        ? `Recorded ${roundSummary.roundsRecorded}/${roundsRequested} requested rounds: ${roundSummary.wins} wins, ${roundSummary.losses} losses, and ${roundSummary.draws} draws.`
+        : `Recorded ${roundSummary.roundsRecorded}/${roundsRequested} requested rounds: ${roundSummary.wins} wins, ${roundSummary.losses} losses, ${roundSummary.draws} draws, and ${inconclusiveRounds} inconclusive round(s).`;
+    return {
+        roundsRequested,
+        roundsRecorded: roundSummary.roundsRecorded,
+        wins: roundSummary.wins,
+        losses: roundSummary.losses,
+        draws: roundSummary.draws,
+        inconclusiveRounds,
+        howToPlayConfirmed: combinedSummary.howToPlayConfirmed,
+        replayConfirmed: combinedSummary.replayConfirmed,
+        summary: normalizeText([
+            narrative,
+            combinedSummary.howToPlayConfirmed ? "Visible how-to-play guidance was confirmed." : "Visible how-to-play guidance was not clearly confirmed.",
+            combinedSummary.replayConfirmed ? "A replay or restart path was visible." : "A replay or restart path was not clearly confirmed.",
+            inconclusiveRounds > 0 && blockerReason ? blockerReason : ""
+        ].join(" ")),
+        evidence: uniqueItems([
+            ...combinedSummary.evidence,
+            ...roundSummary.evidence,
+            combinedSummary.howToPlayConfirmed ? "How-to-play guidance was visibly encountered." : "",
+            combinedSummary.replayConfirmed ? "Replay or restart controls were visibly encountered." : "",
+            inconclusiveRounds > 0 && blockerReason ? blockerReason : ""
+        ], 8)
+    };
+}