@quenty/nevermore-cli 4.41.0 → 4.42.0

package/src/commands/test-command/test-command.ts

@@ -56,9 +56,9 @@ export class TestProjectCommand<T>
       type: 'string',
     });
     args.option('logs', {
-      describe: 'Show execution logs',
+      describe:
+        'Show execution logs. Defaults on with --script-text, whose output is the whole point of the run',
       type: 'boolean',
-      default: false,
     });
     args.option('universe-id', {
       describe:
@@ -84,7 +84,7 @@ export class TestProjectCommand<T>
     });
     args.option('timeout', {
       describe:
-        'Max script execution time in seconds. Sent to the Open Cloud API so Roblox cancels server-side on overrun (default: 120)',
+        'Max script execution time in seconds. Sent to the Open Cloud API so Roblox cancels server-side on overrun. Max 300s (API limit). (default: 300)',
       type: 'number',
     });
 
@@ -94,7 +94,10 @@ export class TestProjectCommand<T>
   public handler = async (args: TestProjectArgs) => {
     const cwd = process.cwd();
     const packageName = (await readPackageNameAsync(cwd)) ?? path.basename(cwd);
-    const showLogs = args.logs ?? false;
+    // A probe run exists to show its output. Hiding it behind an opt-in flag
+    // made --script-text look broken enough that a workaround was written into
+    // the docs instead of a bug report.
+    const showLogs = args.logs ?? args.scriptText !== undefined;
     const useSpinner = process.stdout.isTTY && !args.verbose;
 
     const reporter = new CompositeReporter(

package/src/utils/job-context/batch-script-job-context.ts

@@ -113,7 +113,11 @@ export class BatchScriptJobContext implements JobContext {
       return { success: false };
     }
 
-    return { success: result.success, durationMs: result.durationMs };
+    return {
+      success: result.success,
+      durationMs: result.durationMs,
+      errorMessage: result.error,
+    };
   }
 
   async getLogsAsync(deployment: Deployment): Promise<string> {

package/src/utils/open-cloud/open-cloud-client.ts

@@ -336,7 +336,10 @@ export class OpenCloudClient {
   private async _fetchRawLogsAsync(taskPath: string): Promise<string> {
     const apiKey = await this._resolveApiKeyAsync();
     const messages: string[] = [];
+    const structured: { message: string; createTime: string }[] = [];
     let pageToken: string | undefined;
+    let pagesFetched = 0;
+    let entriesFetched = 0;
 
     do {
       const url = new URL(`https://apis.roblox.com/cloud/v2/${taskPath}/logs`);
@@ -371,18 +374,41 @@ export class OpenCloudClient {
 
       for (const entry of data.luauExecutionSessionTaskLogs ?? []) {
         if (entry.structuredMessages?.length) {
+          // Keep createTime alongside the text: the API does not guarantee
+          // chronological order, and readers downstream assume it.
           for (const msg of entry.structuredMessages) {
-            messages.push(msg.message);
+            structured.push({
+              message: msg.message,
+              createTime: msg.createTime,
+            });
           }
         } else if (entry.messages?.length) {
           messages.push(...entry.messages);
         }
       }
 
+      entriesFetched += (data.luauExecutionSessionTaskLogs ?? []).length;
+      pagesFetched++;
       pageToken = data.nextPageToken || undefined;
     } while (pageToken);
 
-    return messages.join('\n');
+    // Out-of-order messages silently destroy marker-delimited parsing: a
+    // trailing summary that arrives early ends the scan before any of the
+    // output it summarizes has been read.
+    structured.sort((a, b) => a.createTime.localeCompare(b.createTime));
+    messages.push(...structured.map((m) => m.message));
+
+    const text = messages.join('\n');
+
+    // Log volume is the prime suspect when engine output goes missing between
+    // the task and the parser, and the parser cannot tell a short run from a
+    // truncated fetch. Record what arrived so a real run can settle it.
+    OutputHelper.verbose(
+      `[open-cloud] Task logs: ${pagesFetched} page(s), ${entriesFetched} entries, ` +
+        `${messages.length} messages, ${text.length} chars`
+    );
+
+    return text;
   }
 
   /**

package/src/utils/testing/parsers/batch-log-parser.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  countTracebacks,
+  findSummaryEntries,
+  parseBatchTestLogs,
+} from './batch-log-parser.js';
+
+const SLUG_MAP = new Map([['egghunt2026', 'egghunt2026']]);
+
+function buildLogs(section: string): string {
+  return [
+    '===BATCH_TEST_BEGIN egghunt2026===',
+    section,
+    '===BATCH_TEST_END egghunt2026 PASS 1000===',
+    '===BATCH_TEST_SUMMARY===',
+    '[{"slug":"egghunt2026","success":true,"durationMs":1000}]',
+  ].join('\n');
+}
+
+describe('parseBatchTestLogs', () => {
+  it('reads test counts out of a package section', () => {
+    const logs = buildLogs('Tests:  275 passed, 275 total');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.testCounts).toEqual({ passed: 275, failed: 0, total: 275 });
+  });
+
+  it('attributes a section closed by END when its BEGIN was dropped', () => {
+    // Open Cloud keeps only the tail of a long run's log, so BEGIN — printed
+    // first — is the first casualty while END and the summary survive.
+    const logs = [
+      '  ✓ some test that survived (3 ms)',
+      'Tests:  275 passed, 275 total',
+      '===BATCH_TEST_END egghunt2026 PASS 1000===',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"egghunt2026","success":true,"durationMs":1000}]',
+    ].join('\n');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.success).toBe(true);
+    expect(result?.testCounts).toEqual({ passed: 275, failed: 0, total: 275 });
+  });
+
+  it('does not let an out-of-order END steal another package’s output', () => {
+    // The API does not deliver messages in order, so a stray END can arrive
+    // mid-section. Only the first section can have lost its head; past that the
+    // log is well-formed and a BEGIN-less END must not claim anything.
+    const twoPackages = new Map([
+      ['alpha', 'alpha'],
+      ['beta', 'beta'],
+    ]);
+    const logs = [
+      '===BATCH_TEST_BEGIN alpha===',
+      'Tests:  10 passed, 10 total',
+      '===BATCH_TEST_END beta PASS 5===',
+      '===BATCH_TEST_END alpha PASS 10===',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"alpha","success":true},{"slug":"beta","success":true}]',
+    ].join('\n');
+
+    const results = parseBatchTestLogs(logs, twoPackages);
+
+    expect(results.get('alpha')?.testCounts?.total).toBe(10);
+    // beta never had a section of its own; it must not inherit alpha's.
+    expect(results.get('beta')?.testCounts).toBeUndefined();
+    expect(results.get('beta')?.success).toBe(false);
+  });
+
+  it('fails a pass it cannot read, rather than trusting the pcall', () => {
+    // No END marker either, so there is no boundary to attribute output with.
+    // The pcall said success, but nothing here saw a test run.
+    const logs = [
+      'Tests:  275 passed, 275 total',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"egghunt2026","success":true,"durationMs":1000}]',
+    ].join('\n');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.success).toBe(false);
+    expect(result?.error).toContain('no output could be attributed');
+    expect(result?.testCounts).toBeUndefined();
+  });
+
+  it('still shows output it could not attribute', () => {
+    // 330KB of real test output was being reported as "(no output)" because no
+    // BEGIN marker survived to delimit it.
+    const logs = [
+      'PlayerBadgeHelper: attempt to index nil',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"egghunt2026","success":true,"durationMs":1000}]',
+    ].join('\n');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.logs).toContain('PlayerBadgeHelper');
+  });
+
+  it('counts tracebacks that jest reports as a clean pass', () => {
+    const logs = buildLogs(
+      [
+        'Tests:  155 passed, 155 total',
+        'PlayerBadgeHelper: attempt to index nil',
+        'Stack Begin',
+        "Script 'PlayerBadgeHelper', Line 365",
+        'Stack End',
+      ].join('\n')
+    );
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.testCounts?.failed).toBe(0);
+    expect(result?.tracebackCount).toBe(1);
+  });
+});
+
+describe('findSummaryEntries', () => {
+  it('finds the summary even when output landed after it', () => {
+    // Messages are not delivered in order, so a stray line can follow the
+    // summary. Treating the whole remainder as one JSON blob made the same
+    // batch parse on one run and fail on the next.
+    const lines = [
+      '[{"slug":"alpha","success":true}]',
+      '  ✓ a stray line that arrived late',
+    ];
+
+    expect(findSummaryEntries(lines, 0)).toEqual([
+      { slug: 'alpha', success: true },
+    ]);
+  });
+
+  it('returns undefined when there is no array to find', () => {
+    expect(findSummaryEntries(['not json at all'], 0)).toBeUndefined();
+  });
+});
+
+describe('countTracebacks', () => {
+  it('counts each traceback separately', () => {
+    expect(countTracebacks('Stack Begin\nfoo\nStack End\nStack Begin\n')).toBe(
+      2
+    );
+  });
+
+  it('is zero for empty output', () => {
+    expect(countTracebacks('')).toBe(0);
+  });
+});

package/src/utils/testing/parsers/batch-log-parser.ts

@@ -1,5 +1,10 @@
 import { OutputHelper } from '@quenty/cli-output-helpers';
-import { type ParsedTestCounts, parseTestCounts } from '../test-log-parser.js';
+import {
+  type ParsedTestCounts,
+  evaluateTestOutcome,
+  parseTestCounts,
+} from '../test-log-parser.js';
+import { formatTracebacks, parseTracebacks } from './traceback-parser.js';
 
 export interface BatchPackageResult {
   slug: string;
@@ -8,6 +13,14 @@ export interface BatchPackageResult {
   /** Inner pcall execution time reported by the Luau batch runner. */
   durationMs?: number;
   testCounts?: ParsedTestCounts;
+  /** Why this package failed, when the failure is the parser's own verdict. */
+  error?: string;
+  /**
+   * Luau tracebacks found in this package's section. Reported, not gated on:
+   * jest cannot count these, since a deferred-callback crash fires outside any
+   * test — often after the test that scheduled it already passed.
+   */
+  tracebackCount: number;
 }
 
 const BEGIN_MARKER = '===BATCH_TEST_BEGIN ';
@@ -51,10 +64,17 @@ export function parseBatchTestLogs(
   // ── Pass 1: Extract per-package log sections from markers ──
 
   const logSections = new Map<string, string>();
+  /** Sections closed by an END whose BEGIN never arrived — start of output lost. */
+  const partialSections = new Set<string>();
   const markerDurations = new Map<string, number>();
   let currentSlug: string | null = null;
   let currentLines: string[] = [];
   let summaryLineIndex = -1;
+  let beginMarkersSeen = 0;
+  let endMarkersSeen = 0;
+  let strayEndMarkers = 0;
+  /** Only one section can have lost its head: the one the log was cut inside. */
+  let headSectionClaimed = false;
 
   // Matches "<slug> PASS|FAIL [<durationMs>]" — slugs have no whitespace.
   const endInnerPattern = /^(\S+)\s+(?:PASS|FAIL)(?:\s+(\d+))?$/;
@@ -65,25 +85,47 @@ export function parseBatchTestLogs(
     if (trimmed.startsWith(BEGIN_MARKER) && trimmed.endsWith('===')) {
       currentSlug = trimmed.slice(BEGIN_MARKER.length, -3);
       currentLines = [];
+      beginMarkersSeen++;
       continue;
     }
 
     if (trimmed.startsWith(END_MARKER) && trimmed.endsWith('===')) {
       const inner = trimmed.slice(END_MARKER.length, -3);
+      endMarkersSeen++;
       const match = endInnerPattern.exec(inner);
       const endSlug = match ? match[1] : inner;
       const durationStr = match?.[2];
 
-      if (currentSlug && endSlug === currentSlug) {
-        logSections.set(currentSlug, currentLines.join('\n'));
+      // A section normally closes on the END matching its own BEGIN.
+      const closesOwnSection = endSlug === currentSlug;
+
+      // Open Cloud keeps only the tail of a long run's log, so BEGIN — printed
+      // first — can be lost while END and the summary survive. Recovering that
+      // means letting an END with no open section claim what precedes it, but
+      // only where the head can actually have been dropped: before any BEGIN
+      // has survived, and only once. Past that point the log is well-formed,
+      // and a BEGIN-less END is a message delivered out of order (the API does
+      // not order them), which must not be allowed to claim another package's
+      // output.
+      const closesDroppedHead =
+        currentSlug === null && beginMarkersSeen === 0 && !headSectionClaimed;
+
+      if (closesOwnSection || closesDroppedHead) {
+        logSections.set(endSlug, currentLines.join('\n'));
+        if (closesDroppedHead) {
+          partialSections.add(endSlug);
+          headSectionClaimed = true;
+        }
         if (durationStr !== undefined) {
-          markerDurations.set(currentSlug, parseInt(durationStr, 10));
+          markerDurations.set(endSlug, parseInt(durationStr, 10));
         }
         currentSlug = null;
         currentLines = [];
+      } else {
+        // Reordered marker from another package. Ignore it without resetting
+        // state, so the section it interrupted still closes on its own END.
+        strayEndMarkers++;
       }
-      // If endSlug doesn't match currentSlug, this is a reordered marker
-      // from another package — ignore it without resetting state.
       continue;
     }
 
@@ -92,9 +134,9 @@ export function parseBatchTestLogs(
       break;
     }
 
-    if (currentSlug) {
-      currentLines.push(lines[i]);
-    }
+    // Accumulate unconditionally: output that precedes the first surviving
+    // BEGIN still belongs to whichever package's END closes it.
+    currentLines.push(lines[i]);
   }
 
   // ── Pass 2: Parse the JSON summary for authoritative pcall results ──
@@ -102,12 +144,16 @@ export function parseBatchTestLogs(
   const summaryResults = new Map<string, boolean>();
   const summaryDurations = new Map<string, number>();
   if (summaryLineIndex >= 0 && summaryLineIndex + 1 < lines.length) {
-    const jsonLine = lines
-      .slice(summaryLineIndex + 1)
-      .join('\n')
-      .trim();
-    try {
-      const entries = JSON.parse(jsonLine) as SummaryEntry[];
+    const entries = findSummaryEntries(lines, summaryLineIndex + 1);
+    if (entries === undefined) {
+      OutputHelper.verbose(
+        `[batch-log-parser] Failed to parse JSON summary after line ${summaryLineIndex}: ` +
+          lines
+            .slice(summaryLineIndex + 1, summaryLineIndex + 3)
+            .join('\n')
+            .slice(0, 200)
+      );
+    } else {
       for (const entry of entries) {
         summaryResults.set(entry.slug, entry.success);
         if (typeof entry.durationMs === 'number') {
@@ -122,20 +168,20 @@ export function parseBatchTestLogs(
         );
       }
       console.error(
-        `[batch-log-parser] Parsed ${entries.length} summary entries, ${failures.length} failures`
-      );
-    } catch {
-      OutputHelper.verbose(
-        `[batch-log-parser] Failed to parse JSON summary: ${jsonLine.slice(
-          0,
-          200
-        )}`
+        `[batch-log-parser] Parsed ${entries.length} summary entries, ${failures.length} pcall failures`
       );
     }
   }
 
   // ── Warn when the batch produced no recognizable output ──
 
+  if (strayEndMarkers > 0) {
+    OutputHelper.verbose(
+      `[batch-log-parser] Ignored ${strayEndMarkers} out-of-order END marker(s); ` +
+        'their sections closed on their own boundaries.'
+    );
+  }
+
   const noOutputAtAll = logSections.size === 0 && summaryResults.size === 0;
   if (noOutputAtAll) {
     OutputHelper.warn(
@@ -144,35 +190,111 @@ export function parseBatchTestLogs(
     );
   }
 
+  // The summary is printed last, so it survives a log fetch that dropped the
+  // output above it. Summary present with no sections is exactly that case, and
+  // it is invisible to the check above — the results below would then be built
+  // from pcall exit status alone, knowing nothing about what actually ran.
+  const lostSectionOutput = logSections.size === 0 && summaryResults.size > 0;
+  if (lostSectionOutput) {
+    OutputHelper.warn(
+      `[batch-log-parser] Received ${rawLogs.length} chars of output but could not ` +
+        `attribute any of it to a package section ` +
+        `(${beginMarkersSeen} BEGIN, ${endMarkersSeen} END markers; summary at line ` +
+        `${summaryLineIndex} of ${lines.length}). ` +
+        'Test counts are not derived from unattributed output.'
+    );
+    // BEGIN is printed first and the summary last, so their positions separate
+    // the two ways this happens: a log window that dropped the head keeps the
+    // summary at the end, while reordered messages put it early.
+    OutputHelper.warn(
+      summaryLineIndex >= lines.length - 2
+        ? '[batch-log-parser] Summary sits at the end of the log — consistent with the head being dropped by a log size/retention limit.'
+        : '[batch-log-parser] Summary sits early in the log — consistent with out-of-order messages ending the scan prematurely.'
+    );
+  }
+
   // ── Pass 3: Combine log sections with summary results ──
 
-  // When the batch produced zero output, surface the raw error in every
-  // package's logs so reporters show the actual failure instead of "(no output)".
-  const fallbackLogs = noOutputAtAll ? rawLogs.trim() : '';
+  // Output that arrived but could not be split into sections is still output.
+  // Reporting "(no output)" over it hides the very thing needed to diagnose the
+  // parse failure, so it is shown verbatim instead. Only safe to hand to a
+  // single package: with several, there is no way to say whose output this is.
+  const fallbackLogs = noOutputAtAll || lostSectionOutput ? rawLogs.trim() : '';
+
+  // The unattributed stream is the same text for every package, so it is
+  // attached once rather than repeated per package across a large log.
+  let unattributedClaimed = false;
 
   for (const [packageName, slug] of slugMap) {
-    const sectionLogs = logSections.get(slug) ?? fallbackLogs;
+    const attributedLogs = logSections.get(slug);
+    let sectionLogs = attributedLogs ?? '';
+    if (!attributedLogs && fallbackLogs && !unattributedClaimed) {
+      sectionLogs = fallbackLogs;
+      unattributedClaimed = true;
+    }
     const summarySuccess = summaryResults.get(slug);
+    const reasons: string[] = [];
 
-    // The JSON summary (pcall result) is the primary success signal.
-    // Jest failure detection provides a secondary override.
+    // The pcall result only proves the script did not throw. It is a floor, not
+    // a verdict — everything below can fail a run it called successful.
     let success = summarySuccess ?? false;
-    if (success && sectionLogs) {
-      const hasJestFailures = _hasJestFailuresInLogs(sectionLogs);
-      if (hasJestFailures) {
+    if (summarySuccess === false) {
+      reasons.push('the batch runner reported a Luau error');
+    } else if (summarySuccess === undefined) {
+      // Absent from the summary is a different fault from failing in it, and
+      // conflating them sends you hunting for a Luau error that never happened.
+      reasons.push('this package is missing from the batch summary');
+    }
+
+    if (attributedLogs !== undefined) {
+      const outcome = evaluateTestOutcome(attributedLogs, {
+        requireTestReport: true,
+      });
+      if (!outcome.success) {
         success = false;
+        reasons.push(...outcome.failureReasons);
       }
+    } else {
+      // Judged unreadable rather than judged by content: whatever broke
+      // attribution is reason enough not to trust which package a line is from.
+      success = false;
+      reasons.push(
+        `no output could be attributed to this package ` +
+          `(${rawLogs.length} chars received, ${beginMarkersSeen} BEGIN markers found)`
+      );
     }
 
-    if (!success && !noOutputAtAll) {
-      console.error(
-        `[batch-log-parser] ${slug}: summarySuccess=${summarySuccess} hasLogs=${
-          sectionLogs.length > 0
-        } logsLen=${sectionLogs.length}`
+    if (partialSections.has(slug)) {
+      OutputHelper.warn(
+        `[batch-log-parser] ${slug}: section closed by its END marker with no BEGIN — ` +
+          'the start of this output was dropped by the log window, so the section is partial.'
       );
     }
 
-    const testCounts = sectionLogs ? parseTestCounts(sectionLogs) : undefined;
+    // Attribute by script path, not by log position: a deferred callback can
+    // fire during another package's section.
+    const tracebacks = parseTracebacks(sectionLogs);
+    const tracebackCount = tracebacks.reduce((sum, t) => sum + t.count, 0);
+    const owned = tracebacks.filter((t) => !t.owner || t.owner === slug);
+    if (tracebacks.length > owned.length) {
+      OutputHelper.verbose(
+        `[batch-log-parser] ${slug}: ignored ${
+          tracebacks.length - owned.length
+        } traceback(s) belonging to other packages`
+      );
+    }
+    if (owned.length > 0) {
+      OutputHelper.warn(
+        `[batch-log-parser] ${slug}: ${owned.length} distinct traceback(s):\n` +
+          formatTracebacks(owned)
+      );
+    }
+
+    const error = reasons.length > 0 ? reasons.join('; ') : undefined;
+
+    const testCounts = attributedLogs
+      ? parseTestCounts(attributedLogs)
+      : undefined;
     // Prefer the JSON summary (authoritative, immune to log reordering);
     // fall back to the END-marker value if the summary was truncated.
     const durationMs = summaryDurations.get(slug) ?? markerDurations.get(slug);
@@ -182,6 +304,8 @@ export function parseBatchTestLogs(
       logs: sectionLogs,
       durationMs,
       testCounts,
+      tracebackCount,
+      error,
     });
   }
 
@@ -189,16 +313,44 @@ export function parseBatchTestLogs(
 }
 
 /**
- * Check specifically for Jest test suite/test failures in logs.
- * Unlike parseTestLogs, this ignores "Stack Begin" runtime errors since
- * those can come from deferred callbacks of other packages in batch mode.
+ * Find the summary array in the lines following the summary marker.
+ *
+ * The marker is printed last, but the API does not deliver messages in order,
+ * so unrelated output can land after it. Treating everything past the marker as
+ * one JSON blob therefore fails intermittently — the same batch parses on one
+ * run and not the next. Scan for the array instead of assuming it is alone.
  */
-function _hasJestFailuresInLogs(rawOutput: string): boolean {
-  const cleanLogs = OutputHelper.stripAnsi(rawOutput);
-  const failedSuites = cleanLogs.match(/Test Suites:\s*(\d+)\s+failed/);
-  const failedTests = cleanLogs.match(/Tests:\s*(\d+)\s+failed/);
-  return (
-    (failedSuites != null && parseInt(failedSuites[1], 10) > 0) ||
-    (failedTests != null && parseInt(failedTests[1], 10) > 0)
-  );
+export function findSummaryEntries(
+  lines: string[],
+  startIndex: number
+): SummaryEntry[] | undefined {
+  const MAX_SPAN = 50;
+
+  for (let i = startIndex; i < lines.length; i++) {
+    if (!lines[i].trim().startsWith('[')) {
+      continue;
+    }
+
+    // Normally one line, but allow the array to span a few in case the runner
+    // or the transport breaks it up.
+    for (let end = i; end < Math.min(lines.length, i + MAX_SPAN); end++) {
+      try {
+        const parsed = JSON.parse(
+          lines
+            .slice(i, end + 1)
+            .join('\n')
+            .trim()
+        );
+        if (Array.isArray(parsed)) {
+          return parsed as SummaryEntry[];
+        }
+      } catch {
+        // Incomplete so far — grow the window and try again.
+      }
+    }
+  }
+
+  return undefined;
 }
+
+export { countTracebacks } from '../test-log-parser.js';

package/src/utils/testing/parsers/traceback-parser.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  formatTracebacks,
+  ownerOf,
+  parseTracebacks,
+} from './traceback-parser.js';
+
+const TRACEBACK = [
+  'PlayerBadgeHelper: attempt to index nil with UserId',
+  'Stack Begin',
+  'Script \'[string "ServerScriptService.egghunt2026.game.Server.PlayerBadgeHelper"]\', Line 365 - function _awardBadge',
+  'Script \'[string "ServerScriptService.egghunt2026.game.Server.PlayerBadgeHelper"]\', Line 138',
+  'Stack End',
+].join('\n');
+
+describe('parseTracebacks', () => {
+  it('attributes a traceback to the package that owns the failing script', () => {
+    const [traceback] = parseTracebacks(TRACEBACK);
+
+    expect(traceback.owner).toBe('egghunt2026');
+    expect(traceback.source).toContain('PlayerBadgeHelper');
+    expect(traceback.message).toContain('attempt to index nil');
+  });
+
+  it('collapses repeats of the same crash into one entry with a count', () => {
+    // One bug fires per player per frame, so raw output can hold hundreds of
+    // identical copies. Printing them all is what makes logs unreadable.
+    const repeated = [TRACEBACK, TRACEBACK, TRACEBACK].join('\n');
+
+    const tracebacks = parseTracebacks(repeated);
+
+    expect(tracebacks).toHaveLength(1);
+    expect(tracebacks[0].count).toBe(3);
+  });
+
+  it('keeps distinct crashes apart', () => {
+    const other = TRACEBACK.replace('PlayerBadgeHelper', 'TrainHelper');
+
+    expect(parseTracebacks([TRACEBACK, other].join('\n'))).toHaveLength(2);
+  });
+
+  it('finds nothing in clean output', () => {
+    expect(parseTracebacks('Tests: 10 passed, 10 total')).toEqual([]);
+  });
+});
+
+describe('ownerOf', () => {
+  it('names the package below the service', () => {
+    expect(ownerOf('ServerScriptService.brio.Foo.Bar')).toBe('brio');
+  });
+});
+
+describe('formatTracebacks', () => {
+  it('bounds how many it prints and says how many it withheld', () => {
+    const many = Array.from({ length: 8 }, (_, i) =>
+      TRACEBACK.replace('PlayerBadgeHelper:', `Helper${i}:`)
+    ).join('\n');
+
+    const formatted = formatTracebacks(parseTracebacks(many), 5);
+
+    expect(formatted).toContain('and 3 more distinct traceback(s)');
+  });
+});