scenescout 3.23.0 → 3.23.2

package/dist/engine/check-replay.js

@@ -285,7 +285,7 @@ ol.steps { list-style:none; margin:10px 0 0; padding:0; }
 .why { margin:4px 0; font-size:13px; overflow-wrap:anywhere; }
 a.frame { display:grid; margin:6px 0 2px; max-width:min(100%,720px); color:var(--muted); font-size:12px; }
 a.frame > * { grid-area:1 / 1; }
-a.frame img { position:relative; max-width:100%; max-height:400px; object-fit:cover; object-position:top; border:1px solid var(--line); border-radius:6px; display:block; background:var(--panel); }
+a.frame img { position:relative; width:100%; max-height:400px; object-fit:cover; object-position:top; border:1px solid var(--line); border-radius:6px; display:block; background:var(--panel); }
 .gone-note { align-self:end; padding:2.6em 12px 12px; border:1px dashed var(--line); border-radius:6px; }
 .noframe, .none { color:var(--muted); font-size:12px; font-style:italic; margin:4px 0; }
 .note { color:var(--muted); font-size:13px; }

package/dist/engine/check-report.js

@@ -431,7 +431,7 @@ header.title h1 { font-size:22px; margin:0 0 4px; }
 header.title .subtitle { margin:0 0 8px; color:var(--muted); }
 h2 { font-size:17px; margin:28px 0 8px; border-bottom:1px solid var(--line); padding-bottom:4px; }
 table { border-collapse:collapse; width:100%; margin:8px 0; }
-th, td { border:1px solid var(--line); padding:5px 8px; text-align:left; vertical-align:top; overflow-wrap:anywhere; }
+th, td { border:1px solid var(--line); padding:5px 8px; text-align:left; vertical-align:top; overflow-wrap:break-word; }
 thead th, table.facts th { background:var(--head); }
 table.facts { width:auto; min-width:50%; }
 tr.test-head th { background:var(--head); font-weight:400; }
@@ -444,7 +444,8 @@ td.r-passed { color:var(--pass); font-weight:700; } td.r-failed, td.r-refused {
 tr.failed td, tr.refused td { background:var(--fail-bg); }
 a.frame { display:block; color:var(--muted); font-size:11px; }
 a.frame img { display:block; max-width:220px; max-height:150px; object-fit:cover; object-position:top; border:1px solid var(--line); }
-td.hash, td.path { font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
+td.hash, td.path { font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; overflow-wrap:anywhere; }
+a.frame { overflow-wrap:anywhere; }
 table.sign td.blank { height:2.6em; min-width:8em; }
 .none { color:var(--muted); font-style:italic; }
 @media print { main { max-width:none; padding:0; } a { color:inherit; text-decoration:none; } tbody, tr { break-inside:avoid; } }

package/dist/engine/dispatch.js

@@ -98,3 +98,73 @@ export class SessionQueue {
             this.forget(key);
     }
 }
+/**
+ * The work of every tool call still running, per session.
+ *
+ * The watchdog answers a slow call, but it cannot stop the call: the work goes
+ * on in the background and can still write into the project (its action log,
+ * a frame, a debounced memory save). Left alone, those writes land after
+ * `scout_close` has answered, and after another session has attached to the
+ * same folder. So close waits for them: it closes the browser first, which
+ * makes every page-bound step of the abandoned work fail at once, then waits
+ * here for the work to finish unwinding. The wait is bounded, so work that is
+ * stuck on something other than the browser cannot hold a close forever; the
+ * caller is told how many calls were still running when it gave up.
+ */
+export class CallWork {
+    running = new Map();
+    /** Record `work` as running for `key` until it settles, whether it resolves or rejects. */
+    track(key, work) {
+        let set = this.running.get(key);
+        if (!set) {
+            set = new Set();
+            this.running.set(key, set);
+        }
+        set.add(work);
+        const done = () => {
+            const left = this.running.get(key);
+            if (!left)
+                return;
+            left.delete(work);
+            if (left.size === 0)
+                this.running.delete(key);
+        };
+        // The rejection is the call's own caller's to handle; here it only means "finished".
+        work.then(done, done);
+    }
+    /** Calls still running for `key`. */
+    count(key) {
+        return this.running.get(key)?.size ?? 0;
+    }
+    /** Wait up to `ms` for `key`'s running calls to finish; resolves with how many are still running. */
+    async settle(key, ms) {
+        return this.settleKeys([key], ms);
+    }
+    /** The same for every session (close-all). */
+    async settleAll(ms) {
+        return this.settleKeys([...this.running.keys()], ms);
+    }
+    async settleKeys(keys, ms) {
+        const work = keys.flatMap((k) => [...(this.running.get(k) ?? [])]);
+        if (work.length > 0) {
+            let timer;
+            await Promise.race([Promise.allSettled(work), new Promise((resolve) => (timer = setTimeout(resolve, ms)))]);
+            clearTimeout(timer);
+        }
+        return keys.reduce((n, k) => n + this.count(k), 0);
+    }
+}
+/**
+ * The cap on every tool call's watchdog, from SCENESCOUT_WATCHDOG_MS. Unset
+ * means each tool keeps its own limit. Anything else must be a whole number
+ * of milliseconds of at least 100, or the server refuses to start: a typo
+ * here would otherwise run with limits nobody chose.
+ */
+export function watchdogCap(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return undefined;
+    const ms = Number(raw);
+    if (!Number.isInteger(ms) || ms < 100)
+        throw new Error(`SCENESCOUT_WATCHDOG_MS must be a whole number of milliseconds, at least 100; got "${raw}"`);
+    return ms;
+}

package/dist/engine/memory.js

@@ -1815,6 +1815,18 @@ export class MemoryStore {
         // Deliberately NOT unref'd: a pending coverage write briefly holds the
         // process open so an exit without scout_close still lands the last save.
     }
+    /**
+     * Write now if a debounced save is waiting. A close calls it after the work
+     * it waited for has finished, so a save that work scheduled lands before the
+     * close answers rather than half a second after. Throws as flush() does.
+     */
+    flushPending() {
+        if (!this.saveTimer)
+            return;
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+        this.flush();
+    }
     /** How many states the last open pruned. Reported once, so a shrinking history is never silent. */
     prunedStates = 0;
     /** Set when a debounced background write failed — cleared on the next successful write. Surfaced by scout_coverage/scout_close so a broken persistence path is never silently invisible. */

package/dist/mcp-server.js

@@ -50,7 +50,7 @@ import { DedupJudge, planDedup, samplingAsk } from "./engine/dedup.js";
 import { httpJudgeAsk } from "./ci-run.js";
 import { decodedEntitiesNote, ignoredConventionsNote, LANE_CONVENTION_MAX, LANE_NAME_MAX, LaneLedger, laneCloseGuard, laneReportInstruction, parseLaneReport, summarizeLaneReport, } from "./engine/lane.js";
 import { MAX_UNFILED_NAMED, unfiledDefects } from "./engine/calibration.js";
-import { SessionQueue, withWatchdog } from "./engine/dispatch.js";
+import { CallWork, SessionQueue, watchdogCap, withWatchdog } from "./engine/dispatch.js";
 import { FIXTURE_KINDS } from "./engine/fixtures.js";
 import { feedForSession, LIVE_ENV, writeStatusFile, LIVE_TOKEN_FILE, liveEngines, liveTokenFileName, pidAlive, statusFileName, LiveServer, StatusBoard, } from "./engine/live.js";
 import { liveViewUrl, MCP_APP_MIME, paneData, paneText, STATUS_PANE_URI, STATUS_POLL_TOOL, STATUS_TOOL, } from "./engine/status-pane.js";
@@ -451,6 +451,31 @@ function watchdogTimeout(label, ms) {
  * each other. The queue itself lives in engine/dispatch.ts, where it is tested.
  */
 const sessionQueue = new SessionQueue();
+/** Every call's work until it settles, so a close can wait for what a watchdog let run on (engine/dispatch.ts). */
+const callWork = new CallWork();
+/** How long a close waits for that work once the browser is gone; anything page-bound has failed well before this. */
+const CLOSE_WORK_WAIT_MS = 10_000;
+/**
+ * Write the save that work finishing during a close's wait scheduled. The engine's own close has already flushed;
+ * this catches what came after it. A failure is recorded where the close reports it, as the engine's flush does.
+ */
+function flushAfterClose(eng) {
+    try {
+        eng.memory?.flushPending();
+    }
+    catch (err) {
+        if (eng.memory)
+            eng.memory.lastSaveError = err instanceof Error ? err.message : String(err);
+    }
+}
+/** What a close says when work it waited for was still running at the end of the wait. */
+function stillRunningNote(count) {
+    if (count === 0)
+        return "";
+    return `\n⚠ ${count} tool call${count === 1 ? " was" : "s were"} still running ${CLOSE_WORK_WAIT_MS / 1000} s after the browser closed, so ${count === 1 ? "it" : "they"} may still write into .scenescout/.`;
+}
+/** SCENESCOUT_WATCHDOG_MS caps every tool's watchdog. Read once, at start, and a bad value stops the server here. */
+const WATCHDOG_CAP_MS = watchdogCap(process.env.SCENESCOUT_WATCHDOG_MS);
 function serializedPerSession(label, fn, timeoutMs = 60_000) {
     return (args) => {
         const session = args.session ?? activeName;
@@ -469,10 +494,13 @@ function serializedPerSession(label, fn, timeoutMs = 60_000) {
         const exec = async () => {
             // A session that raised its time limits gets its watchdog raised by as much (limits.ts).
             const current = engines.get(session);
-            const watchdogMs = current ? watchdogFor(timeoutMs, current.timeLimits) : timeoutMs;
+            const raised = current ? watchdogFor(timeoutMs, current.timeLimits) : timeoutMs;
+            const watchdogMs = Math.min(raised, WATCHDOG_CAP_MS ?? raised);
             writeStatus(session, "running", label, watchdogMs);
             try {
-                const out = await withWatchdog(label, fn(args, session), watchdogMs, watchdogTimeout);
+                const work = fn(args, session);
+                callWork.track(session, work);
+                const out = await withWatchdog(label, work, watchdogMs, watchdogTimeout);
                 // `activeName` is process-global and every scout_attach moves it. With
                 // several sessions live — the multi-role runs this tool encourages —
                 // an omitted `session` silently binds to whichever browser attached
@@ -2258,8 +2286,15 @@ server.registerTool("scout_close", {
             for (const name of engines.keys())
                 live?.dropSession(name);
             const stores = new Set([...engines.values()].map((e) => e.memory).filter((m) => m !== null && m !== undefined));
-            await Promise.allSettled([...engines.values()].map((e) => e.close()));
+            const closing = [...engines.values()];
+            await Promise.allSettled(closing.map((e) => e.close()));
+            // Out of the live list before the wait, so a call queued behind abandoned work finds no session instead of
+            // reaching a closed one. Then wait for work a watchdog let run on to unwind, and write what it left pending,
+            // so nothing it writes lands after this answer.
             engines.clear();
+            const stillRunning = await callWork.settleAll(CLOSE_WORK_WAIT_MS);
+            for (const e of closing)
+                flushAfterClose(e);
             for (const store of stores)
                 store.endRun();
             sessionQueue.clear();
@@ -2267,7 +2302,7 @@ server.registerTool("scout_close", {
             laneLedger.clear();
             lastWriter = null;
             await Promise.all([...dirs].map((dir) => settleProjectWrites(dir)));
-            return text(`All sessions closed (${names.join(", ") || "none were live"}). Memory and reports remain in .scenescout/.`, activeName);
+            return text(`All sessions closed (${names.join(", ") || "none were live"}). Memory and reports remain in .scenescout/.` + stillRunningNote(stillRunning), activeName);
         }
         const name = session ?? activeName;
         const eng = engines.get(name);
@@ -2279,8 +2314,11 @@ server.registerTool("scout_close", {
         keepReport(eng);
         live?.dropSession(name);
         await eng.close();
-        const saveError = eng.memory?.lastSaveError;
+        // As above: out of the live list, then wait for work a watchdog let run on and write what it left pending.
         engines.delete(name);
+        const stillRunning = await callWork.settle(name, CLOSE_WORK_WAIT_MS);
+        flushAfterClose(eng);
+        const saveError = eng.memory?.lastSaveError;
         openDecisions.delete(name);
         // The last session on this project ends its run.
         if (eng.memory && ![...engines.values()].some((e) => e.memory === eng.memory))
@@ -2300,6 +2338,7 @@ server.registerTool("scout_close", {
             activeName = engines.keys().next().value ?? "default";
         return text(`Session "${name}" closed. Memory and report remain in .scenescout/.` +
             (engines.size > 0 ? ` Default session → ${activeName}.` : "") +
+            stillRunningNote(stillRunning) +
             (saveError ? `\n⚠ The final memory write failed (${saveError}) — some coverage/findings from this session may not have been persisted to disk.` : ""), activeName);
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenescout",
-  "version": "3.23.0",
+  "version": "3.23.2",
   "description": "SceneScout — exploratory UI testing for AI coding agents. An MCP server that gives any agent (Claude Code, Cursor, VS Code Copilot, Codex, Gemini CLI and others) a structured view of a running web app, always-on oracles, a network-level write policy, memory across runs and a gap-checked report.",
   "license": "MIT",
   "author": "brunoboto96",
@@ -112,7 +112,7 @@
     "dedup-bench": "tsx scripts/dedup-bench.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "playwright": "^1.63.0",
     "zod": "^3.25.0"
   },