@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/utils/proxy-terminal.js

@@ -1,4 +1,5 @@
 import { spawn, exec } from "child_process";
+import { randomBytes } from "crypto";
 import path from "path";
 import fs from "fs";
 import os from "os";
@@ -16,16 +17,66 @@ const shellEnvVariables = {
 };
 let terminalProcess;
 let terminalPID;
+// Windows closes its console window by title rather than by PID. cmd.exe has no
+// built-in variable for its own process id, so the PID file it used to write
+// never held a number and cleanup silently did nothing (SKYR-4446). The title
+// carries a timestamp so a stop closes the window this session opened and
+// leaves a window from an earlier session alone.
+const WINDOWS_TERMINAL_TITLE_PREFIX = "Skyramp Trace Collection";
+let windowsTerminalTitle;
+// Titles of windows a stop failed to close and a later launch then displaced.
+// Kept so the user is still told which windows are open: clearing them on the
+// next successful close would silently drop the older orphans.
+const orphanedWindowsTerminalTitles = [];
+// The stamp avoids colons: taskkill takes the title as a quoted /FI value, and
+// a colon there is needlessly awkward to reproduce by hand when checking with
+// `tasklist /FI "WINDOWTITLE eq ..."`.
+//
+// The trailing nonce is not decoration. `taskkill /FI "WINDOWTITLE eq ..."`
+// terminates *every* process tree whose title matches, so a title unique only
+// to the second lets two windows opened in the same second - two editors, two
+// workspaces, two server processes - collide, and stopping one would kill the
+// other. The nonce makes each launch its own identity.
+export function makeWindowsTerminalTitle(now = new Date()) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ` +
+        `${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+    const nonce = randomBytes(4).toString("hex");
+    return `${WINDOWS_TERMINAL_TITLE_PREFIX} ${stamp} ${nonce}`;
+}
+// buildWindowsTerminalArgs assembles the `cmd` arguments that open the titled
+// window. Split out from openProxyTerminal so the shape can be asserted without
+// spawning anything - the title silently going missing here is exactly the
+// regression the title-based cleanup cannot survive.
+export function buildWindowsTerminalArgs(title) {
+    // `start` reads its first *quoted* argument as the window title. libuv quotes
+    // an argument containing whitespace (also an empty one, or one containing a
+    // double quote), and the title always has spaces, so cmd receives
+    // `start "Skyramp Trace Collection ..." cmd /k <script>`. A title without
+    // spaces would arrive unquoted and `start` would treat it as the command to
+    // run, so the spaces are load-bearing.
+    //
+    // This holds only while the spawn passes no `shell` option: `shell: true`
+    // resolving to cmd.exe forces windowsVerbatimArguments, which would skip the
+    // quoting and silently un-title the window. No unit test on this array can
+    // catch that, so do not add a shell option to the launch without revisiting.
+    return ["/c", "start", title, "cmd", "/k"];
+}
 function getTerminalConfig() {
     const platform = os.platform();
     switch (platform) {
         case "win32":
             return {
                 command: "cmd",
-                args: ["/c", "start", "cmd", "/k"],
+                // Never used: openProxyTerminal replaces args wholesale on win32 with
+                // buildWindowsTerminalArgs(title), which is the only source of truth.
+                // Editing this array changes nothing. Kept only to satisfy the type.
+                args: [],
                 scriptExtension: ".bat",
                 scriptHeader: "@echo off",
-                pidCommand: "echo %$",
+                // Unused on Windows: cmd.exe cannot report its own PID, so the script
+                // writes no PID file and the window is closed by title instead.
+                pidCommand: "",
             };
         case "darwin":
             return {
@@ -48,9 +99,11 @@ function getTerminalConfig() {
             };
     }
 }
-function createEnvironmentScript(config) {
+function createEnvironmentScript(config, scriptId) {
     const tempDir = os.tmpdir();
-    const scriptPath = path.join(tempDir, `skyramp-launch${config.scriptExtension}`);
+    // Per-launch filename. With a shared name, the 2s cleanup timer from one
+    // launch deletes the next launch's script while its cmd is still reading it.
+    const scriptPath = path.join(tempDir, `skyramp-launch-${scriptId}${config.scriptExtension}`);
     const pidFile = path.join(tempDir, "skyramp-terminal.pid");
     const infoMessage = os.platform() === "win32"
         ? "A new terminal has been spawned here by Skyramp to enable trace collection.\\nAsk skyramp agent to stop trace to terminate trace collection and return to where you were.\\nFor more information, visit skyramp.dev/docs."
@@ -61,11 +114,18 @@ function createEnvironmentScript(config) {
         const setStatements = Object.entries(shellEnvVariables)
             .map(([key, value]) => `set ${key}=${value}`)
             .join("\n");
+        // Deliberately no trailing `cmd /k`: the window is already launched as
+        // `cmd /k <script>`, so it drops to an interactive prompt with these vars
+        // applied once the script ends. Starting a second cmd inside the same
+        // console would be redundant, and a nested shell appends to the console
+        // title - which would move the title out from under the exact-match
+        // taskkill filter that closes this window (SKYR-4446).
+        //
+        // No PID file either: cmd.exe has no variable holding its own process id,
+        // so anything echoed would be a literal string.
         scriptContent = `${config.scriptHeader}
 ${setStatements}
-echo %^%^% > "${pidFile}"
-echo ${infoMessage}
-cmd /k`;
+echo ${infoMessage}`;
     }
     else {
         // Unix-like script (macOS/Linux)
@@ -155,11 +215,35 @@ async function findAvailableTerminal() {
     logger.warning("No common Linux terminal found, falling back to xterm");
     return "xterm";
 }
+// The launcher hands the script to a console that reads it asynchronously, so
+// the file cannot be removed the moment the launcher exits.
+const SCRIPT_CLEANUP_DELAY_MS = 2000;
+function scheduleScriptCleanup(scriptPath) {
+    setTimeout(() => {
+        try {
+            if (fs.existsSync(scriptPath)) {
+                fs.unlinkSync(scriptPath);
+                logger.debug("Script file cleaned up", { scriptPath });
+            }
+        }
+        catch (scriptCleanupError) {
+            logger.debug("Script cleanup completed with minor issues", {
+                error: scriptCleanupError instanceof Error
+                    ? scriptCleanupError.message
+                    : String(scriptCleanupError),
+            });
+        }
+    }, SCRIPT_CLEANUP_DELAY_MS);
+}
 export default async function openProxyTerminal() {
     logger.info("Starting cross-platform proxy terminal creation", {
         platform: os.platform(),
         arch: os.arch(),
     });
+    // Which title this launch owns, so both error paths can tell their own
+    // failure from a newer launch's success. Declared out here so the catch
+    // below sees it too.
+    let launchedTitle;
     try {
         const config = getTerminalConfig();
         // For Linux, try to find an available terminal
@@ -176,7 +260,20 @@ export default async function openProxyTerminal() {
                 }
             }
         }
-        const scriptPath = createEnvironmentScript(config);
+        if (os.platform() === "win32") {
+            // A title still set here belongs to a window a previous stop failed to
+            // close. Overwriting it is how that window's handle is actually lost, so
+            // carry it forward rather than let a later stop claim nothing was opened.
+            if (windowsTerminalTitle) {
+                logger.warning("Previous Windows trace terminal was never closed; its window must be " +
+                    "closed by hand", { title: windowsTerminalTitle });
+                orphanedWindowsTerminalTitles.push(windowsTerminalTitle);
+            }
+            windowsTerminalTitle = makeWindowsTerminalTitle();
+            launchedTitle = windowsTerminalTitle;
+            config.args = buildWindowsTerminalArgs(windowsTerminalTitle);
+        }
+        const scriptPath = createEnvironmentScript(config, randomBytes(4).toString("hex"));
         const pidFile = path.join(os.tmpdir(), "skyramp-terminal.pid");
         // Verify script exists before launching terminal
         if (!fs.existsSync(scriptPath)) {
@@ -217,6 +314,16 @@ export default async function openProxyTerminal() {
                 platform: os.platform(),
                 exitCode: code,
             });
+            // Windows writes no PID file - the script cannot produce one and cleanup
+            // works by window title instead - so there is nothing to wait for or read.
+            // Skipping the read also stops a stale skyramp-terminal.pid left by an
+            // older build from being parsed as this session's terminal. The script
+            // still has to be removed, so take that path directly rather than
+            // returning past it.
+            if (os.platform() === "win32") {
+                scheduleScriptCleanup(scriptPath);
+                return;
+            }
             // Wait for terminal to write PID and execute script
             // On macOS, Terminal.app takes longer to start and execute the script
             const cleanupDelay = os.platform() === "darwin" ? 10000 : 3000;
@@ -283,12 +390,42 @@ export default async function openProxyTerminal() {
                 }
             }, cleanupDelay);
         });
+        // Node emits "error" both for a failed spawn and for a later kill() that
+        // could not deliver its signal. Only the first means no window exists, so
+        // track whether the child ever started before treating an error as a
+        // non-launch - otherwise a failed kill would clear a live window's title
+        // and cleanup would skip taskkill entirely.
+        let hasSpawned = false;
+        terminalProcess.on("spawn", () => {
+            hasSpawned = true;
+        });
         terminalProcess.on("error", (error) => {
             logger.error("Terminal spawn error", {
                 platform: os.platform(),
                 command: config.command,
                 error: error.message,
             });
+            if (hasSpawned) {
+                // The window exists; this is a kill() that could not signal it. Leave
+                // the title alone so cleanup still runs taskkill against it.
+                return;
+            }
+            // Pre-spawn failure (ENOENT, permissions): reported here rather than by
+            // the synchronous catch below, and no window exists. Keeping the title
+            // would have the next stop taskkill a phantom and blame the user for it.
+            // Guarded on identity - a newer launch may already own the title.
+            if (windowsTerminalTitle === launchedTitle) {
+                windowsTerminalTitle = undefined;
+            }
+            // A displaced title from this same failed launch is not a real window
+            // either, so it must not linger in the orphan list.
+            if (launchedTitle) {
+                const at = orphanedWindowsTerminalTitles.indexOf(launchedTitle);
+                if (at !== -1) {
+                    orphanedWindowsTerminalTitles.splice(at, 1);
+                }
+            }
+            scheduleScriptCleanup(scriptPath);
         });
         logger.info("Cross-platform proxy terminal opened successfully", {
             platform: os.platform(),
@@ -296,6 +433,13 @@ export default async function openProxyTerminal() {
         });
     }
     catch (error) {
+        // The title is claimed before the script is written and before spawn can
+        // fail. Holding on to it after a failed launch would have a later stop
+        // taskkill a window that was never opened and tell the user to close it.
+        // Same ownership guard as the async error handler above.
+        if (windowsTerminalTitle === launchedTitle) {
+            windowsTerminalTitle = undefined;
+        }
         logger.error("Failed to open proxy terminal", {
             platform: os.platform(),
             error: error instanceof Error ? error.message : String(error),
@@ -303,17 +447,193 @@ export default async function openProxyTerminal() {
         throw error;
     }
 }
-export async function closeProxyTerminal() {
+// `cmd /c start` returns as soon as it has handed the window off, so the new
+// console can still be registering its title when a quick stop arrives. A
+// single taskkill would miss it and the window would be orphaned, so poll
+// briefly rather than give up on the first miss.
+const WINDOWS_CLOSE_TIMEOUT_MS = 5000;
+const WINDOWS_CLOSE_POLL_MS = 250;
+// Neither taskkill's text nor its exit code is trustworthy on its own: the exit
+// code for an unmatched filter is undocumented, and the whole message including
+// the SUCCESS: token is localised. So SUCCESS: is a fast path for the English
+// case only, and windowsTerminalIsGone below is the authority.
+const TASKKILL_SUCCESS = /\bSUCCESS:/i;
+// tasklist prints one row per match - image name, then PID - and a single
+// informational line when nothing matches. The prose is localised; the row
+// shape is not, so an "<image> <pid>" row is the locale-independent signal.
+const TASKLIST_ROW = /^\s*\S+\s+\d+\s/m;
+async function windowsTerminalIsGone(title) {
+    try {
+        const { stdout } = await execAsync(`tasklist /FI "WINDOWTITLE eq ${title}*" /NH`);
+        return !TASKLIST_ROW.test(stdout);
+    }
+    catch {
+        // tasklist unavailable: fall back to believing the taskkill output.
+        return false;
+    }
+}
+// Orphans are windows an earlier stop could not close and a later launch then
+// displaced. Every stop has another go at them and drops the ones that are no
+// longer there, so the list cannot grow without bound and a window the user
+// closed by hand stops being reported. One attempt each, no polling: these are
+// old windows, so the start-up race the current window can lose does not apply.
+//
+// A hard failure (taskkill missing, access denied) keeps the entry: that is the
+// case where the window really may still be open.
+async function retryOrphanedWindowsTerminals() {
+    if (orphanedWindowsTerminalTitles.length === 0) {
+        return;
+    }
+    const survivors = [];
+    for (const title of [...orphanedWindowsTerminalTitles]) {
+        try {
+            const { stdout, stderr } = await execAsync(`taskkill /FI "WINDOWTITLE eq ${title}*" /T /F`);
+            const output = `${stdout}${stderr}`.trim();
+            if (TASKKILL_SUCCESS.test(output)) {
+                logger.info("Closed a previously orphaned Windows terminal", { title });
+            }
+            else if (await windowsTerminalIsGone(title)) {
+                // The user closed it, or it died with its parent.
+                logger.debug("Orphaned Windows terminal is already gone", { title });
+            }
+            else {
+                survivors.push(title);
+            }
+        }
+        catch (err) {
+            const failure = err;
+            const output = `${failure?.stdout ?? ""}${failure?.stderr ?? ""}`.trim();
+            // A rejection is not proof the window is still there - see
+            // windowsTerminalIsGone. Ask tasklist rather than read the exit code.
+            if (TASKKILL_SUCCESS.test(output) ||
+                (await windowsTerminalIsGone(title))) {
+                logger.info("Previously orphaned Windows terminal is gone", { title });
+            }
+            else {
+                survivors.push(title);
+                logger.warning("Could not close a previously orphaned terminal", {
+                    title,
+                    error: output || (err instanceof Error ? err.message : String(err)),
+                });
+            }
+        }
+    }
+    orphanedWindowsTerminalTitles.length = 0;
+    orphanedWindowsTerminalTitles.push(...survivors);
+}
+async function closeWindowsTerminal(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? WINDOWS_CLOSE_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? WINDOWS_CLOSE_POLL_MS;
+    await retryOrphanedWindowsTerminals();
+    if (!windowsTerminalTitle) {
+        // Two ways to arrive here: nothing was opened (start failed, or stop ran
+        // twice), or earlier windows were opened and displaced. Only the second
+        // leaves anything on screen, so only it is worth telling the user about.
+        const orphans = [...orphanedWindowsTerminalTitles];
+        const reason = orphans.length
+            ? `${orphans.length} earlier trace terminal(s) were opened and could not be closed`
+            : "no trace terminal was opened by this server process";
+        logger.warning(`Skipping Windows terminal closure - ${reason}`, {
+            orphanedTitles: orphans,
+        });
+        return { closed: orphans.length === 0, reason, orphanedTitles: orphans };
+    }
+    const deadline = Date.now() + timeoutMs;
+    const title = windowsTerminalTitle;
+    let lastOutput = "";
+    for (;;) {
+        try {
+            // The trailing `*` is defensive: the filter is otherwise exact, and
+            // anything appending to the console title would put the window out of
+            // reach. The nonce is at the end of the title, so it survives it.
+            const { stdout, stderr } = await execAsync(`taskkill /FI "WINDOWTITLE eq ${title}*" /T /F`);
+            lastOutput = `${stdout}${stderr}`.trim();
+            if (TASKKILL_SUCCESS.test(lastOutput) ||
+                (await windowsTerminalIsGone(title))) {
+                logger.info("Windows terminal closed via window-title filter", {
+                    title,
+                    output: lastOutput,
+                });
+                // This window is gone, so its title is no longer a handle to anything
+                // and must not survive into the next stop. Cleared here rather than in
+                // closeProxyTerminal because this is the only place that knows the kill
+                // was confirmed - `closed` below is false whenever an earlier orphan is
+                // still outstanding, even though this window died.
+                //
+                // By identity: this path has awaited (see the same guard on the error
+                // paths), so a newer start may own the title by now.
+                if (windowsTerminalTitle === title) {
+                    windowsTerminalTitle = undefined;
+                }
+                // A success here says nothing about windows displaced earlier; those
+                // are still on screen and still the user's to close.
+                // No `title` on success, deliberately: callers read `title` as "this
+                // window is still open". Returning the one just killed would have the
+                // stop tool tell the user to close an already-terminated window
+                // whenever an older orphan kept `closed` false.
+                return {
+                    closed: orphanedWindowsTerminalTitles.length === 0,
+                    orphanedTitles: [...orphanedWindowsTerminalTitles],
+                };
+            }
+            // No match yet - either the window has not registered its title, or it is
+            // already gone. Both look the same here, so keep polling until the
+            // deadline and let the caller report the ambiguity.
+        }
+        catch (err) {
+            // A rejection is not proof of failure: taskkill can kill the titled root
+            // and still exit non-zero because a descendant could not be killed, and
+            // execAsync rejects on any non-zero exit. The rejection carries the same
+            // stdout/stderr, so test it before believing the exit code.
+            const failure = err;
+            const output = `${failure?.stdout ?? ""}${failure?.stderr ?? ""}`.trim();
+            lastOutput =
+                output ||
+                    (err instanceof Error ? err.message : String(err ?? "unknown error"));
+            if (TASKKILL_SUCCESS.test(lastOutput) ||
+                (await windowsTerminalIsGone(title))) {
+                logger.info("Windows terminal closed via window-title filter (taskkill exited non-zero)", { title, output: lastOutput });
+                if (windowsTerminalTitle === title) {
+                    windowsTerminalTitle = undefined;
+                }
+                return {
+                    closed: orphanedWindowsTerminalTitles.length === 0,
+                    orphanedTitles: [...orphanedWindowsTerminalTitles],
+                };
+            }
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+    const reason = `taskkill matched no window titled "${title}" within ` +
+        `${timeoutMs}ms` +
+        (lastOutput ? `: ${lastOutput}` : "");
+    logger.warning("Could not close Windows terminal", { title, lastOutput });
+    return {
+        closed: false,
+        title,
+        reason,
+        orphanedTitles: [...orphanedWindowsTerminalTitles],
+    };
+}
+export async function closeProxyTerminal(opts = {}) {
     logger.info("Starting cross-platform proxy terminal closure", {
         platform: os.platform(),
     });
+    let result = { closed: true };
     // Kill the spawn process if it exists
     if (terminalProcess) {
         const killResult = terminalProcess.kill();
         logger.debug("Terminal spawn process kill result", { killResult });
     }
-    // Handle platform-specific terminal closing
-    if (terminalPID) {
+    // Handle platform-specific terminal closing. Windows is handled first and
+    // without a PID: it never captures one (see closeWindowsTerminal).
+    if (os.platform() === "win32") {
+        result = await closeWindowsTerminal(opts);
+    }
+    else if (terminalPID) {
         try {
             const platform = os.platform();
             if (platform === "darwin") {
@@ -360,13 +680,6 @@ export async function closeProxyTerminal() {
                     logger.info("macOS terminal closed via AppleScript fallback");
                 }
             }
-            else if (platform === "win32") {
-                // Windows: Use taskkill with /T flag to kill process tree
-                await execAsync(`taskkill /PID ${terminalPID} /T /F`);
-                logger.info("Windows terminal and children closed via taskkill", {
-                    terminalPID,
-                });
-            }
             else {
                 // Linux: Send SIGTERM to process group
                 try {
@@ -411,20 +724,32 @@ export async function closeProxyTerminal() {
             }
         }
         catch (err) {
+            const reason = err instanceof Error ? err.message : String(err ?? "unknown error");
             logger.warning("Error during platform-specific terminal closure", {
                 platform: os.platform(),
                 terminalPID,
-                error: err instanceof Error ? err.message : String(err),
+                error: reason,
             });
+            result = { closed: false, reason };
         }
     }
     else {
-        logger.warning("No terminal PID available for cleanup - terminal may not have been properly tracked");
+        // Unix captures a real shell PID from the script; its absence means the
+        // terminal was never tracked, so nothing was closed. Say so rather than let
+        // the default {closed: true} report a cleanup that did not happen.
+        const reason = "no terminal PID was captured, so the terminal could not be closed";
+        logger.warning(`${reason} - it may not have been properly tracked`);
+        result = { closed: false, reason };
     }
-    // Reset state
+    // Reset state.
     terminalProcess = undefined;
     terminalPID = undefined;
+    // Nothing to reset for the title here: only the win32 path ever sets it, and
+    // closeWindowsTerminal clears it on a confirmed kill so a failed close keeps
+    // the handle for a retried stop.
     logger.info("Cross-platform proxy terminal closure completed", {
         platform: os.platform(),
+        closed: result.closed,
     });
+    return result;
 }

package/build/utils/rebaselineSnapshots.d.ts

@@ -6,7 +6,7 @@ import { z } from "zod";
  *
  * Bare filename only: no path separators, and no commas or whitespace, because the
  * list is joined with commas into `SKYRAMP_UPDATE_SNAPSHOTS` and split again in the
- * executor, where `a,b.png` would read as two baselines. One definition shared by
+ * test runtime, where `a,b.png` would read as two baselines. One definition shared by
  * both tools so they can never drift apart.
  */
 export declare const REBASELINE_SNAPSHOT_NAME_RE: RegExp;

package/build/utils/rebaselineSnapshots.js

@@ -7,7 +7,7 @@ import { z } from "zod";
  *
  * Bare filename only: no path separators, and no commas or whitespace, because the
  * list is joined with commas into `SKYRAMP_UPDATE_SNAPSHOTS` and split again in the
- * executor, where `a,b.png` would read as two baselines. One definition shared by
+ * test runtime, where `a,b.png` would read as two baselines. One definition shared by
  * both tools so they can never drift apart.
  */
 export const REBASELINE_SNAPSHOT_NAME_RE = /^[^/\\,\s]+\.png$/i;
@@ -22,21 +22,11 @@ export function baselineStem(name) {
     return path.basename(name).replace(/\.png$/i, "");
 }
 /**
- * Playwright's default snapshot layout, which is what the executor produces: the
- * baseline for `<stem>.png` lives in `<spec>-snapshots/` as `<stem>-<project>-<platform>.png`
- * (or `<stem>-<platform>.png` with no project, or `<stem>.png` under a custom
- * `snapshotPathTemplate`). Safe to assume here because TestExecutionService mounts
- * its own generated Playwright config over any the repo carries, so a repo cannot
- * relocate its snapshots out from under this rule.
- *
- * The executor's generated config declares no `projects`, but runner.sh passes
- * `--browser=chromium`, so Playwright names the implicit project "chromium" and a
- * refresh writes `<stem>-chromium-linux.png` (observed end to end on demoshop).
- * Baselines the Skyramp executor produced therefore round-trip exactly. A baseline
- * a repo's own CI wrote under another project name (`<stem>-Desktop-Chrome-linux.png`)
- * is a different file: the executor's refresh adds its own and leaves that one as
- * it was — the tool reports what it rewrote, and the repo's own suite is out of
- * scope for skyramp_execute_test (which never runs it).
+ * Playwright's default snapshot layout: the baseline for `<stem>.png` lives in
+ * `<spec>-snapshots/` as `<stem>-<project>-<platform>.png` (or `<stem>-<platform>.png`
+ * with no project, or `<stem>.png` under a custom `snapshotPathTemplate`). A repo
+ * config that sets another `snapshotPathTemplate` moves its baselines out from under
+ * this rule; the tool then reports them as not refreshed rather than claim a refresh.
  *
  * Anchored so a longer baseline cannot vouch for a shorter one: `page-001-wide-chromium-linux.png`
  * belongs to `page-001-wide.png` and must not satisfy a claim on `page-001.png`.

package/build/utils/removedUiElements.js

@@ -26,7 +26,7 @@
  * Every skip is logged at debug with its reason so a missing guard is diagnosable.
  */
 import * as fs from "fs";
-import { extractAddedAttributeValues, extractAttributeChanges } from "./frontendSelectors.js";
+import { extractAddedAttributeValues, extractAttributeChanges, } from "./frontendSelectors.js";
 import { escapeRegExp } from "./regex.js";
 import { logger } from "./logger.js";
 function defaultReadFile(absPath) {

package/build/utils/reportLanguage.js

@@ -46,7 +46,8 @@ export function isEnforcedReportLanguage(language) {
  *  ultimately caller-supplied, and a name lookup must never throw. */
 export function reportLanguageDisplayName(language) {
     try {
-        return new Intl.DisplayNames(["en"], { type: "language" }).of(language) ?? language;
+        return (new Intl.DisplayNames(["en"], { type: "language" }).of(language) ??
+            language);
     }
     catch {
         return language;
@@ -58,11 +59,36 @@ const UNTRANSLATED_WORDS = new Set([
     // Exact enum values only. NOT "passed"/"failed" — those are ordinary English
     // prose and are exactly what leaks in pytest summaries ("1 passed in 0.88s",
     // "failed: count was 13"; see letsramp/api-insight#215).
-    "pass", "fail", "skipped", "error", "unknown",
-    "critical", "high", "medium", "low",
-    "get", "post", "put", "patch", "delete", "head", "options",
-    "ui", "e2e", "api", "contract", "integration", "smoke", "fuzz", "load", "mock",
-    "http", "https", "json", "yaml", "ok",
+    "pass",
+    "fail",
+    "skipped",
+    "error",
+    "unknown",
+    "critical",
+    "high",
+    "medium",
+    "low",
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options",
+    "ui",
+    "e2e",
+    "api",
+    "contract",
+    "integration",
+    "smoke",
+    "fuzz",
+    "load",
+    "mock",
+    "http",
+    "https",
+    "json",
+    "yaml",
+    "ok",
 ]);
 /** A field must contain at least this many plain English prose words (after the
  *  stripping below) to be flagged — so identifier-and-timing-only details like
@@ -81,7 +107,9 @@ function countProseWords(text, script) {
     const withoutCode = text.replace(/`[^`]*`/g, " ");
     let proseWords = 0;
     for (const raw of withoutCode.split(/\s+/)) {
-        const token = raw.replace(/^[^A-Za-z0-9]+/, "").replace(/[^A-Za-z0-9]+$/, "");
+        const token = raw
+            .replace(/^[^A-Za-z0-9]+/, "")
+            .replace(/[^A-Za-z0-9]+$/, "");
         // Pure alphabetic words only: anything with digits or interior punctuation
         // (paths, file names, snake_case, versions, "10.8s") is not prose.
         if (token.length < 2 || !/^[A-Za-z]+$/.test(token))

package/build/utils/reportVerification.d.ts

@@ -38,14 +38,18 @@ export interface UnchangedFileClaimsInput {
     newTests: {
         testId?: string;
         fileName?: string;
-        repository?: string;
+        repository: string;
     }[];
     /** Maintenance verdicts (server-derived from skyramp_actions). `pomFile`, when set, is
      *  the file the edit actually lands in — see the UPDATE rule below. */
     verdicts: Pick<MaintenanceActionCore, "action" | "testFilePath" | "pomFile" | "rebaselineSnapshots" | "rebaselineOnly">[];
     /** owner/repo of the primary repo — used to exempt cross-repo newTest claims
      *  whose files live in a different checkout. */
-    primaryRepository?: string;
+    primaryRepository: string;
+    /** Every owner/repo this run analyzed, the primary included. A newTest claim
+     *  attributed outside this set names no checkout at all, so exempting it would
+     *  let an uncreated test ship behind a typo. */
+    knownRepositories: string[];
     /** SKYR-4250: a plan-only eval run generates nothing — `newTestsCreated`
      *  declares the approved GENERATE list — so no declaration can be backed by
      *  a working-tree change. Exempts the declaration half only; a maintenance
@@ -81,17 +85,19 @@ export interface UnchangedFileClaimsInput {
  *  - DELETE verdicts — applied deterministically by the delivery step, not
  *    necessarily reflected in the tree at report time.
  *  - IGNORE / VERIFY verdicts — assert that NO edit was needed.
- *  - Claims for files outside this checkout (cross-repo `repository`, or an
- *    absolute path resolving outside `repoRoot`) — a different checkout owns them.
+ *  - Claims for files outside this checkout (a `repository` naming another
+ *    checkout THIS RUN ANALYZED, or an absolute path resolving outside
+ *    `repoRoot`) — a different checkout owns them. A name the run does not know
+ *    owns nothing, so it is reported rather than exempted.
  */
 export declare function findUnchangedFileClaims(input: UnchangedFileClaimsInput): string[];
 /** One checkout of the run, and the owner/repo it holds. */
 export interface RepoCheckout {
     /** Absolute checkout path. */
     root: string;
-    /** owner/repo of this checkout, when the run recorded one. Undefined means the
-     *  checkout cannot be named, so nothing resolved in it can be attributed. */
-    repository?: string;
+    /** owner/repo of this checkout. The primary takes it from the root metadata,
+     *  a related repo from its own section key. */
+    repository: string;
     /** True for the run's primary checkout — the repo an entry with no `repository`
      *  already means downstream, so its citations are never stamped. */
     primary?: boolean;
@@ -105,7 +111,7 @@ export interface SourceCitationInput {
     issues: {
         sourceFile?: string;
         sourceSymbol?: string;
-        repository?: string;
+        repository: string;
     }[];
 }
 export interface SourceCitationCheck {