claude-code-session-manager 0.35.16 → 0.35.17

package/src/main/__tests__/runVerify.test.cjs

@@ -973,3 +973,149 @@ test('halt result + sentinel PASS + committedDuringRun:true → still halt', asy
     rmdir(tmp);
   }
 });
+
+// ─── -merge-main postcondition exemption tests (2026-07-18 feedback) ──────────
+
+const { isMergeMainSlug, extractMergeMainPrNumber } = require('../runVerify.cjs');
+
+test('isMergeMainSlug matches the NN-prXXX-merge-main and NN-fix-prXXX-merge-main conventions', () => {
+  assert.equal(isMergeMainSlug('565-pr188-merge-main'), true);
+  assert.equal(isMergeMainSlug('571-fix-pr141-merge-main'), true);
+  assert.equal(isMergeMainSlug('523-fix-bounded-fix-plan-retry'), false);
+  assert.equal(isMergeMainSlug('406-browser-capture-panel-ui'), false);
+  assert.equal(isMergeMainSlug(''), false);
+  assert.equal(isMergeMainSlug(undefined), false);
+});
+
+test('extractMergeMainPrNumber prefers "PR #<n>" in text, falls back to slug', () => {
+  assert.equal(extractMergeMainPrNumber('565-pr188-merge-main', 'title: Merge current main into sigma PR #188 (round 2)'), 188);
+  assert.equal(extractMergeMainPrNumber('565-pr188-merge-main', 'no pr mention here'), 188);
+  assert.equal(extractMergeMainPrNumber('non-standard-slug', 'no pr mention here'), null);
+});
+
+// (1) -merge-main + PASS + no commit + gh reports MERGEABLE/non-CONFLICTING → verified, no issue
+test('merge-main exemption: gh reports MERGEABLE → pass_no_commit_target_verified, no issue pushed', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '565-pr188-merge-main';
+    writeLog(tmp, slug, noOpRunEvents('PR #188 was already merged into main by another actor.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Merge current main into sigma PR #188');
+    let ghCalls = 0;
+    const ghExecImpl = (cmd, args, opts) => {
+      ghCalls++;
+      assert.equal(cmd, 'gh');
+      assert.deepEqual(args, ['pr', 'view', '188', '--json', 'mergeable,mergeStateStatus']);
+      assert.equal(opts.cwd, '/tmp/sigma');
+      return JSON.stringify({ mergeable: 'MERGEABLE', mergeStateStatus: 'BEHIND' });
+    };
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: '/tmp/sigma' },
+      allJobs: [],
+      committedDuringRun: false,
+      ghExecImpl,
+    });
+    assert.equal(ghCalls, 1);
+    assert.equal(verdict.verdict, 'pass_no_commit_target_verified', `expected verified verdict, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+    assert.equal(verdict.verifiedPrNumber, 188);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// (2) -merge-main + PASS + no commit + gh reports CONFLICTING → falls through to pass_no_commit
+test('merge-main exemption: gh reports CONFLICTING → falls through to pass_no_commit', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '565-pr188-merge-main';
+    writeLog(tmp, slug, noOpRunEvents('PR #188 needs no further work.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Merge current main into sigma PR #188');
+    const ghExecImpl = () => JSON.stringify({ mergeable: 'MERGEABLE', mergeStateStatus: 'CONFLICTING' });
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: '/tmp/sigma' },
+      allJobs: [],
+      committedDuringRun: false,
+      ghExecImpl,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected fallback to pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// (3) -merge-main + PASS + no commit + gh call fails/times out → falls through to pass_no_commit, never throws
+test('merge-main exemption: gh call throws → falls through to pass_no_commit, never throws', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '565-pr188-merge-main';
+    writeLog(tmp, slug, noOpRunEvents('PR #188 needs no further work.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Merge current main into sigma PR #188');
+    const ghExecImpl = () => { throw new Error('gh: command not found'); };
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: '/tmp/sigma' },
+      allJobs: [],
+      committedDuringRun: false,
+      ghExecImpl,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected fallback to pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// (4) non-merge-main slug, PASS + no commit → unchanged pass_no_commit behavior, zero gh invocations
+test('merge-main exemption: non-merge-main slug never attempts a gh call', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '406-browser-capture-panel-ui';
+    writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
+    let ghCalls = 0;
+    const ghExecImpl = () => { ghCalls++; return JSON.stringify({ mergeable: 'MERGEABLE', mergeStateStatus: 'CLEAN' }); };
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: '/tmp/proj' },
+      allJobs: [],
+      committedDuringRun: false,
+      ghExecImpl,
+    });
+    assert.equal(ghCalls, 0, 'gh must never be invoked for a non-merge-main slug');
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected unchanged pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// (5) -merge-main slug but a real commit DID land → unaffected, path unreachable, zero gh invocations
+test('merge-main exemption: commit landed → path unreachable, zero gh invocations, verdict clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '565-pr188-merge-main';
+    writeLog(tmp, slug, noOpRunEvents('Merged and pushed.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Merge current main into sigma PR #188');
+    let ghCalls = 0;
+    const ghExecImpl = () => { ghCalls++; return JSON.stringify({ mergeable: 'MERGEABLE', mergeStateStatus: 'CLEAN' }); };
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: '/tmp/sigma' },
+      allJobs: [],
+      committedDuringRun: true,
+      ghExecImpl,
+    });
+    assert.equal(ghCalls, 0, 'gh must never be invoked when a commit already landed');
+    assert.equal(verdict.verdict, 'clean', `expected clean (commit landed, sentinel PASS), got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});

package/src/main/__tests__/scheduler-committed-in-window.test.cjs

@@ -1,11 +1,13 @@
 /**
  * scheduler-committed-in-window.test.cjs — unit tests for committedInWindow.
  *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-committed-in-window.test.cjs
+ * Run: timeout 120 node --test src/main/__tests__/scheduler-committed-in-window.test.cjs
  */
 
 'use strict';
 
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -42,7 +44,7 @@ test('committedInWindow returns true for a commit landed on a non-checked-out br
     git(dir, ['checkout', '-q', '-b', 'other-branch-at-exit']);
 
     const result = await committedInWindow(dir, startedAt, finishedAt);
-    expect(result).toBe(true);
+    assert.strictEqual(result, true);
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }
@@ -55,7 +57,7 @@ test('committedInWindow returns false when the window covers no commit', async (
     const farFutureEnd = new Date(Date.now() + 366 * 24 * 60 * 60 * 1000).toISOString();
 
     const result = await committedInWindow(dir, farFutureStart, farFutureEnd);
-    expect(result).toBe(false);
+    assert.strictEqual(result, false);
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }

package/src/main/__tests__/scheduler-tick-cancel-token.test.cjs

@@ -0,0 +1,54 @@
+/**
+ * scheduler-tick-cancel-token.test.cjs — regression test for the 2026-07-14
+ * scheduler stall (PRD 543/544): the tick loop stopped picking up pending
+ * jobs after a job's run paused the queue (e.g. a rate limit), because the
+ * pause's cancelToken.cancelled flag was only ever reset inside
+ * runDueJobs() — clearPause() (used by the poll-loop's auth/network
+ * auto-recovery and the manual "Resume" button) never reset it, so every
+ * subsequent tickQueue() call short-circuited on the stale flag forever,
+ * even though queue.json's `paused` field was correctly null.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/scheduler-tick-cancel-token.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { applyPauseCleared, pickNextBatch } = require('../scheduler.cjs');
+
+test('clearPause un-cancels the tick guard so the next pending job still starts', () => {
+  // A job's run pauses the queue (e.g. rate limit) — setPaused() cancels the
+  // in-flight tick batch.
+  const cancelToken = { cancelled: true };
+
+  // The pause is cleared via a recovery path OTHER than runDueJobs() (the
+  // poll-loop's auth/network auto-recovery, or the manual "Resume" button —
+  // both call clearPause() directly). Before the fix, this left
+  // cancelToken.cancelled stuck at true forever.
+  applyPauseCleared(true, cancelToken);
+
+  assert.strictEqual(
+    cancelToken.cancelled,
+    false,
+    'clearPause must un-cancel the tick guard, or every future tick short-circuits forever even though paused=null',
+  );
+
+  // With the guard cleared, the next tick's batch-picking proceeds normally
+  // and starts the next pending job after the failed one.
+  const jobs = [
+    { slug: '543-chat-mode-data-table-rendering', status: 'failed', cwd: '/proj' },
+    { slug: '544-committed-in-window-test-runner-consistency', status: 'pending', cwd: '/proj' },
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 3);
+  assert.strictEqual(batch.length, 1);
+  assert.strictEqual(batch[0].slug, '544-committed-in-window-test-runner-consistency');
+});
+
+test('applyPauseCleared is a no-op when the queue was not actually paused', () => {
+  const cancelToken = { cancelled: false };
+  applyPauseCleared(false, cancelToken);
+  assert.strictEqual(cancelToken.cancelled, false);
+});
+
+console.log('scheduler-tick-cancel-token tests: PASS');

package/src/main/__tests__/scheduler-transient-failure.test.cjs

@@ -0,0 +1,141 @@
+/**
+ * scheduler-transient-failure.test.cjs — classifying network-outage vs. real
+ * code failures so a transient outage (PRD 543/545: ENOTFOUND) gets a bounded
+ * requeue instead of burning a whole run + an auto-fix investigation on an
+ * outage that has nothing to do with the code.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/scheduler-transient-failure.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  detectNetworkErrorInLog,
+  detectRateLimitInLog,
+  classifyFailureOutcome,
+  TRANSIENT_RETRY_CAP,
+} = require('../scheduler.cjs');
+
+// Real tail captured from the 543 incident run (2026-07-14T14-40-39-306Z),
+// per the PRD's "reuse it, don't re-derive" instruction.
+const NETWORK_OUTAGE_LOG_TAIL = String.raw`
+{"type":"result","subtype":"success","is_error":true,"api_error_status":null,"duration_ms":592749,"duration_api_ms":83313,"num_turns":19,"result":"API Error: Unable to connect to API (ENOTFOUND)","stop_reason":"stop_sequence","session_id":"85b1a3f4-3625-4f2d-a9f0-b3994f062b39","total_cost_usd":0.75,"terminal_reason":"api_error","uuid":"cc041889-4497-4fca-9f83-73e3dae6de54"}
+`;
+
+const RATE_LIMIT_LOG_TAIL = String.raw`
+{"type":"result","subtype":"error","is_error":true,"api_error_status":429,"rateLimitType":"five_hour","result":"You've hit your limit","uuid":"abc"}
+`;
+
+const REAL_CODE_FAILURE_LOG_TAIL = String.raw`
+{"type":"result","subtype":"error","is_error":true,"result":"Error: expected 2 but got 3\n  at test/foo.test.ts:12:5","terminal_reason":"error_max_turns","uuid":"def"}
+`;
+
+function writeTmpLog(contents) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transient-log-'));
+  const p = path.join(dir, 'run.log');
+  fs.writeFileSync(p, contents);
+  return p;
+}
+
+test('detectNetworkErrorInLog fires only on terminal_reason:api_error + a network-class error', () => {
+  const p = writeTmpLog(NETWORK_OUTAGE_LOG_TAIL);
+  try {
+    assert.strictEqual(detectNetworkErrorInLog(p), true);
+  } finally {
+    fs.rmSync(path.dirname(p), { recursive: true, force: true });
+  }
+});
+
+test('detectNetworkErrorInLog does not fire on a genuine code failure (no terminal_reason:api_error)', () => {
+  const p = writeTmpLog(REAL_CODE_FAILURE_LOG_TAIL);
+  try {
+    assert.strictEqual(detectNetworkErrorInLog(p), false);
+  } finally {
+    fs.rmSync(path.dirname(p), { recursive: true, force: true });
+  }
+});
+
+test('detectNetworkErrorInLog does not fire on a rate-limit log (rateLimited handling stays separate)', () => {
+  const p = writeTmpLog(RATE_LIMIT_LOG_TAIL);
+  try {
+    assert.strictEqual(detectNetworkErrorInLog(p), false);
+    // And the reverse: the rate-limit detector doesn't fire on the network log.
+    assert.strictEqual(detectRateLimitInLog(p), true);
+  } finally {
+    fs.rmSync(path.dirname(p), { recursive: true, force: true });
+  }
+});
+
+test('detectRateLimitInLog does not fire on a network-outage log', () => {
+  const p = writeTmpLog(NETWORK_OUTAGE_LOG_TAIL);
+  try {
+    assert.strictEqual(detectRateLimitInLog(p), false);
+  } finally {
+    fs.rmSync(path.dirname(p), { recursive: true, force: true });
+  }
+});
+
+test('classifyFailureOutcome: ENOTFOUND-class network error with a clean tree retries (bounded)', () => {
+  const decision = classifyFailureOutcome({
+    exitCode: 1,
+    networkError: true,
+    durationMs: 594_000,
+    transientRetries: 0,
+    newlyDirtyCount: 0,
+  });
+  assert.strictEqual(decision.action, 'retry');
+  assert.strictEqual(decision.transientKind, 'network');
+  assert.strictEqual(decision.retries, 0);
+});
+
+test('classifyFailureOutcome: network error with uncommitted work left behind refuses to requeue', () => {
+  const decision = classifyFailureOutcome({
+    exitCode: 1,
+    networkError: true,
+    durationMs: 594_000,
+    transientRetries: 0,
+    newlyDirtyCount: 2,
+  });
+  assert.strictEqual(decision.action, 'fail-dirty');
+  assert.strictEqual(decision.newlyDirtyCount, 2);
+});
+
+test('classifyFailureOutcome: retry cap exhausted fails without auto-fix, never loops unboundedly', () => {
+  const decision = classifyFailureOutcome({
+    exitCode: 1,
+    networkError: true,
+    durationMs: 594_000,
+    transientRetries: TRANSIENT_RETRY_CAP,
+    newlyDirtyCount: 0,
+  });
+  assert.strictEqual(decision.action, 'fail-cap');
+  assert.strictEqual(decision.retries, TRANSIENT_RETRY_CAP);
+});
+
+test('classifyFailureOutcome: a genuine code failure (non-network exit 1) is still terminal + investigated', () => {
+  const decision = classifyFailureOutcome({
+    exitCode: 1,
+    networkError: false,
+    durationMs: 30_000,
+    transientRetries: 0,
+    newlyDirtyCount: 0,
+  });
+  assert.strictEqual(decision.action, 'investigate');
+});
+
+test('classifyFailureOutcome: signal-kill transient (exit 143, short run) still retries as before', () => {
+  const decision = classifyFailureOutcome({
+    exitCode: 143,
+    networkError: false,
+    durationMs: 60_000,
+    transientRetries: 0,
+    newlyDirtyCount: 0,
+  });
+  assert.strictEqual(decision.action, 'retry');
+  assert.strictEqual(decision.transientKind, 'exit=143');
+});

package/src/main/adminServer.cjs

@@ -14,8 +14,17 @@
  *     ~/.claude/session-manager/admin-api.json with 0600 perms.
  *   - Token compared with crypto.timingSafeEqual to avoid a timing
  *     side-channel on the comparison itself.
- *   - Only two routes: reset-job (one narrow mutation) and jobs (read-only
- *     list). writePrd/pause/resume are intentionally NOT exposed here.
+ *   - Three routes: reset-job (flips fields on an already-vetted job),
+ *     jobs (read-only list), and create-prd (PRD 549 — authors a BRAND-NEW
+ *     file that the scheduler will later run as `claude -p
+ *     --dangerously-skip-permissions` in a caller-chosen, home-dir-bounded
+ *     cwd; a materially larger blast radius than reset-job, justified only
+ *     because it unblocks external automation with no other queueing path).
+ *     cwd is validated via config.cjs's validatePath; title/cwd are
+ *     newline-blocked at the zod boundary (ipcSchemas.cjs) to prevent
+ *     frontmatter injection into the hand-rolled PRD serializer
+ *     (prdCreate.cjs). pause/resume/cancel/update remain intentionally NOT
+ *     exposed here.
  */
 
 'use strict';
@@ -26,6 +35,9 @@ const path = require('node:path');
 const crypto = require('node:crypto');
 const fsp = require('node:fs/promises');
 const config = require('./config.cjs');
+const { expandHome } = require('./lib/expandHome.cjs');
+const { schemas } = require('./ipcSchemas.cjs');
+const prdCreate = require('./lib/prdCreate.cjs');
 
 const TOKEN_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'admin-api.json');
 
@@ -123,6 +135,79 @@ function createAdminServer(remote) {
         sendJson(res, 200, result);
         return;
       }
+      if (req.method === 'POST' && req.url === '/admin/scheduler/create-prd') {
+        const raw = await readBody(req);
+        let parsed;
+        try {
+          parsed = raw ? JSON.parse(raw) : {};
+        } catch {
+          sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+          return;
+        }
+
+        let input;
+        try {
+          input = schemas.schedulerCreatePrd.parse(parsed);
+        } catch (e) {
+          sendJson(res, 400, { ok: false, error: 'invalid PRD payload', details: e?.issues ?? e?.message });
+          return;
+        }
+
+        // cwd is untrusted: this is the first *creating* mutation on a
+        // token-authed API whose product is "a command that will later run
+        // with --dangerously-skip-permissions in a chosen cwd". Route it
+        // through config.cjs's validatePath (allowedRoots = home dir) —
+        // same boundary every other fs-touching IPC handler uses — never a
+        // bespoke check here.
+        try {
+          config.validatePath(expandHome(input.cwd));
+        } catch (e) {
+          sendJson(res, 400, { ok: false, error: `cwd rejected: ${e?.message ?? 'outside allowed roots'}` });
+          return;
+        }
+
+        const slug = input.slug || prdCreate.deriveSlugFromTitle(input.title);
+        if (!slug || !prdCreate.PRD_CREATE_SLUG_RE.test(slug)) {
+          sendJson(res, 400, { ok: false, error: 'could not derive a valid kebab-case slug from title; supply "slug" explicitly' });
+          return;
+        }
+
+        // NN allocation is delegated to allocateParallelGroup() (PRD 548) via
+        // the injected remote — never re-derived here — unless the caller
+        // opted into an existing group explicitly.
+        const nn = input.parallelGroup ?? await remote.allocateParallelGroup();
+        const filenameSlug = `${nn}-${slug}`;
+
+        // An explicit `parallelGroup` bypasses allocateParallelGroup()'s
+        // collision-proof reservation, so re-check for an existing file at
+        // this exact destination before writing — remote.writePrd itself has
+        // no existence guard (by design, it doubles as the edit-in-place
+        // path for Scheduler UI PRD edits), so "create" must not silently
+        // clobber an existing job's PRD.
+        const existing = await remote.readPrd(filenameSlug);
+        if (existing?.ok) {
+          sendJson(res, 409, { ok: false, error: `PRD already exists: ${filenameSlug}.md` });
+          return;
+        }
+
+        let standardsText;
+        try {
+          standardsText = await prdCreate.readStandards();
+        } catch (e) {
+          sendJson(res, 500, { ok: false, error: `could not read engineering standards: ${e?.message}` });
+          return;
+        }
+
+        const body = prdCreate.buildPrdBody(input, standardsText);
+        const writeResult = await remote.writePrd(filenameSlug, body);
+        if (!writeResult?.ok) {
+          sendJson(res, 500, { ok: false, error: writeResult?.error ?? 'write failed' });
+          return;
+        }
+
+        sendJson(res, 200, { nn, filename: `${filenameSlug}.md`, status: 'queued' });
+        return;
+      }
       sendJson(res, 404, { ok: false, error: 'not found' });
     } catch (e) {
       sendJson(res, 500, { ok: false, error: e?.message ?? 'internal error' });

package/src/main/browserCapture.cjs

@@ -656,14 +656,21 @@ async function captureSelection({ viewId, selectors, mode }, getView) {
   }
 
   if (mode === 'a11y') {
-    const selector = selectors[0];
-    const tree = await captureA11y(wc, selector);
-    const text = tree ? formatA11yTree(tree) : '';
+    // captureA11y attaches/detaches the CDP debugger per call, so loop
+    // sequentially rather than firing selectors in parallel (mirrors the
+    // multi-select behavior of the html/selector modes above, which apply to
+    // the whole `selectors` array instead of only the first entry).
+    const trees = [];
+    for (const selector of selectors) {
+      const tree = await captureA11y(wc, selector);
+      if (tree) trees.push(tree);
+    }
+    const text = trees.map((t) => formatA11yTree(t)).join('\n\n');
     return { ok: true, mode, text, meta: {} };
   }
 
   // mode === 'agent'
-  const rawTree = await wc.executeJavaScript(
+  const rawTrees = await wc.executeJavaScript(
     `(function () {
       function serialize(el) {
         if (el.nodeType === 3) {
@@ -683,11 +690,18 @@ async function captureSelection({ viewId, selectors, mode }, getView) {
         }
         return { tag: el.tagName.toLowerCase(), attrs: attrs, style: { display: cs.display, visibility: cs.visibility }, children: children };
       }
-      var el = document.querySelector(${JSON.stringify(selectors[0])});
-      return el ? serialize(el) : null;
+      return (${JSON.stringify(selectors)}).map(function (sel) {
+        var el = document.querySelector(sel);
+        return el ? serialize(el) : null;
+      }).filter(Boolean);
     })()`,
   );
-  const { text, meta } = buildAgentCapture(capRawTree(rawTree));
+  const parts = (Array.isArray(rawTrees) ? rawTrees : []).map((t) => buildAgentCapture(capRawTree(t)));
+  const text = parts.map((p) => p.text).join('\n\n');
+  const meta = {
+    chunks: parts.reduce((a, p) => a + (p.meta.chunks || 0), 0),
+    tokens: parts.reduce((a, p) => a + (p.meta.tokens || 0), 0),
+  };
   return { ok: true, mode, text, meta };
 }
 

package/src/main/chatRunner.cjs

@@ -310,8 +310,12 @@ function pump() {
       .catch(() => { /* executeRun never rejects; defensive */ })
       .finally(() => { activeCount -= 1; pump(); });
   }
-  // Anyone still waiting gets a 1-based position update.
+  // Anyone still waiting gets a 1-based position update. Silent (automated
+  // probe) runs must stay invisible to the renderer, same as every other
+  // broadcast in executeRun — otherwise a queued probe would flip a tab's
+  // `running`/`queuedPosition` UI state for a run the user never initiated.
   waiting.forEach((w, i) => {
+    if (w.silent) return;
     broadcast('chat:run:queued', { tabId: w.tabId, sessionId: w.sessionId, position: i + 1 });
   });
 }