scenescout 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # scenescout
 
+## 3.6.0
+
+### Minor Changes
+
+- 6fbd659: The pace section now separates a lane's working time from the time it holds its browser after finishing. "Idle while working" is the share of each lane's working time spent in gaps over 30 seconds; "after finishing" is time waiting to be collected and closed, split at the moment the lane's report was folded. The latter grows with the number of lanes and the slowest one, so it is reported as planner overhead rather than summed into the lanes' idle time. `scout_lane_report` now logs the fold so the split can be made.
+
 ## 3.5.0
 
 ### Minor Changes

package/README.md

@@ -335,7 +335,7 @@ A `🛡 WRITE-POLICY blocked` notice is the safety net doing its job, not an app
 - 💯 **Page scores** (0–100: a11y · craft · consistency · task-clarity), ranked worst-first, with stale scores from old runs marked as such.
 - 👥 **A role capability matrix** — what each role could and couldn't reach.
 - 🧾 **A gap ledger** — everything *not* done, so the report is honest about its own coverage.
-- ⏱️ **How the run was paced** — actions, median gap, idle share and held-idle time per session, so a browser held open for nothing is visible.
+- ⏱️ **How the run was paced** — how closely each session kept working, and apart from that, how long finished lanes held their browsers waiting to be collected, so neither hides the other.
 - 🎯 **How well the lanes judged** — on a parallel run, whether the confidence each lane stated matched what the project went on to file, beside what later re-tests found ([ADR 10](docs/adr/0010-a-confidence-is-checked-not-trusted.md)).
 
 `.scenescout/report.html` — the same report as one self-contained page, with every session's trail beside it, and on a [recorded run](#-recording-a-run-and-reading-it-back) the screenshots under each finding.

package/dist/engine/memory.js

@@ -1212,7 +1212,10 @@ export class MemoryStore {
                 return url;
             }
         };
-        const log = this.actionLog;
+        // The planner's fold marker is not a step anyone took on a page. Left in,
+        // its empty URL read as a route change and cut the trace of a finding filed
+        // right after a fold — which is when the fold asks lanes to file.
+        const log = this.actionLog.filter((a) => a.action !== "lane-report");
         let start = Math.max(0, log.length - 12);
         for (let i = log.length - 1; i >= 0 && i >= log.length - 12; i--) {
             if (routeOf(log[i].url) !== routeOf(f.url)) {

package/dist/engine/pace.js

@@ -4,7 +4,7 @@
  * counting them inflates the action count and drags the median gap toward
  * zero. One real run logged 325 entries of which 107 were stated tasks.
  */
-const MARKER_ACTIONS = new Set(["task", "attach", "close", "created-resource", "journey:start", "journey:end", "record:full", "record:failed"]);
+const MARKER_ACTIONS = new Set(["task", "attach", "close", "lane-report", "created-resource", "journey:start", "journey:end", "record:full", "record:failed"]);
 /** Whether a log entry represents work the browser actually did. */
 export function isActing(action) {
     return !MARKER_ACTIONS.has(action);
@@ -30,7 +30,11 @@ export function measurePace(log, nowMs, attached = []) {
     const lifecycle = new Map();
     for (const entry of log) {
         const name = entry.session ?? "default";
-        const into = isActing(entry.action) ? bySession : entry.action === "attach" || entry.action === "close" ? lifecycle : null;
+        const into = isActing(entry.action)
+            ? bySession
+            : entry.action === "attach" || entry.action === "close" || entry.action === "lane-report"
+                ? lifecycle
+                : null;
         if (!into)
             continue;
         const list = into.get(name);
@@ -51,10 +55,10 @@ export function measurePace(log, nowMs, attached = []) {
             .map((e) => Date.parse(e.at))
             .filter((t) => Number.isFinite(t))
             .sort((a, b) => a - b);
-        const heldIdleMs = heldIdle(lifecycle.get(session) ?? [], times, nowMs, stillOpen.has(session));
+        const edge = edges(lifecycle.get(session) ?? [], times, nowMs, stillOpen.has(session));
         if (times.length === 0) {
-            if (heldIdleMs > 0) {
-                sessions.push({ session, actions: 0, spanMs: 0, medianGapMs: 0, maxGapMs: 0, idleShare: 0, quietMs: 0, framed: 0, heldIdleMs });
+            if (edge.leadInMs > 0) {
+                sessions.push({ session, actions: 0, spanMs: 0, medianGapMs: 0, maxGapMs: 0, idleShare: 0, quietMs: 0, framed: 0, ...edge });
             }
             continue;
         }
@@ -75,11 +79,20 @@ export function measurePace(log, nowMs, attached = []) {
             idleShare: spanMs > 0 ? idleMs / spanMs : 0,
             quietMs: Math.max(0, nowMs - times[times.length - 1]),
             framed: entries.filter((e) => e.frame).length,
-            heldIdleMs,
+            ...edge,
         });
     }
     sessions.sort((a, b) => b.actions - a.actions);
+    const folds = sessions.filter((s) => s.afterFoldMs !== null);
+    const waiting = {
+        workingMs: sessions.reduce((sum, s) => sum + s.spanMs, 0),
+        workingIdleMs: sessions.reduce((sum, s) => sum + s.idleShare * s.spanMs, 0),
+        leadInMs: sessions.reduce((sum, s) => sum + s.leadInMs, 0),
+        afterFinishMs: sessions.reduce((sum, s) => sum + s.afterFinishMs, 0),
+        afterFoldMs: folds.length > 0 ? folds.reduce((sum, s) => sum + (s.afterFoldMs ?? 0), 0) : null,
+    };
     return {
+        waiting,
         sessions,
         spanMs: sessions.length > 0 ? last - first : 0,
         actions: sessions.reduce((sum, x) => sum + x.actions, 0),
@@ -91,18 +104,22 @@ export function measurePace(log, nowMs, attached = []) {
     };
 }
 /**
- * Idle time at the edges of each attach: attach to first action, last action
- * to close. An attach with no close after it ends at the next attach, or at
- * now while the session is still open. A log written before close was
- * recorded has no close marker; its closed sessions count no trailing idle,
- * because when they closed is unknown.
+ * Time at the edges of each attach: attach to first action (lead-in), and last
+ * action to close (after finishing). An attach with no close after it ends at
+ * the next attach, or at now while the session is still open. A log written
+ * before close was recorded has no close marker; its closed sessions count no
+ * trailing time, because when they closed is unknown. A fold marker after the
+ * last action splits the trailing time at the moment the browser stopped being
+ * needed.
  */
-function heldIdle(markers, actionTimes, nowMs, stillOpen) {
+function edges(markers, actionTimes, nowMs, stillOpen) {
     const events = markers
         .map((m) => ({ kind: m.action, at: Date.parse(m.at) }))
         .filter((e) => Number.isFinite(e.at))
         .sort((a, b) => a.at - b.at);
-    let idle = 0;
+    let leadInMs = 0;
+    let afterFinishMs = 0;
+    let afterFoldMs = null;
     for (let i = 0; i < events.length; i += 1) {
         if (events[i].kind !== "attach")
             continue;
@@ -112,14 +129,19 @@ function heldIdle(markers, actionTimes, nowMs, stillOpen) {
         const inside = actionTimes.filter((t) => t >= start && (end === null || t <= end));
         if (inside.length === 0) {
             if (end !== null)
-                idle += end - start;
+                leadInMs += end - start;
             continue;
         }
-        idle += inside[0] - start;
-        if (end !== null)
-            idle += end - inside[inside.length - 1];
+        leadInMs += inside[0] - start;
+        if (end === null)
+            continue;
+        const lastAction = inside[inside.length - 1];
+        afterFinishMs += end - lastAction;
+        const fold = events.filter((e) => e.kind === "lane-report" && e.at >= lastAction && e.at <= end).at(-1);
+        if (fold)
+            afterFoldMs = (afterFoldMs ?? 0) + (end - fold.at);
     }
-    return Math.max(0, idle);
+    return { leadInMs: Math.max(0, leadInMs), afterFinishMs: Math.max(0, afterFinishMs), afterFoldMs };
 }
 /** Milliseconds as a person says them: 45s, 4m12s, 1h03m. */
 export function sayDuration(ms) {
@@ -139,16 +161,28 @@ export function sayDuration(ms) {
 export function formatPace(pace) {
     if (pace.sessions.length === 0)
         return [];
+    const w = pace.waiting;
+    const pct = (part, whole) => (whole > 0 ? `${Math.round((part / whole) * 100)}%` : "0%");
     const lines = [
         `## How the run was paced`,
         ``,
-        `${pace.actions} action(s) over ${sayDuration(pace.spanMs)}. Stated tasks and attaches are not counted: they take no time. Idle share is time the browser stood still waiting for the agent, not time the engine spent working. Held idle is time a browser was open before a session's first action or after its last one — a lane waiting to be folded, or attached and never used.`,
+        `${pace.actions} action(s) over ${sayDuration(pace.spanMs)}. Stated tasks and attaches are not counted: they take no time.`,
+        ``,
+        `**While working** — first action to last, ${sayDuration(w.workingMs)} across sessions — ${pct(w.workingIdleMs, w.workingMs)} was spent in gaps over ${sayDuration(IDLE_GAP_MS)}, the agent thinking at length. That is how closely the sessions kept working.`,
+        ``,
+        `**After finishing**, sessions held their browsers for a further ${sayDuration(w.afterFinishMs)}` +
+            (w.afterFoldMs !== null ? `, ${sayDuration(w.afterFoldMs)} of it after their report was already folded` : ``) +
+            (w.afterFoldMs !== null
+                ? `. That is time waiting to be collected and closed: it grows with the number of lanes and with the slowest one, not with how well any lane worked. Closing each lane as soon as its report is folded removes it.`
+                : `: time from the last action to close.`) +
+            ` (Before the first action: ${sayDuration(w.leadInMs)}.)`,
         ``,
-        `| Session | Actions | Span | Median gap | Longest gap | Idle | Held idle | Frames |`,
+        `| Session | Actions | Working | Median gap | Longest gap | Idle while working | After finishing | Frames |`,
         `|---|---:|---:|---:|---:|---:|---:|---:|`,
     ];
     for (const s of pace.sessions) {
-        lines.push(`| ${s.session} | ${s.actions} | ${sayDuration(s.spanMs)} | ${sayDuration(s.medianGapMs)} | ${sayDuration(s.maxGapMs)} | ${Math.round(s.idleShare * 100)}% | ${sayDuration(s.heldIdleMs)} | ${s.framed} |`);
+        const after = sayDuration(s.afterFinishMs) + (s.afterFoldMs !== null ? ` (${sayDuration(s.afterFoldMs)} after fold)` : ``);
+        lines.push(`| ${s.session} | ${s.actions} | ${sayDuration(s.spanMs)} | ${sayDuration(s.medianGapMs)} | ${sayDuration(s.maxGapMs)} | ${Math.round(s.idleShare * 100)}% | ${after} | ${s.framed} |`);
     }
     lines.push(``);
     if (pace.quiet.length > 0) {

package/dist/mcp-server.js

@@ -546,6 +546,9 @@ server.registerTool("scout_lane_report", {
         // already closed makes that the ordinary case, not an edge one.
         const owner = engines.get(lane)?.memory;
         const at = new Date().toISOString();
+        // Marks the moment the lane's browser stopped being needed, so the pace
+        // section can tell a lane still reporting from one waiting to be closed.
+        owner?.logAction({ action: "lane-report", url: engines.get(lane)?.currentUrl ?? "", session: lane });
         const kept = owner
             ? owner.addLaneDecisions(lane, parsed.report.decisions.map((d) => ({ ...d, lane, at })))
             : 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenescout",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "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",