browserzap 0.5.0 → 0.6.0

package/bridge-server/mcp-server.js

@@ -24,8 +24,10 @@
 const { WebSocket } = require('ws');
 const readline = require('readline');
 const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
-const { getOrCreateSecret } = require('./secret');
+const { getOrCreateSecret, configDir } = require('./secret');
 const { BIND_HOST, DEFAULT_PORT, PROTOCOL_VERSION, sanitizeSessionName } = require('./server');
 const { ensureBridge: ensureBridgeListening } = require('./ensure-bridge');
 const { LIMITS, CALL_DEADLINE_MS, STATUS_DEADLINE_MS } = require('./limits');
@@ -37,7 +39,9 @@ const { createWorkflowService, checkStep, stepLogEntry } = require('./workflow-s
 const { createSessionLog, describeArgs, describeResult } = require('./session-log');
 const workflows = require('./workflows');
 const screenshots = require('./screenshots');
-const { createRunRegistry, compactBatch, RunError } = require('./background-runs');
+const feedback = require('./feedback');
+const downloads = require('./downloads');
+const { createRunRegistry, compactBatch, probeResume, RunError } = require('./background-runs');
 
 const { WorkflowError, Recorder } = workflows;
 
@@ -189,12 +193,12 @@ function connectToBridge() {
 
 function describeBridgeProblem() {
   if (lastCloseCode === 4003) {
-    return 'The bridge rejected this server\'s pairing token. Run "npm run health" for details.';
+    return 'The bridge rejected this server\'s pairing token. Run "browserzap doctor" for details; "browserzap restart-bridge" replaces a bridge from another install.';
   }
   if (lastCloseCode === 4005) {
     return `${lastCloseReason || 'The bridge speaks a different protocol version.'} Restart the bridge and this MCP server after rebuilding.`;
   }
-  return 'The local BrowserZap bridge is not reachable. Run "npm run health" and check that the extension is loaded in Chrome.';
+  return 'The local BrowserZap bridge is not reachable. Run "browserzap doctor" and check that the extension is loaded in Chrome.';
 }
 
 function ensureSession(timeoutMs = 3000) {
@@ -227,7 +231,7 @@ function bridgeRequest(type, payload = {}, timeoutMs = 3000) {
     const id = `${SESSION_ID}-b${++bridgeSeq}`;
     const timer = setTimeout(() => {
       bridgeReplies.delete(id);
-      reject(Object.assign(new Error('The bridge did not answer. It may be an older version: run "npm run bridge:restart".'), { code: 'BRIDGE_DISCONNECTED' }));
+      reject(Object.assign(new Error('The bridge did not answer. It may be an older version: run "browserzap restart-bridge".'), { code: 'BRIDGE_DISCONNECTED' }));
     }, timeoutMs);
     bridgeReplies.set(id, (msg) => { clearTimeout(timer); resolve(msg); });
     ws.send(JSON.stringify({ type, id, ...payload }));
@@ -508,6 +512,13 @@ async function callToolWith(progress, requestId, toolName, args) {
 
   if (toolName === 'browser_list_profiles' || toolName === 'browser_select_profile') return finish(await profileTool(traceId, toolName, args));
 
+  if (toolName === 'browser_downloads') return finish(await downloadsTool(traceId, args));
+
+  if (toolName === 'feedback_list' || toolName === 'feedback_get') {
+    const { env, extra } = feedbackTool(traceId, toolName, args);
+    return finish(env, extra);
+  }
+
   if (LOCAL_TOOLS.has(toolName)) return finish(await workflowTool(requestId, traceId, toolName, args, progress));
   // A background run is driving this session's tab: reading is fine, acting would interleave with its steps.
   const running = backgroundRuns.active();
@@ -526,7 +537,19 @@ async function callToolWith(progress, requestId, toolName, args) {
     const notReady = await ensureBrowserForCall(traceId, progress, () => call.cancelled);
     if (notReady) return finish(notReady);
     if (call.cancelled) return finish(errorEnvelope(traceId, 'CANCELLED', 'Cancelled by the client.'));
-    const { env, extra } = await executeTool(toolName, args, { onStart: (c) => { call.cancel = c.cancel; } });
+    let toolArgs = args;
+    if (toolName === 'file_upload') {
+      const checked = checkUpload(traceId, args);
+      if (checked.error) return finish(checked.error);
+      toolArgs = checked.args;
+    }
+    // A download the agent starts is saved here, with no "Save as" dialog (dialogs.ts).
+    if (toolName === 'element_click' || toolName === 'browser_press_key') toolArgs = { ...toolArgs, downloadDir: downloadFolder() };
+    // A click or Enter may start a download: note the folder's names first (one directory read).
+    const watchDownloads = toolName === 'element_click' || toolName === 'browser_press_key';
+    const downloadsBefore = watchDownloads ? downloads.names(downloadFolder()) : null;
+    const { env, extra } = await executeTool(toolName, toolArgs, { onStart: (c) => { call.cancel = c.cancel; } });
+    if (downloadsBefore && env.ok) noteDownloads(env, downloadsBefore);
     if (recorder) recorder.observe(toolName, args, env);
     return finish(env, extra);
   } finally {
@@ -552,6 +575,160 @@ async function executeTool(toolName, args, { allowedOrigins = ALLOWED_ORIGINS, o
   return { env, extra };
 }
 
+// ─── Downloads (ROADMAP 0.5.4) ───────────────────────────────────────────────
+
+/** When this MCP server started: browser_downloads lists what arrived since then by default. */
+const SESSION_STARTED_AT = Date.now();
+let downloadDirCache = null;
+const downloadFolder = () => (downloadDirCache ??= downloads.downloadDir());
+
+/** A file that appeared in the Downloads folder during a click is said in its result. */
+function noteDownloads(env, before) {
+  const started = downloads.arrived(before, downloadFolder());
+  if (started.length === 0) return;
+  env.evidence = { ...(env.evidence ?? {}), downloads: started };
+  if (typeof env.summary === 'string') {
+    env.summary = `${env.summary} It started a download: ${started.map(downloads.describe).join(', ')}.`;
+  }
+  if (started.some((d) => d.state === 'in_progress') && !env.nextAction) {
+    env.nextAction = 'Call browser_downloads with waitForMs to wait until the download finishes.';
+  }
+}
+
+async function downloadsTool(traceId, args) {
+  const dir = downloadFolder();
+  let sinceMs = SESSION_STARTED_AT;
+  if (typeof args.since === 'string') {
+    const parsed = Date.parse(args.since);
+    if (Number.isNaN(parsed)) return errorEnvelope(traceId, 'INVALID_ARGUMENT', 'since must be an ISO date and time, e.g. 2026-10-29T10:00:00Z.');
+    sinceMs = parsed;
+  }
+  const waitMs = Number.isInteger(args.waitForMs) ? args.waitForMs : 0;
+  const { entries, timedOut } = waitMs > 0
+    ? await downloads.waitFor(dir, sinceMs, waitMs)
+    : { entries: downloads.since(dir, sinceMs), timedOut: false };
+  const running = entries.filter((e) => e.state === 'in_progress').length;
+  let summary = entries.length === 0
+    ? `No downloads in ${dir} since ${new Date(sinceMs).toISOString()}${timedOut ? ` (waited ${waitMs} ms)` : ''}.`
+    : `${entries.length} download(s)${running ? `, ${running} still in progress` : ', all complete'}: ${entries.slice(-5).map(downloads.describe).join(', ')}.`;
+  // Nothing arrived and Chrome asks where to save: the person is probably looking at a "Save as" dialog.
+  const asks = entries.length === 0 ? downloads.asksWhereToSave({ dataDir: chromeLauncher.userDataDir() }) : null;
+  if (asks) summary = `${summary} ${downloads.ASK_HINT}`;
+  return okEnvelope(traceId, summary, { downloads: entries, folder: dir }, { timedOut, ...(asks ? { chromeAsksWhereToSave: true } : {}) });
+}
+
+// ─── File upload (ROADMAP 0.5.4) ─────────────────────────────────────────────
+
+const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+
+/** What a file looks like when it must never leave the machine through file_upload, or null. */
+function secretLooking(file) {
+  const lower = file.toLowerCase().replace(/\\/g, '/');
+  const name = path.basename(lower);
+  const config = configDir().toLowerCase().replace(/\\/g, '/');
+  if (lower.startsWith(`${config}/`)) return 'BrowserZap\'s own data (pairing secret, licence, workflows)';
+  if (/\/\.(ssh|gnupg|aws|azure|kube|docker|config\/gcloud)\//.test(lower)) return 'a credentials folder';
+  if (/\/(google\/chrome|microsoft\/edge|bravesoftware|mozilla\/firefox)\/(user data|profiles?)\//.test(lower)) return 'a browser profile (cookies, saved passwords)';
+  if (/^(id_(rsa|dsa|ecdsa|ed25519)(\.pub)?|known_hosts|authorized_keys|\.netrc|\.npmrc|\.pypirc|\.git-credentials|credentials(\.json)?|\.env(\..+)?)$/.test(name)) return 'a key or credentials file';
+  if (/\.(pem|key|p12|pfx|jks|keystore|kdbx|ppk|ovpn)$/.test(name)) return 'a private key or password store';
+  return null;
+}
+
+/**
+ * Check a file_upload path before anything reaches the browser: absolute, an
+ * existing regular file, ≤ 50 MB, and inside BROWSERZAP_UPLOAD_DIR when that is
+ * set. The extension gets the resolved path plus the name and size it shows in
+ * the approval. The file's content is never read here.
+ */
+function checkUpload(traceId, args) {
+  const raw = String(args.path ?? '');
+  if (!path.isAbsolute(raw)) {
+    return { error: errorEnvelope(traceId, 'INVALID_ARGUMENT', 'path must be an absolute path on this computer.') };
+  }
+  let real;
+  let stat;
+  try {
+    real = fs.realpathSync(raw);
+    stat = fs.statSync(real);
+  } catch {
+    return { error: errorEnvelope(traceId, 'INVALID_ARGUMENT', `No file at ${raw}.`) };
+  }
+  if (!stat.isFile()) return { error: errorEnvelope(traceId, 'INVALID_ARGUMENT', `${raw} is not a file.`) };
+  // A page can try to talk the agent into uploading secrets (prompt injection).
+  // The person approves every file, and these are refused even then.
+  const secret = secretLooking(real);
+  if (secret) {
+    return { error: errorEnvelope(traceId, 'POLICY_BLOCKED', `${path.basename(real)} looks like ${secret}; file_upload never sends it.`, 'Choose the document the task needs, or ask the user to attach it themselves.') };
+  }
+  if (stat.size > MAX_UPLOAD_BYTES) {
+    return { error: errorEnvelope(traceId, 'INVALID_ARGUMENT', `${path.basename(real)} is ${Math.round(stat.size / 1048576)} MB; file_upload takes files up to 50 MB.`) };
+  }
+  const dir = process.env.BROWSERZAP_UPLOAD_DIR;
+  if (dir) {
+    let allowed;
+    try { allowed = fs.realpathSync(dir); } catch { allowed = path.resolve(dir); }
+    const rel = path.relative(allowed, real);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+      return { error: errorEnvelope(traceId, 'POLICY_BLOCKED', `Uploads are limited to ${allowed} (BROWSERZAP_UPLOAD_DIR).`) };
+    }
+  }
+  return { args: { ...args, path: real, fileName: path.basename(real), sizeBytes: stat.size } };
+}
+
+// ─── Comment mode batches (docs/COMMENT_MODE.md) ─────────────────────────────
+
+/** Inline images per feedback_get: enough to see every comment, small enough for any client. */
+const FEEDBACK_INLINE_IMAGES = 12;
+const FEEDBACK_INLINE_BYTES = 6 * 1024 * 1024;
+const MIME_BY_EXT = { png: 'image/png', jpg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif' };
+
+function feedbackTool(traceId, toolName, args) {
+  if (toolName === 'feedback_list') {
+    const batches = feedback.list({ includeDelivered: args.includeDelivered === true });
+    const pending = batches.filter((b) => !b.delivered).length;
+    return {
+      env: okEnvelope(traceId, batches.length
+        ? `${batches.length} comment batch(es)${pending ? `, ${pending} not yet read` : ''}.`
+        : 'No comments from the person. They add them with Comment mode in the BrowserZap side panel.', { batches }),
+      extra: [],
+    };
+  }
+  const batch = feedback.get(args.id);
+  if (!batch) {
+    return {
+      env: args.id
+        ? errorEnvelope(traceId, 'INVALID_ARGUMENT', `No comment batch "${args.id}".`, 'Call feedback_list to see the batches.')
+        : okEnvelope(traceId, 'No unread comments from the person. They add them with Comment mode in the BrowserZap side panel, then press Send.', { batch: null }),
+      extra: [],
+    };
+  }
+  if (args.markDelivered !== false) feedback.markDelivered(batch.id);
+  const extra = [];
+  let bytes = 0;
+  if (args.images !== false) {
+    for (const c of batch.comments) {
+      for (const file of [c.screenshot, ...c.attachments].filter(Boolean)) {
+        if (extra.length >= FEEDBACK_INLINE_IMAGES) break;
+        try {
+          const data = fs.readFileSync(file);
+          if (bytes + data.length > FEEDBACK_INLINE_BYTES) continue;
+          bytes += data.length;
+          extra.push({ type: 'text', text: `Comment ${c.n}: ${file === c.screenshot ? 'the element' : 'image the person attached'}` });
+          extra.push({ type: 'image', data: data.toString('base64'), mimeType: MIME_BY_EXT[path.extname(file).slice(1)] ?? 'image/png' });
+        } catch { /* pruned meanwhile: the path is still listed */ }
+      }
+    }
+  }
+  const pages = [...new Set(batch.comments.map((c) => c.page.url))];
+  return {
+    env: okEnvelope(traceId,
+      `${batch.comments.length} comment(s) from the person on ${pages.length === 1 ? pages[0] : `${pages.length} pages`}.`,
+      { batch },
+      {}),
+    extra,
+  };
+}
+
 // ─── Workflows and plan (docs/WORKFLOWS.md, docs/PRO.md) ─────────────────────
 
 /** The active recording for this MCP session, if any. In memory only. */
@@ -752,7 +929,7 @@ async function runTool(requestId, traceId, args, progress) {
  * redaction as screenshot_capture).
  */
 async function runBatchOrOnce({
-  wf, params, paramSets, labels, onError, startAt = 0, approvalId, signal,
+  wf, params, paramSets, labels, onError, startAt = 0, approvalId, signal, resume = [],
   onCall = () => {}, onStep = () => {}, onSet = () => {}, onSetDone = () => {},
 }) {
   const execute = async (tool, stepArgs, { allowedOrigins }) => {
@@ -769,14 +946,14 @@ async function runBatchOrOnce({
     const { env } = await executeTool('screenshot_capture', {}, { allowedOrigins: ALLOWED_ORIGINS });
     return env.ok ? env.screenshotPath ?? null : null;
   };
-  const runOnce = async (setParams, first) => {
+  const runOnce = async (setParams, first, setStartAt = 0) => {
     const startedAt = new Date().toISOString();
     const history = workflows.runHistory(wf);
     const result = await workflows.run(wf, {
       history,
       onStep,
       params: setParams,
-      startAt: first ? startAt : 0,
+      startAt: setStartAt || (first ? startAt : 0),
       approvalId: first ? approvalId : undefined,
       execute,
       capture,
@@ -787,7 +964,7 @@ async function runBatchOrOnce({
     service.recordRun({ wf, result, params: setParams, startedAt });
     return result;
   };
-  if (paramSets === undefined) return runOnce(params, true);
+  if (paramSets === undefined) return runOnce(params, true, startAt);
   let first = true;
   return pro.runBulk({
     wf,
@@ -795,9 +972,22 @@ async function runBatchOrOnce({
     labels,
     onError,
     signal,
+    resume,
+    // A resume at the failed step is probed first, as a real wait_for_state
+    // through executeTool; the page has moved, so the set starts at the
+    // navigation anchor instead (A6-09). With no anchor it fails without acting.
+    resumeStart: ({ plan, params: setParams }) => probeResume({
+      wf, plan, params: setParams, execute, allowedOrigins: ALLOWED_ORIGINS,
+    }),
     onSet,
     onSetDone,
-    runOnce: (setParams) => { const r = runOnce(setParams, first); first = false; return r; },
+    // A re-run of the sets that failed resumes at the step that failed where
+    // the page allows it (0.6.0), instead of starting every set at step 1.
+    runOnce: (setParams, setStartAt) => {
+      const r = runOnce(setParams, first, setStartAt ?? 0);
+      first = false;
+      return r;
+    },
   });
 }
 
@@ -808,6 +998,7 @@ const backgroundRuns = createRunRegistry({
     paramSets: job.paramSets,
     labels: job.labels,
     onError: job.onError,
+    resume: job.resume,
     signal: job.controller.signal,
     onCall: (c) => { job.call = c; },
     onStep: ({ index }) => backgroundRuns.progress(job, { stepIndex: index }),
@@ -823,7 +1014,7 @@ const backgroundRuns = createRunRegistry({
 });
 
 /** Tools that only read, allowed while a background run drives the tab. */
-const READ_WHILE_RUNNING = new Set(['browser_status', 'page_inspect', 'screenshot_capture', 'browser_list_tabs', 'browser_list_profiles']);
+const READ_WHILE_RUNNING = new Set(['browser_status', 'page_inspect', 'screenshot_capture', 'page_console', 'page_network', 'browser_list_tabs', 'browser_list_profiles']);
 
 /**
  * "5 of 5 done" / "3 of 5 done, 2 need attention" as a Chrome notification
@@ -863,14 +1054,16 @@ function statusOfRuns(traceId, args) {
 }
 
 function rerunFailedTool(traceId, args) {
-  const { job: previous, paramSets, labels } = backgroundRuns.failedSets(args.rerunFailed);
+  const { job: previous, paramSets, labels, resume } = backgroundRuns.failedSets(args.rerunFailed);
   if (previous.workflow !== args.name) {
     return errorEnvelope(traceId, 'INVALID_ARGUMENT', `${previous.runId} ran "${previous.workflow}", not "${args.name}".`);
   }
   if (paramSets.length === 0) return okEnvelope(traceId, `Every set of ${previous.runId} completed; nothing to run again.`);
-  const job = backgroundRuns.start({ wf: workflows.load(previous.workflow), paramSets, labels, onError: 'continue' });
+  const job = backgroundRuns.start({ wf: workflows.load(previous.workflow), paramSets, labels, onError: 'continue', resume });
+  const resumed = resume.filter((plan) => plan?.at > 0).length;
   return okEnvelope(traceId,
-    `Running the ${paramSets.length} set(s) of ${previous.runId} that did not complete, from the start, in the background (${job.runId}).`,
+    `Running the ${paramSets.length} set(s) of ${previous.runId} that did not complete` +
+    `${resumed ? `, ${resumed} from the step that failed` : ''}, in the background (${job.runId}).`,
     { runId: job.runId }, { paramSets: paramSets.length, rerunOf: previous.runId });
 }
 
@@ -882,7 +1075,7 @@ async function profileTool(traceId, toolName, args) {
       ? await bridgeRequest('profiles_list')
       : await bridgeRequest('profile_select', { profile: args.profile });
   } catch (err) {
-    return errorEnvelope(traceId, err.code || 'BRIDGE_DISCONNECTED', err.message, 'Run "npm run health".');
+    return errorEnvelope(traceId, err.code || 'BRIDGE_DISCONNECTED', err.message, 'Ask the user to run "browserzap doctor".');
   }
   const profiles = reply.data?.profiles ?? [];
   if (!reply.ok) {
@@ -931,7 +1124,7 @@ async function statusTool(traceId, args) {
       evidence.bridge = 'connected';
     } catch {
       return { ...errorEnvelope(traceId, 'BRIDGE_DISCONNECTED', describeBridgeProblem(),
-        'Ask the user to run "npm run health" in the BrowserZap folder.'), evidence };
+        'Ask the user to run "browserzap doctor"; every failed line says what to do.'), evidence };
     }
   }
   try {
@@ -951,6 +1144,10 @@ async function statusTool(traceId, args) {
     const result = await call.promise;
     const env = envelope(call.id, result);
     env.evidence = { ...evidence, extension: 'connected' };
+    const waiting = feedback.pendingCount();
+    if (waiting && typeof env.summary === 'string') {
+      env.summary = `${env.summary} The person sent ${waiting} comment batch(es) from Comment mode: call feedback_get.`;
+    }
     return env;
   } catch {
     evidence.extension = 'not_connected';
@@ -1012,7 +1209,11 @@ async function handleRequest(request) {
           'For a task the user repeats, record it once with workflow_record and replay it with workflow_run. ' +
           'Tabs: work in the session\'s main tab and navigate it for each new task. Open a helper with ' +
           'browser_new_tab only for a side trip (research, a comparison) and close it with browser_close_tab when done, ' +
-          'which takes you back to the main tab. A session keeps at most 3 tabs between tasks; its tabs close when it ends.',
+          'which takes you back to the main tab. A session keeps at most 3 tabs between tasks; its tabs close when it ends. ' +
+          'When the user mentions their BrowserZap feedback or comments, call feedback_get: it returns the notes they ' +
+          'made on page elements in Comment mode, with components, source files and screenshots. When debugging a page, ' +
+          'page_console and page_network show what it logged and requested. A click that downloads a file says so; ' +
+          'browser_downloads lists and waits for downloads. file_upload always needs the user\'s approval per file.',
       });
       break;
     }

package/bridge-server/native-host.js

@@ -26,7 +26,7 @@ const { getOrCreateSecret } = require('./secret');
 const { DEFAULT_PORT, PROTOCOL_VERSION, fileLogger } = require('./server');
 const { ensureBridge } = require('./ensure-bridge');
 const { helloProbe } = require('./probe');
-const { HOST_NAME, extensionOrigin } = require('./extension-id');
+const { HOST_NAME, allowedOrigins } = require('./extension-id');
 
 /** Inbound frames above this are rejected before parsing. Chrome's own host→Chrome cap is 1 MiB. */
 const MAX_MESSAGE_BYTES = 1024 * 1024;
@@ -130,7 +130,9 @@ async function handleRequest(request, options = {}) {
   });
   if (!verified.ok) {
     logLine('bridge_not_verified', { port, code: verified.code });
-    return { type: 'error', error: 'bridge_unavailable' };
+    // 4003: a BrowserZap bridge is listening but holds another install's secret
+    // (D-39). The extension shows the fix instead of staying grey.
+    return { type: 'error', error: verified.code === 4003 ? 'bridge_foreign' : 'bridge_unavailable' };
   }
   verified.ws.close();
   logLine('hello_served', { port });
@@ -141,7 +143,7 @@ function main() {
   // Defense in depth: allowed_origins is the real control, but refuse a caller
   // that is not the BrowserZap extension if Chrome tells us who it is.
   const origin = process.argv[2];
-  if (typeof origin === 'string' && origin.startsWith('chrome-extension://') && origin !== extensionOrigin()) {
+  if (typeof origin === 'string' && origin.startsWith('chrome-extension://') && !allowedOrigins().includes(origin)) {
     logLine('wrong_origin');
     process.exit(1);
   }

package/bridge-server/panel.js

@@ -38,7 +38,9 @@ const { CALL_DEADLINE_MS } = require('./limits');
 const { createWorkflowService, checkStep, stepLogEntry } = require('./workflow-service');
 const { createSessionLog, describeResult } = require('./session-log');
 const { parseParamSets } = require('./param-sets');
+const { resumePlan, probeResume } = require('./background-runs');
 const screenshots = require('./screenshots');
+const feedback = require('./feedback');
 
 const PANEL_SESSION = 'panel';
 const PANEL_SESSION_NAME = 'BrowserZap workflows';
@@ -217,7 +219,13 @@ function createPanelRunner({ deliver, toExtension, log = () => {} }) {
           if (ok) current.batch.done += 1;
           else current.batch.failed += 1;
         },
-        runOnce: (setParams) => runOnce(setParams, 0),
+        // "Re-run failed" probes the failed step's target before resuming there,
+        // as a real wait_for_state; a page that has moved starts at the
+        // navigation anchor, and with no anchor the set fails without acting (A6-09).
+        resumeStart: ({ plan, params: setParams }) => probeResume({
+          wf, plan, params: setParams, execute, allowedOrigins: wf.origins,
+        }),
+        runOnce: (setParams, setStartAt) => runOnce(setParams, setStartAt ?? 0),
       });
       const runs = result.evidence?.runs ?? [];
       lastBatch = {
@@ -225,6 +233,9 @@ function createPanelRunner({ deliver, toExtension, log = () => {} }) {
         paramSets: batch.paramSets,
         labels: batch.labels,
         unfinished: batch.paramSets.map((_, i) => i).filter((i) => !runs.some((r) => r.index === i && r.ok)),
+        // Where each set may resume when the person presses "Re-run failed" (0.6.0):
+        // the plan a probe proves before it is used (A6-09).
+        resumeByIndex: Object.fromEntries(runs.filter((r) => !r.ok).map((r) => [r.index, resumePlan(wf, r)])),
       };
       // What the person needs to find each problem: step, cause, screenshot. Never values.
       const attention = runs.filter((r) => !r.ok).map((r) => ({
@@ -240,7 +251,7 @@ function createPanelRunner({ deliver, toExtension, log = () => {} }) {
         status: result.ok ? 'completed' : controller.signal.aborted ? 'cancelled' : 'failed',
         summary: result.summary,
         code: result.error?.code ?? null,
-        nextAction: lastBatch.unfinished.length ? `${lastBatch.unfinished.length} set(s) did not complete. "Re-run failed" runs just those, from the start.` : null,
+        nextAction: lastBatch.unfinished.length ? `${lastBatch.unfinished.length} set(s) did not complete. "Re-run failed" runs just those, from the step that failed where the page allows it.` : null,
         canContinueFrom: null,
         batch: { ...current.batch, attention, report: result.evidence?.report ?? null, canRerun: lastBatch.unfinished.length > 0 },
         finishedAt: new Date().toISOString(),
@@ -395,7 +406,8 @@ function createPanelRunner({ deliver, toExtension, log = () => {} }) {
           const wf = workflows.load(lastBatch.workflow);
           const paramSets = lastBatch.unfinished.map((i) => lastBatch.paramSets[i]);
           const labels = lastBatch.unfinished.map((i) => lastBatch.labels[i] ?? `#${i + 1}`);
-          runWorkflow(wf, {}, 0, profile, { paramSets, labels }).catch((err) => log('panel_run_error', { message: err.message }));
+          const resume = lastBatch.unfinished.map((i) => lastBatch.resumeByIndex?.[i] ?? null);
+          runWorkflow(wf, {}, 0, profile, { paramSets, labels, resume }).catch((err) => log('panel_run_error', { message: err.message }));
           return { ok: true, data: { runId: current.runId, sets: paramSets.length } };
         }
         case 'run':
@@ -424,6 +436,12 @@ function createPanelRunner({ deliver, toExtension, log = () => {} }) {
         case 'delete':
           workflows.remove(String(args.name));
           return { ok: true, data: {} };
+        case 'feedback_submit': {
+          // Comment mode (docs/COMMENT_MODE.md): stored on this device for the agent's feedback_get.
+          const saved = feedback.saveBatch(args.batch);
+          log('feedback_saved', { batch: saved.id, comments: saved.count });
+          return { ok: true, data: { batchId: saved.id, count: saved.count } };
+        }
         default:
           return { ok: false, error: { code: 'INVALID_ARGUMENT', message: `Unknown panel request "${op}".` } };
       }

package/bridge-server/probe.js

@@ -101,7 +101,8 @@ function nodePidsOnPort(port) {
       return [...pids].filter((pid) => /node\.exe/i.test(execFileSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], { encoding: 'utf8', windowsHide: true })));
     }
     for (const pid of execFileSync('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { encoding: 'utf8' }).split(/\s+/).filter(Boolean)) {
-      if (/node/i.test(execFileSync('ps', ['-p', pid, '-o', 'comm='], { encoding: 'utf8' }))) pids.add(pid);
+      // `comm` can be Node's thread name ("MainThread") on Linux; the command line names node.
+      if (/(^|\/)node(\.exe)?(\s|$)/i.test(execFileSync('ps', ['-p', pid, '-o', 'args='], { encoding: 'utf8' }).trim())) pids.add(pid);
     }
   } catch { /* netstat/lsof missing or nothing found */ }
   return [...pids];