scenescout 3.2.0 → 3.4.0

package/dist/engine/claims.js

@@ -0,0 +1,194 @@
+/**
+ * What the page says about itself, checked against what actually happened.
+ *
+ * Two of the most expensive bugs a web app ships are invisible to every oracle
+ * that watches only one side of the wire:
+ *
+ *   - A list request is refused (401, 403, 500) and the page renders its empty
+ *     state. The user is told they have nothing, when the truth is that nothing
+ *     could be loaded. Nobody files a bug, because the screen looks fine — it
+ *     is the single most common way a permission regression reaches production
+ *     without anyone noticing.
+ *   - A save is refused and the page says "Saved". The user walks away
+ *     believing their work is stored.
+ *
+ * Neither is a crash, so `console_error` and `http_error` miss the harm: the
+ * HTTP oracle sees the 403 and reports it as a medium, indistinguishable from
+ * the dozens of expected 401s an auth probe produces. The defect is not the
+ * refusal. It is the page CONTRADICTING the refusal.
+ *
+ * The rules pair a precise half with a fuzzy one. The request half is exact —
+ * a status code either is an error or is not. The page half only has to be
+ * roughly right, because it is never enough on its own: no contradiction is
+ * reported unless a request was genuinely refused during the same action. That
+ * asymmetry is what keeps the false-positive rate low enough to be worth
+ * reporting at high severity.
+ *
+ * Everything here is pure so it can be table-tested; the DOM read lives in
+ * browser.ts.
+ */
+import { VISIBLE_SRC } from "./collector.js";
+/**
+ * Methods whose refusal a success message would be lying about. A refused GET
+ * is the empty-state rule's business; a refused POST is this one's.
+ */
+const WRITING_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+/**
+ * Resource types worth correlating. A failed image, font or analytics beacon
+ * says nothing about whether the list on screen is real, and correlating them
+ * would fire on every page with a broken logo.
+ */
+const DATA_RESOURCES = new Set(["xhr", "fetch", "document"]);
+/** Whether this request is one whose refusal the page should be admitting to. */
+export function isRefused(req) {
+    if (req.blockedByPolicy)
+        return false;
+    if (!DATA_RESOURCES.has(req.resourceType))
+        return false;
+    if (req.status === null)
+        return true;
+    return req.status >= 400;
+}
+/**
+ * Phrases that assert there is nothing to show.
+ *
+ * Deliberately narrow: these are the stock empty-state sentences, not any
+ * sentence containing "no". "No results", "Nothing to show", "You have no
+ * orders" match; "No changes were saved since yesterday" does not, because the
+ * assertion has to be about the absence of the things themselves.
+ */
+const EMPTY_RE = /\b(?:no (?:results?|items?|records?|rows?|data|entries|matches)\b|nothing (?:to (?:show|display)|here|found)\b|(?:there are|you have|we found) no\b|(?:0|zero) (?:results?|items?|records?|rows?|matches)\b|no [a-z]{3,20}s (?:found|yet|to show)\b|empty\b)/i;
+/**
+ * Phrases that assert something worked. A page that says one of these while
+ * the write that produced it was refused is telling the user a falsehood.
+ */
+const SUCCESS_RE = /\b(?:success(?:fully)?|saved|created|updated|deleted|removed|submitted|sent|published|approved|completed|added|changes? saved|done)\b/i;
+/**
+ * Phrases that admit something went wrong. Their presence is what makes a page
+ * INNOCENT: an app that refuses a request and says so has behaved correctly,
+ * whatever else is on the screen, and must not be reported.
+ */
+const ERROR_RE = /\b(?:error|failed|failure|could ?n[o']?t|unable to|went wrong|try again|retry|denied|forbidden|unauthori[sz]ed|not allowed|no permission|timed out|unavailable|problem loading)\b/i;
+/** Longest piece of text judged. An empty state is a sentence; a paragraph that happens to contain one of these words is not a claim. */
+export const CLAIM_TEXT_MAX = 120;
+/**
+ * What one piece of visible page text asserts, or nothing when it asserts none
+ * of these. An admission of error outranks the others: a banner reading
+ * "Couldn't load orders — no results to show" is the app being honest.
+ */
+export function classify(text) {
+    const trimmed = text.trim();
+    if (!trimmed || trimmed.length > CLAIM_TEXT_MAX)
+        return null;
+    if (ERROR_RE.test(trimmed))
+        return "error";
+    if (SUCCESS_RE.test(trimmed))
+        return "success";
+    if (EMPTY_RE.test(trimmed))
+        return "empty";
+    return null;
+}
+function shortUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.pathname + u.search;
+    }
+    catch {
+        return url.slice(0, 120);
+    }
+}
+function say(req) {
+    return `${req.method} ${shortUrl(req.url)} ${req.status === null ? "failed" : req.status}`;
+}
+/**
+ * The contradictions this action produced, if any.
+ *
+ * Both rules are silent whenever the page admits the failure, and both require
+ * a genuinely refused request — the page half never fires alone.
+ */
+export function findContradictions(requests, page) {
+    const refused = requests.filter(isRefused);
+    if (refused.length === 0)
+        return [];
+    const claims = page.texts.map(classify);
+    // An app that says what went wrong has behaved correctly, and nothing below
+    // applies. This is checked before anything else so that a page carrying both
+    // an error banner and a stale empty state is not reported.
+    if (claims.includes("error"))
+        return [];
+    const out = [];
+    const reads = refused.filter((r) => !WRITING_METHODS.has(r.method.toUpperCase()));
+    const saysEmpty = claims.includes("empty") || page.emptyLists > 0;
+    if (reads.length > 0 && saysEmpty) {
+        const worst = reads[0];
+        const how = claims.includes("empty") ? "an empty state" : `an empty list (${page.emptyLists})`;
+        out.push({
+            kind: "refused_empty",
+            detail: `${say(worst)} was refused, and the page shows ${how} with no error. ` +
+                `The user is told there is nothing to see when the truth is that nothing could be loaded.`,
+            evidence: `refused-empty ${say(worst)}`,
+        });
+    }
+    const writes = refused.filter((r) => WRITING_METHODS.has(r.method.toUpperCase()));
+    if (writes.length > 0 && claims.includes("success")) {
+        const worst = writes[0];
+        const message = page.texts[claims.indexOf("success")];
+        out.push({
+            kind: "false_success",
+            detail: `${say(worst)} was refused, and the page says ${JSON.stringify(message.trim().slice(0, 80))}. The user is told their change was kept when the server rejected it.`,
+            evidence: `false-success ${say(worst)}`,
+        });
+    }
+    return out;
+}
+/** Most pieces of text read from one page. A page with more than this has nothing useful to say in the extra ones. */
+export const MAX_CLAIM_TEXTS = 120;
+/**
+ * Page-side reader for the two signals `findContradictions` needs. Shipped as
+ * a STRING expression for the same reason the collector is: loader transforms
+ * inject a `__name` helper that does not exist in the browser, and a
+ * serialized function carrying a call to it fails there.
+ *
+ * Text is taken as each element's OWN text nodes, not its subtree, so a
+ * sentence is read once rather than again for every ancestor that contains it.
+ *
+ * The empty-list count is structural on purpose: most apps write no
+ * empty-state sentence at all, and the ones that do write it in the user's
+ * language. A container that renders its header and no rows says the same
+ * thing in every language and in every design system.
+ */
+export const CLAIM_SCAN_SCRIPT = `(() => {
+  const visible = ${VISIBLE_SRC};
+  const texts = [];
+  const seen = new Set();
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+  let el = document.body;
+  while (el && texts.length < ${MAX_CLAIM_TEXTS}) {
+    let own = "";
+    for (const node of el.childNodes) if (node.nodeType === 3) own += node.nodeValue;
+    own = own.replace(/\\s+/g, " ").trim();
+    if (own && own.length <= ${CLAIM_TEXT_MAX} && !seen.has(own) && visible(el)) {
+      seen.add(own);
+      texts.push(own);
+    }
+    el = walker.nextNode();
+  }
+
+  // A list or table that renders its container but no rows. Hidden ones are
+  // templates and dropdown shells, not empty states.
+  let emptyLists = 0;
+  for (const list of document.querySelectorAll("table, ul, ol, [role='table'], [role='grid'], [role='list']")) {
+    if (!visible(list)) continue;
+    const tag = list.tagName.toLowerCase();
+    if (tag === "table") {
+      const body = list.tBodies[0];
+      // No header means it is a layout table, not a record list.
+      if (!list.querySelector("th, thead")) continue;
+      if (body && body.rows.length === 0) emptyLists += 1;
+      continue;
+    }
+    const rows = list.querySelectorAll(":scope > li, :scope > [role='row'], :scope > [role='listitem']");
+    if (rows.length === 0) emptyLists += 1;
+  }
+  return { texts, emptyLists };
+})()`;

package/dist/engine/lane.js

@@ -138,14 +138,28 @@ export function parseLaneReport(text, expectedLane) {
  */
 export function laneReportInstruction(lane) {
     return [
-        "Reply with ONE JSON object and nothing else — no prose before or after it, no explanation, no headings. A fenced ```json block is fine.",
-        `Shape: {"lane":${JSON.stringify(lane)},"status":<${quoteAll(LANE_STATUSES)}>,"decisions":[…],"routes":[…],"blocked_by":<string or null>}.`,
-        `Each decision: {"observation":<a short id for what was observed, unique in the report, at most ${LANE_OBSERVATION_MAX} characters>,"verdict":<${quoteAll(LANE_VERDICTS)}>,"severity":<${quoteAll(LANE_SEVERITIES)} or null>,"category":<${quoteAll(LANE_CATEGORIES)} or null>,"confidence":<0..1>,"evidence":<machine signature such as "GET /api/things 500", or null>}.`,
-        `A "defect" must carry a severity and a category. "evidence" is a signature, not a sentence: at most ${LANE_EVIDENCE_MAX} characters. "confidence" is how sure you are of the verdict, calibrated: 0.5 means a coin flip, 0.95 means you would bet on it.`,
-        `"routes" lists the routes you covered, each at most ${LANE_ROUTE_MAX} characters. "blocked_by" is one line of at most ${LANE_BLOCKED_BY_MAX} characters saying what stopped you: required when the status is "blocked", allowed with "partial", null with "complete"; the detail belongs in a finding. The lane name is at most ${LANE_NAME_MAX} characters. At most ${LANE_MAX_ITEMS} decisions and ${LANE_MAX_ITEMS} routes. Unknown keys are refused.`,
-        "The object IS your final report: whatever hands it back must hand back the object verbatim, not a summary of it.",
+        ...LANE_RUBRIC,
+        // The ONLY lane-specific sentence, and it comes last on purpose. Every
+        // lane in a wave is given the same rubric, so keeping it byte-identical up
+        // to here makes it one shared prompt prefix: the cache hits from the
+        // second lane onward instead of diverging at the first sentence, which is
+        // what putting the name in the shape line used to do.
+        `Your lane name is ${JSON.stringify(lane)}; put exactly that in "lane".`,
     ].join(" ");
 }
+/**
+ * Everything every lane is told, identical for all of them. Built once from
+ * the same constants the parser enforces, because a limit a lane is not told
+ * refuses good replies.
+ */
+const LANE_RUBRIC = [
+    "Reply with ONE JSON object and nothing else — no prose before or after it, no explanation, no headings. A fenced ```json block is fine.",
+    `Shape: {"lane":<your lane name>,"status":<${quoteAll(LANE_STATUSES)}>,"decisions":[…],"routes":[…],"blocked_by":<string or null>}.`,
+    `Each decision: {"observation":<a short id for what was observed, unique in the report, at most ${LANE_OBSERVATION_MAX} characters>,"verdict":<${quoteAll(LANE_VERDICTS)}>,"severity":<${quoteAll(LANE_SEVERITIES)} or null>,"category":<${quoteAll(LANE_CATEGORIES)} or null>,"confidence":<0..1>,"evidence":<machine signature such as "GET /api/things 500", or null>}.`,
+    `A "defect" must carry a severity and a category. "evidence" is a signature, not a sentence: at most ${LANE_EVIDENCE_MAX} characters. "confidence" is how sure you are of the verdict, calibrated: 0.5 means a coin flip, 0.95 means you would bet on it.`,
+    `"routes" lists the routes you covered, each at most ${LANE_ROUTE_MAX} characters. "blocked_by" is one line of at most ${LANE_BLOCKED_BY_MAX} characters saying what stopped you: required when the status is "blocked", allowed with "partial", null with "complete"; the detail belongs in a finding. The lane name is at most ${LANE_NAME_MAX} characters. At most ${LANE_MAX_ITEMS} decisions and ${LANE_MAX_ITEMS} routes. Unknown keys are refused.`,
+    "The object IS your final report: whatever hands it back must hand back the object verbatim, not a summary of it.",
+];
 function quoteAll(values) {
     return values.map((v) => `"${v}"`).join("|");
 }

package/dist/engine/live-page.js

@@ -58,6 +58,10 @@ export const LIVE_PAGE = `<!doctype html>
     color: #fff; background: var(--accent); border-radius: 6px; }
   main { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 320px), 1fr)); gap: 12px; padding: 16px; }
   .card { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; display: flex; flex-direction: column; }
+  /* Every rule here that sets display beats the browser's own [hidden] rule,
+     so a hidden card stayed on screen with the "nothing matches" notice above
+     it. Say it once, for everything. */
+  [hidden] { display: none !important; }
   .card.stuck { border-color: var(--stuck); }
   .top { display: flex; align-items: center; gap: 8px; padding: 10px 12px 6px; }
   .name { font-weight: 650; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
@@ -118,6 +122,10 @@ export const LIVE_PAGE = `<!doctype html>
   .doing { padding: 0 12px 4px; font-size: 12px; color: var(--text); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .doing::before { content: "▸ "; color: var(--accent); }
   .doing.unset { color: var(--stuck); }
+  .pace { padding: 0 12px 4px; font-size: 11px; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .pace .bad { color: var(--stuck); }
+  header input#filter { font: inherit; font-size: 12px; padding: 4px 8px; border: 1px solid var(--line); border-radius: 6px; background: var(--bg); color: var(--text); min-width: 150px; }
+  #no-match { padding: 16px; color: var(--muted); }
   #focus .feed .a { color: #e6e9ee; }
   #focus .feed .t, #focus .feed .d, #focus .feed .none { color: #98a2b3; }
   #focus .feed .bad { color: #fca5a5; }
@@ -188,12 +196,14 @@ export const LIVE_PAGE = `<!doctype html>
   <span class="spacer"></span>
   <span class="meta" id="counts" data-testid="live-session-counts"></span>
   <span class="actions">
+    <input type="search" id="filter" placeholder="Filter sessions" aria-label="Filter sessions by name, role, objective, task or page" data-testid="live-filter" />
     <button type="button" id="report-open" data-testid="live-report-toggle">Report</button>
     <button type="button" id="all" aria-pressed="false" data-testid="live-all-toggle">Stream all</button>
   </span>
 </header>
 <div id="banner" role="alert" data-testid="live-unreachable-banner">The engine is not answering. It may have exited; this page will pick up again if it comes back.</div>
 <div id="empty" data-testid="live-empty-state">No session is attached yet. Cards appear here as soon as one attaches.</div>
+<div id="no-match" data-testid="live-no-match" hidden></div>
 <div id="finished" data-testid="live-finished-state">
   <h2>The run has finished</h2>
   <p>Its browsers are closed, so there is nothing left to watch. What it found is in the report.</p>
@@ -240,6 +250,8 @@ export const LIVE_PAGE = `<!doctype html>
   var THUMB_EVERY_MS = 3000;
   var cards = {};
   var streamAll = false;
+  /** The header filter, lower-cased. Hides cards; never stops a session running. */
+  var filter = '';
   var focused = null;
   var skew = 0;
   var latest = {};
@@ -364,6 +376,14 @@ export const LIVE_PAGE = `<!doctype html>
     task.setAttribute('data-testid', 'live-card-objective-' + name);
     var doing = el('div', 'doing');
     doing.setAttribute('data-testid', 'live-card-task-' + name);
+    // How long it has been on this task, and how many of its recent steps went
+    // wrong. Both were already in the status payload and reached nobody: the
+    // first only inside the close-up, the second only as a red word in a feed
+    // somebody had to read. On a board of eleven cards, "which one is stuck on
+    // the same thing, and which one is having trouble" is the question being
+    // asked, and it was the one thing the board could not answer.
+    var pace = el('div', 'pace');
+    pace.setAttribute('data-testid', 'live-card-pace-' + name);
     var tool = el('div', 'line');
     var url = el('div', 'line');
     var shot = el('button', 'shot');
@@ -386,9 +406,9 @@ export const LIVE_PAGE = `<!doctype html>
     toggle.setAttribute('data-testid', 'live-card-toggle-' + name);
     var spec = el('span', 'spec');
     foot.appendChild(toggle); foot.appendChild(spec);
-    root.appendChild(top); root.appendChild(task); root.appendChild(doing); root.appendChild(tool); root.appendChild(url); root.appendChild(shot); root.appendChild(feed); root.appendChild(foot);
+    root.appendChild(top); root.appendChild(task); root.appendChild(doing); root.appendChild(pace); root.appendChild(tool); root.appendChild(url); root.appendChild(shot); root.appendChild(feed); root.appendChild(foot);
 
-    var card = { name: name, root: root, role: role, badge: badge, task: task, doing: doing, tool: tool, url: url, shot: shot, img: img, feed: feed, toggle: toggle, spec: spec, live: false };
+    var card = { name: name, root: root, role: role, badge: badge, task: task, doing: doing, pace: pace, tool: tool, url: url, shot: shot, img: img, feed: feed, toggle: toggle, spec: spec, live: false };
     toggle.addEventListener('click', function () { setLive(card, !card.live); });
     shot.addEventListener('click', function () { openFocus(name); });
     img.src = shotUrl(name);
@@ -735,9 +755,31 @@ export const LIVE_PAGE = `<!doctype html>
     card.url.textContent = s.url || '(no page yet)';
     card.url.title = s.url || '';
     card.spec.textContent = [s.mode, s.browser, s.headed ? 'headed' : 'headless'].filter(Boolean).join(' · ');
+    paintPace(card, s);
     renderFeed(card.feed, s.feed);
   }
 
+  /** Steps in the visible feed whose result reads as trouble. */
+  function troubled(feed) {
+    var n = 0;
+    (feed || []).forEach(function (line) { if (BAD_RESULT.test(line.result || '')) n += 1; });
+    return n;
+  }
+
+  function paintPace(card, s) {
+    var on = s.task && s.taskSince ? 'on this for ' + held(Date.now() + skew - Date.parse(s.taskSince)) : '';
+    var bad = troubled(s.feed);
+    card.pace.textContent = '';
+    if (on) card.pace.appendChild(el('span', '', on));
+    if (bad > 0) {
+      if (on) card.pace.appendChild(el('span', '', ' · '));
+      // Only the trouble is red. Reddening the whole line made "on this for
+      // 9s" look like the complaint.
+      card.pace.appendChild(el('span', 'bad', bad + ' of the last ' + s.feed.length + ' steps went wrong'));
+    }
+    card.pace.hidden = !on && bad === 0;
+  }
+
   function openFocus(name) {
     focused = name;
     scrubbed = null;
@@ -827,6 +869,32 @@ export const LIVE_PAGE = `<!doctype html>
     focusTick += 1;
   }
 
+  /**
+   * Whether a session survives the header's filter. Matched against everything
+   * the card already shows, because on a board of eleven the reader is looking
+   * for "the one on the orders register" as often as for a session by name.
+   * Filtering hides cards; it never stops them being polled or streamed, so a
+   * hidden session is still running and still counted in the header.
+   */
+  function matches(s) {
+    if (!filter) return true;
+    var hay = [s.session, s.role, s.objective, s.task, s.url, s.tool].join(' ').toLowerCase();
+    return hay.indexOf(filter) !== -1;
+  }
+
+  function applyFilter() {
+    var shown = 0;
+    Object.keys(cards).forEach(function (name) {
+      var s = latest[name];
+      var keep = !s || matches(s);
+      cards[name].root.hidden = !keep;
+      if (keep) shown += 1;
+    });
+    var none = document.getElementById('no-match');
+    none.hidden = !filter || shown > 0 || Object.keys(cards).length === 0;
+    none.textContent = 'No session matches ' + JSON.stringify(filter) + '.';
+  }
+
   function apply(snap) {
     skew = Date.parse(snap.at) - Date.now();
     var grid = document.getElementById('grid');
@@ -884,6 +952,7 @@ export const LIVE_PAGE = `<!doctype html>
     document.getElementById('engine').textContent = 'engine pid ' + snap.pid + ' · v' + snap.version;
     document.getElementById('counts').textContent = snap.sessions.length + ' session' + (snap.sessions.length === 1 ? '' : 's') +
       ' · ' + counts.running + ' running · ' + counts.idle + ' idle' + (counts.stuck ? ' · ' + counts.stuck + ' stuck' : '');
+    applyFilter();
     paintFocus();
   }
 
@@ -927,7 +996,37 @@ export const LIVE_PAGE = `<!doctype html>
     e.returnValue = '';
   });
   document.getElementById('report-close').addEventListener('click', closeReport);
+  document.getElementById('filter').addEventListener('input', function (e) {
+    filter = String(e.target.value || '').trim().toLowerCase();
+    applyFilter();
+  });
+
+  /**
+   * Step through the timeline from the keyboard.
+   *
+   * Scrubbing a long run by clicking 16px ticks is the kind of thing a mouse
+   * is bad at, and the run being examined is usually the one with hundreds of
+   * steps. Arrow keys move one step, Home and End jump to the ends, and Space
+   * returns to the live picture — only while the close-up is open, and never
+   * while the reader is typing in the filter.
+   */
+  function stepBy(delta) {
+    if (timelineLines.length === 0) return;
+    var at = scrubbed
+      ? timelineLines.findIndex(function (l) { return l.at === scrubbed.at && l.action === scrubbed.action; })
+      : timelineLines.length - 1;
+    var next = Math.max(0, Math.min(timelineLines.length - 1, (at === -1 ? timelineLines.length - 1 : at) + delta));
+    showStep(timelineLines[next]);
+  }
+
   document.addEventListener('keydown', function (e) {
+    if (focused && !reportOpen && e.target !== document.getElementById('filter')) {
+      if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') { e.preventDefault(); stepBy(e.key === 'ArrowLeft' ? -1 : 1); return; }
+      if (e.key === 'Home' || e.key === 'End') { e.preventDefault(); stepBy(e.key === 'Home' ? -1e9 : 1e9); return; }
+      // Back to what the session is showing NOW, which is otherwise a click
+      // on a button the reader has to find.
+      if (e.key === ' ' && scrubbed) { e.preventDefault(); backToLive(); return; }
+    }
     if (e.key !== 'Escape') return;
     if (reportOpen) closeReport();
     else if (focused) closeFocus();

package/dist/engine/live.js

@@ -30,6 +30,10 @@ import { LIVE_PAGE } from "./live-page.js";
 import { JOURNEY_END, JOURNEY_START, TASK_SET } from "./memory.js";
 /** Holds the live view's token, next to status.json. Written owner-only; removed when the engine shuts down. */
 export const LIVE_TOKEN_FILE = "live-token";
+/** This engine's own token file. Shares the directory with other engines, so it carries the pid. */
+export function liveTokenFileName(pid) {
+    return `${LIVE_TOKEN_FILE}.${pid}`;
+}
 /** `SCENESCOUT_LIVE=off` keeps the engine from opening the live view's port at all. */
 export const LIVE_ENV = "SCENESCOUT_LIVE";
 /**
@@ -178,12 +182,68 @@ const statusWrites = new Map();
  * longer one after it (which is what overlapping `writeFile`s produced).
  * Best-effort: a failed write is dropped and the next one lands.
  */
+/**
+ * Whether a process is still there. EPERM means it EXISTS but belongs to
+ * another user; only ESRCH means no such process, and treating both as dead
+ * reported a live engine as stale.
+ */
+export function pidAlive(pid) {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+export function statusFileName(pid) {
+    return `status.${pid}.json`;
+}
+/**
+ * Every engine that has written a status file here, newest first, one entry
+ * per pid. Two engines on one project used to overwrite each other in a single
+ * status.json, so `watch` could only ever find whichever attached last and the
+ * other run was reachable only from the transcript that started it.
+ * status.json is still written for readers from before this, and is used only
+ * when no per-pid file exists.
+ */
+export function liveEngines(dir, isAlive) {
+    let names = [];
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const perPid = names.filter((n) => /^status\.\d+\.json$/.test(n));
+    const out = [];
+    for (const name of perPid.length > 0 ? perPid : names.filter((n) => n === "status.json")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const pid = typeof parsed.pid === "number" ? parsed.pid : NaN;
+        if (!Number.isInteger(pid) || !isAlive(pid))
+            continue;
+        out.push({ pid, status: parsed, file: name });
+    }
+    return out.sort((a, b) => (b.status.at ?? "").localeCompare(a.status.at ?? ""));
+}
 export function writeStatusFile(dir, body) {
     const file = path.join(dir, "status.json");
     const tmp = `${file}.${process.pid}.tmp`;
+    // Both: status.json for readers from before per-pid files, and one named for
+    // this process so a second engine on the same project does not erase it.
+    const mine = path.join(dir, statusFileName(process.pid));
     const next = (statusWrites.get(dir) ?? Promise.resolve())
         .then(() => fs.promises.writeFile(tmp, body))
         .then(() => fs.promises.rename(tmp, file))
+        .then(() => fs.promises.writeFile(mine, body))
         .catch(() => fs.promises.rm(tmp, { force: true }).catch(() => { }));
     statusWrites.set(dir, next);
     return next;