webhelm 1.0.6 → 1.0.7

package/README.md

@@ -29,6 +29,16 @@ npx --yes webhelm@latest session stop SESSION_ID
 
 Use `npx skills add lalalic/webhelm --skill webhelm` to install agent guidance. The Extension is bundled with the npm Runtime and staged by WebHelm Daemon at `~/.local/webhelm/extension`. The Skill lives **in this repo** at `skills/webhelm/SKILL.md`. No Chrome Web Store publication or manual Extension installation is required.
 
+## WebHelm Chrome Extension control panel
+
+The daemon-managed Chrome Extension is installed from the npm Runtime and does not require the Chrome Web Store. Click the WebHelm toolbar icon to see daemon connectivity, each configured workspace's available capacity and current Session count. The badge shows total available slots across configured workspaces, including unallocated lazy slots; `!` means the daemon heartbeat is stale and `?` means capacity cannot be determined.
+
+The popup has a confirmation step to stop one Session, clear Sessions in one workspace, or clear Sessions across all workspaces. These actions are executed by the same Node daemon as the CLI, over the existing CDP-backed Extension RPC. No shell access or HTTP listener is granted to the Extension. The persistent ChatGPT queue is not deleted, and queued work may create new Sessions afterward.
+
+New installations use the default Chrome tab group `WebHelm` and the idle page `helm.html`. Legacy `Harness` default groups migrate only when their tabs are idle. Custom workspace names are unchanged; the old `workspace.html` path and lease titles remain readable until their Sessions finish. Closing an allocated Session returns its managed tabs to the idle page, retaining physical Chrome targets, while unleased popup children are closed. Do not manually remove active managed tabs.
+
+For a real browser integration check on macOS, run `node test/e2e/extension-control.e2e.mjs`; it creates a temporary isolated Chrome profile and daemon and does not touch the current production Sessions.
+
 The Actions checkout is `~/.local/webhelm`, with site modules at `~/.local/webhelm/platforms`. Setup clones if absent, then reuses that checkout without discarding local modifications. Run `platform sync` for new commits. For a verified local Action fix, `platform publish --message "..."` tests, commits and pushes only the action changes to the separate repo.
 
 ## Architecture and compatibility

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webhelm",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Agent browser automation in a visible managed Chrome with persistent JavaScript sessions",
   "type": "module",
   "bin": {
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "test": "node --test test/node/*.test.mjs test/workspace-manager.test.mjs skills/webhelm/tests/*.test.mjs",
-    "test:package": "npm pack --dry-run --json"
+    "test:package": "npm pack --dry-run --json",
+    "test:e2e:extension": "node test/e2e/extension-control.e2e.mjs"
   },
   "license": "MIT",
   "repository": {

package/runtime/cli.mjs

@@ -25,9 +25,9 @@ Usage:
   webhelm migrate  # after stopping Chrome and the old WebHelm daemon
   webhelm setup
   webhelm status
-  webhelm ensure  # verify/recover managed Chrome and Harness, not just daemon ping
+  webhelm ensure  # verify/recover managed Chrome and WebHelm group, not just daemon ping
   webhelm capacity [--workspace NAME]
-  webhelm session start [--url URL]
+  webhelm session start [--workspace NAME] [--url URL]
   webhelm session list
   webhelm session heartbeat SESSION_ID  # keep a working Session alive
   webhelm session exec SESSION_ID [--code-file FILE]   # JavaScript

package/runtime/extension/control-channel.mjs

@@ -0,0 +1,120 @@
+// The daemon polls this short-lived mailbox through the existing CDP Extension
+// RPC. Never expose a local HTTP service or execute shell commands in Chrome.
+const KEY = 'webhelm.control.v1';
+const FRESH_MS = 8_000;
+const EXPIRY_MS = 20_000;
+const ABANDONED_MS = 10 * 60_000;
+
+export class ControlChannel {
+  constructor(chromeApi, now = () => Date.now(), makeId = () => crypto.randomUUID()) {
+    this.chrome = chromeApi;
+    this.now = now;
+    this.makeId = makeId;
+    this.queue = Promise.resolve();
+  }
+
+  serialize(fn) {
+    const task = this.queue.then(fn);
+    this.queue = task.catch(() => {});
+    return task;
+  }
+
+  async read() {
+    return (await this.chrome.storage.session.get(KEY))[KEY] || {};
+  }
+
+  async save(state) {
+    await this.chrome.storage.session.set({[KEY]: state});
+  }
+
+  normalize(state) {
+    const result = {...state};
+    if (result.request) {
+      const age = this.now() - result.request.createdAt;
+      if (result.request.state === 'pending' && age > EXPIRY_MS) {
+        result.lastResult = {id: result.request.id, ok: false, error: 'The request expired. Try again.'};
+        result.request = null;
+      } else if (result.request.state === 'processing' && age > ABANDONED_MS) {
+        result.lastResult = {id: result.request.id, ok: false,
+          error: 'The daemon did not confirm completion. Check current sessions before retrying.'};
+        result.request = null;
+      }
+    }
+    return result;
+  }
+
+  async status() {
+    const state = this.normalize(await this.read());
+    const connected = Number.isFinite(state.daemon?.seenAt) &&
+      this.now() - state.daemon.seenAt < FRESH_MS;
+    return {
+      connected,
+      sessionCount: connected ? state.daemon.sessions?.length ?? 0 : null,
+      sessions: connected ? state.daemon.sessions || [] : [],
+      request: state.request || null,
+      lastResult: state.lastResult || null,
+    };
+  }
+
+  async requestStop(action, sessionId, workspace) {
+    return this.serialize(async () => {
+      if (!['stop-all', 'stop', 'stop-workspace'].includes(action)) throw new Error('Unsupported action');
+      const state = this.normalize(await this.read());
+      if (state.request) throw new Error('Another WebHelm operation is already running');
+      if (!Number.isFinite(state.daemon?.seenAt) || this.now() - state.daemon.seenAt >= FRESH_MS)
+        throw new Error('WebHelm daemon is not responding');
+      const sessions = state.daemon.sessions || [];
+      if (action === 'stop-all' && !sessions.length) throw new Error('No active sessions to stop');
+      if (action === 'stop' && !sessions.some(s => s.session_id === sessionId))
+        throw new Error('Session is no longer active');
+      if (action === 'stop-workspace' && (!workspace || !sessions.some(s => s.workspace === workspace)))
+        throw new Error('No active sessions in this workspace');
+      const request = {id: this.makeId(), action, ...(action === 'stop' ? {sessionId} : {}),
+        ...(action === 'stop-workspace' ? {workspace} : {}),
+        state: 'pending', createdAt: this.now()};
+      await this.save({...state, request, lastResult: null});
+      return {id: request.id, state: 'pending'};
+    });
+  }
+
+  async heartbeat(sessions) {
+    return this.serialize(async()=>{
+      if (!Array.isArray(sessions)) throw new Error('Invalid sessions');
+      const state=this.normalize(await this.read());
+      await this.save({...state,daemon:{seenAt:this.now(),sessions}});
+      return {updated:true};
+    });
+  }
+
+  async poll(sessions) {
+    return this.serialize(async () => {
+      if (!Array.isArray(sessions) || sessions.some(s =>
+        typeof s?.session_id !== 'string' || typeof s?.workspace !== 'string'))
+        throw new Error('Invalid daemon session listing');
+      const state = this.normalize(await this.read());
+      const request = state.request?.state === 'pending'
+        ? {...state.request, state: 'processing'}
+        : state.request || null;
+      await this.save({...state, request, daemon: {seenAt: this.now(), sessions}});
+      return request?.state === 'processing' && state.request?.state === 'pending'
+        ? {id: request.id, action: request.action, ...(request.sessionId ? {sessionId:request.sessionId} : {}),
+          ...(request.workspace ? {workspace:request.workspace} : {})}
+        : null;
+    });
+  }
+
+  async complete(id, response) {
+    return this.serialize(async () => {
+      const state = this.normalize(await this.read());
+      if (!state.request || state.request.id !== id) return {ignored: true};
+      const stoppedCount = response?.stopped_count ?? (response?.stopped ? 1 : 0);
+      const errors = response?.errors || [];
+      const errorText = response?.error || errors.map(e => e.error || String(e)).join('; ');
+      const lastResult = response?.ok
+        ? {id, ok: errors.length === 0, stoppedCount, errors, ...(errors.length ? {error: errorText} : {})}
+        : {id, ok: false, stoppedCount, errors, error: String(errorText || 'Unable to stop sessions')};
+      await this.save({...state, request: null, lastResult});
+      return lastResult;
+    });
+  }
+}

package/runtime/extension/helm.html

@@ -0,0 +1,125 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>WebHelm</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+      --page: #f5f7fb;
+      --card: #fff;
+      --ink: #182234;
+      --subtle: #5f6d81;
+      --border: #e2e8f0;
+      --accent: #335bd1;
+      --accent-bg: #edf2ff;
+    }
+    * { box-sizing: border-box; }
+    body {
+      min-height: 100vh;
+      margin: 0;
+      padding: 32px 20px;
+      display: grid;
+      place-items: center;
+      font: 15px/1.55 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      color: var(--ink);
+      background: var(--page);
+    }
+    main {
+      width: min(100%, 460px);
+      padding: clamp(24px, 6vw, 36px);
+      border: 1px solid var(--border);
+      border-radius: 20px;
+      background: var(--card);
+      box-shadow: 0 12px 35px rgb(25 42 76 / 5%);
+    }
+    header { display: flex; align-items: center; gap: 14px; }
+    .mark {
+      display: grid;
+      place-items: center;
+      width: 48px;
+      height: 48px;
+      border-radius: 14px;
+      background: var(--accent);
+      color: white;
+      font-size: 24px;
+      font-weight: 750;
+      letter-spacing: -2px;
+    }
+    .eyebrow {
+      margin: 0;
+      color: var(--subtle);
+      font-size: 11px;
+      font-weight: 650;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+    }
+    h1 { margin: 1px 0 0; font-size: 24px; line-height: 1.2; letter-spacing: -0.03em; }
+    .status {
+      display: inline-flex;
+      align-items: center;
+      gap: 9px;
+      margin-top: 32px;
+      padding: 7px 12px;
+      border-radius: 999px;
+      background: var(--accent-bg);
+      color: var(--accent);
+      font-weight: 650;
+      font-size: 13px;
+    }
+    .dot { width: 7px; height: 7px; border-radius: 50%; background: currentColor; }
+    .description { margin: 16px 0 24px; color: var(--subtle); }
+    dl {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+      gap: 16px;
+      margin: 0;
+      padding: 18px 0;
+      border-block: 1px solid var(--border);
+    }
+    dt { margin-bottom: 3px; color: var(--subtle); font-size: 12px; }
+    dd { margin: 0; font-weight: 650; overflow-wrap: anywhere; }
+    footer { margin-top: 20px; color: var(--subtle); font-size: 12px; }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --page: #10151e;
+        --card: #192232;
+        --ink: #edf2f9;
+        --subtle: #a8b3c5;
+        --border: #354256;
+        --accent: #a5baff;
+        --accent-bg: #293656;
+      }
+      .mark { background: #4269e0; }
+      main { box-shadow: none; }
+    }
+    @media (max-width: 380px) {
+      body { padding: 16px; }
+      main { border-radius: 14px; }
+    }
+  </style>
+  <script type="module" src="workspace-page.mjs"></script>
+</head>
+<body>
+  <main aria-labelledby="page-title">
+    <header>
+      <div class="mark" aria-hidden="true">W</div>
+      <div>
+        <p class="eyebrow">Managed browser tab</p>
+        <h1 id="page-title">WebHelm</h1>
+      </div>
+    </header>
+    <div class="status" role="status">
+      <span class="dot" aria-hidden="true"></span>
+      <span id="status-label">Managed workspace</span>
+    </div>
+    <p class="description" id="description">This page belongs to WebHelm's managed browser workspace.</p>
+    <dl>
+      <div><dt>Workspace</dt><dd id="workspace-name">—</dd></div>
+      <div><dt>Tab slot</dt><dd id="slot-number">—</dd></div>
+    </dl>
+    <footer id="help-text">Tab status does not indicate whether the daemon is connected.</footer>
+  </main>
+</body>
+</html>

package/runtime/extension/manifest.json

@@ -1,14 +1,15 @@
 {
   "manifest_version": 3,
-  "name": "Browser Workspace",
-  "version": "0.3.3",
+  "name": "WebHelm",
+  "version": "0.4.0",
   "description": "Own named Chrome tab-group workspaces and lazy reusable tab pools for browser agents.",
   "permissions": [
     "storage",
     "tabs",
     "tabGroups",
     "webNavigation",
-    "contextMenus"
+    "contextMenus",
+    "alarms"
   ],
   "host_permissions": [
     "http://*/*",
@@ -18,8 +19,11 @@
     "service_worker": "service-worker.mjs",
     "type": "module"
   },
+  "icons": { "16": "icons/webhelm-16.png", "32": "icons/webhelm-32.png", "48": "icons/webhelm-48.png", "128": "icons/webhelm-128.png" },
   "action": {
-    "default_title": "Browser Workspace"
+    "default_title": "WebHelm",
+    "default_popup": "popup.html",
+    "default_icon": { "16": "icons/webhelm-16.png", "32": "icons/webhelm-32.png" }
   },
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtovrqHYRxYDBSofmlykO8RDtsePhg8KV1fmq07nnhtbmYiNXAnIKrgRyLHeZv+cwm9DSgP5Ig7FDJ7Q6XrSi+Z1FpU6Y/SJkX5Rozo0oAJcX1ggoGD3vxpfHZThSSG/vRSnD8pH3XFf2nDUD7QP6GXc8dX9lN5pslRUNh1J4UCAOcu2UpPSsvpA+wPPTZr2JYzm3AevFXkQM6y0B+4exgw/Hy21ULST4nLWZihuCSu+gfWnftiTNzUPHtseRJcrpd0zT0R46d+OC+JRwXMVBpYSksDDtOXgERwMBSZf+vvskrEqYoXKN8Z9+Rrr7y9PTOvlwQioVLEDEjr9e7RIegQIDAQAB"
 }

package/runtime/extension/popup.html

@@ -0,0 +1,61 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>WebHelm</title>
+  <style>
+    :root { color-scheme: light dark; --ink:#182234; --muted:#5f6d81; --border:#e1e7f0; --accent:#345fd5; --accent-light:#edf2ff; --warning:#ae3849; }
+    * { box-sizing: border-box; }
+    body { width:340px; min-height:250px; margin:0; padding:18px; background:light-dark(#fff,#172131); color:light-dark(var(--ink),#edf2f9); font:13px/1.5 system-ui,sans-serif; }
+    h1 { margin:0 0 2px; font-size:18px; letter-spacing:-.02em; }
+    p { margin:4px 0 12px; color:light-dark(var(--muted),#acb8c9); }
+    .stats { display:flex; gap:10px; padding:12px 0; border-block:1px solid light-dark(var(--border),#334155); margin-bottom:12px; }
+    .stat { flex:1; }
+    .stat strong { display:block; font-size:20px; }
+    .stat span { font-size:11px; color:light-dark(var(--muted),#acb8c9); }
+    button { width:100%; border:1px solid light-dark(var(--border),#40516a); background:light-dark(#fff,#22314a); color:inherit; border-radius:9px; padding:9px; cursor:pointer; font:inherit; font-weight:600; }
+    button:disabled { opacity:.5; cursor:not-allowed; }
+    button.danger { background:#ae3849; color:#fff; border-color:#ae3849; }
+    button:focus-visible { outline:3px solid var(--accent); outline-offset:2px; }
+    #confirmation { margin:8px 0; padding:11px; background:light-dark(#fff1f2,#43222a); border-radius:9px; }
+    #confirmation p { color:inherit; }
+    .buttons { display:flex; gap:8px; }
+    .session-header { margin:12px 0 6px; font-size:13px; font-weight:700; }
+    .session-list { max-height:160px; overflow:auto; }
+    .workspace-row { padding:12px 0; border-bottom:1px solid light-dark(var(--border),#334155); }
+    .workspace-title { display:flex; align-items:center; gap:8px; justify-content:space-between; }
+    .workspace-title strong { font-size:13px; overflow-wrap:anywhere; }
+    .workspace-title button { width:auto; flex-shrink:0; padding:5px 9px; font-size:11px; }
+    .workspace-details { color:light-dark(var(--muted),#acb8c9); font-size:11px; margin:4px 0; }
+    .session-row { display:flex; align-items:center; gap:8px; padding:7px 0; border-bottom:1px solid light-dark(var(--border),#334155); }
+    .session-info { min-width:0; flex:1; }
+    .session-info strong { display:block; font-size:12px; }
+    .session-info span { display:block; color:light-dark(var(--muted),#acb8c9); font-size:11px; }
+    .session-row button { width:auto; padding:5px 9px; font-size:11px; }
+    #message { min-height:20px; margin-top:10px; font-size:12px; overflow-wrap:anywhere; }
+    [hidden] { display:none !important; }
+  </style>
+  <script type="module" src="popup.mjs"></script>
+</head>
+<body>
+  <h1>WebHelm</h1>
+  <p>Managed Chrome · Workspace control</p>
+  <div class="stats" aria-live="polite">
+    <div class="stat"><strong id="available">—</strong><span>Total available slots</span></div>
+    <div class="stat"><strong id="sessions">—</strong><span>Active sessions</span></div>
+    <div class="stat"><strong id="daemon">—</strong><span>Daemon</span></div>
+  </div>
+  <div class="session-header">Workspaces</div>
+  <div id="workspace-list" class="session-list" aria-live="polite">Connecting…</div>
+  <button id="clear">Clear all sessions in all workspaces</button>
+  <section id="confirmation" hidden aria-label="Confirm clear sessions">
+    <p id="confirm-text">Stop the selected WebHelm session(s)? Tasks in progress may be interrupted. Queued jobs remain and may create new sessions.</p>
+    <div class="buttons">
+      <button id="cancel">Cancel</button>
+      <button class="danger" id="confirm">Confirm stop</button>
+    </div>
+  </section>
+  <div id="message" role="status" aria-live="polite"></div>
+</body>
+</html>

package/runtime/extension/popup.mjs

@@ -0,0 +1,136 @@
+const el = id => document.getElementById(id);
+let confirming = false;
+let requestId = null;
+let chosen = {action: 'stop-all'};
+let lastSignature = '';
+let refreshRunning = false;
+
+async function rpc(method, args = {}) {
+  const response = await chrome.runtime.sendMessage({method, args});
+  if (!response?.ok) throw new Error(response?.error?.message || 'WebHelm request failed');
+  return response.result;
+}
+
+function showConfirmation(action, params = {}) {
+  chosen = {action, ...params};
+  confirming = true;
+  el('confirmation').hidden = false;
+  el('clear').hidden = true;
+  if (action === 'stop-all') {
+    el('confirm-text').textContent = 'Stop sessions in ALL workspaces? Active tasks will be interrupted; queued jobs may create new sessions.';
+  } else if (action === 'stop-workspace') {
+    el('confirm-text').textContent = `Stop all sessions in "${params.workspace}"? Other workspaces are unaffected.`;
+  } else {
+    el('confirm-text').textContent = `Stop session ${params.sessionId.slice(0,12)}…? Active work may be interrupted.`;
+  }
+}
+
+function actionButton(label, disabled, onClick) {
+  const button = document.createElement('button');
+  button.textContent = label;
+  button.disabled = disabled;
+  button.addEventListener('click', onClick);
+  return button;
+}
+
+function renderWorkspaces(workspaces, busy, connected) {
+  const signature = JSON.stringify(workspaces.map(w => [
+    w.name,w.initialized,w.available,w.poolSize,w.idleTabs,w.leasedTabs,w.sessions.map(s => s.session_id),
+  ])) + ':' + busy + ':' + connected;
+  if (signature === lastSignature) return;
+  lastSignature = signature;
+  const target = el('workspace-list');
+  target.replaceChildren();
+  if (!workspaces.length) {
+    target.textContent = 'No configured workspaces';
+    return;
+  }
+  for (const workspace of workspaces) {
+    const row = document.createElement('section');
+    row.className = 'workspace-row';
+    const header = document.createElement('div');
+    header.className = 'workspace-title';
+    const heading = document.createElement('strong');
+    heading.textContent = workspace.name;
+    header.append(heading, actionButton('Clear group', busy || !connected || !workspace.sessions.length,
+      () => showConfirmation('stop-workspace', {workspace:workspace.name})));
+    const info = document.createElement('div');
+    info.className = 'workspace-details';
+    info.textContent = workspace.initialized
+      ? `${workspace.available} available / ${workspace.poolSize} slots · ${workspace.idleTabs} idle tabs · ${workspace.leasedTabs} leased · ${workspace.sessions.length} sessions`
+      : `Unavailable · ${workspace.sessions.length} sessions · ${workspace.reason || 'workspace missing'}`;
+    row.append(header, info);
+    for (const session of workspace.sessions) {
+      const sessionRow = document.createElement('div');
+      sessionRow.className = 'session-row';
+      const details = document.createElement('div');
+      details.className = 'session-info';
+      const identifier = document.createElement('span');
+      identifier.textContent = `Session ${session.session_id.slice(0, 12)}…`;
+      details.append(identifier);
+      sessionRow.append(details, actionButton('Stop', busy || !connected,
+        () => showConfirmation('stop', {sessionId:session.session_id})));
+      row.append(sessionRow);
+    }
+    target.append(row);
+  }
+}
+
+async function refresh() {
+  if (refreshRunning) return;
+  refreshRunning = true;
+  try {
+    const state = await rpc('workspace.control.status');
+    el('available').textContent = state.connected ? state.totalAvailable ?? '—' : '—';
+    el('sessions').textContent = state.connected ? state.totalSessions : '—';
+    el('daemon').textContent = state.connected ? 'Online' : 'Offline';
+    const busy = Boolean(state.request);
+    renderWorkspaces(state.workspaces || [], busy, state.connected);
+    el('clear').disabled = !state.connected || !state.sessionCount || busy;
+    el('confirm').disabled = !state.connected || busy;
+    if (busy) {
+      el('message').textContent = 'Stopping sessions…';
+    } else if (state.lastResult) {
+      el('message').textContent = state.lastResult.ok
+        ? `Last action: stopped ${state.lastResult.stoppedCount} session(s).`
+        : `Last action failed: ${state.lastResult.error}`;
+      requestId = null;
+    }
+  } catch (error) {
+    el('clear').disabled = true;
+    el('confirm').disabled = true;
+    el('daemon').textContent = 'Offline';
+    el('available').textContent = '—';
+    el('sessions').textContent = '—';
+    el('message').textContent = error.message;
+  } finally {
+    refreshRunning = false;
+  }
+}
+
+el('clear').addEventListener('click', () => showConfirmation('stop-all'));
+el('cancel').addEventListener('click', () => {
+  confirming = false;
+  el('confirmation').hidden = true;
+  el('clear').hidden = false;
+  refresh();
+});
+el('confirm').addEventListener('click', async () => {
+  if (!confirming) return;
+  el('confirm').disabled = true;
+  try {
+    const result = await rpc('workspace.control.requestStop', chosen);
+    requestId = result.id;
+    el('message').textContent = 'Waiting for WebHelm daemon…';
+  } catch (error) {
+    el('message').textContent = error.message;
+  } finally {
+    confirming = false;
+    el('confirmation').hidden = true;
+    el('clear').hidden = false;
+    refresh();
+  }
+});
+
+refresh();
+setInterval(refresh, 1500);

package/runtime/extension/service-worker.mjs

@@ -1,54 +1,97 @@
 import { WorkspaceManager } from "./workspace-manager.mjs";
+import { ControlChannel } from "./control-channel.mjs";
+import { summarizeWorkspaces } from "./workspace-summary.mjs";
 
 const manager = new WorkspaceManager(chrome);
+const control = new ControlChannel(chrome);
 const closingWindowIds = new Set();
+let badgeTimer = null;
+
+async function refreshBadge() {
+  const state = await control.status();
+  const summary = summarizeWorkspaces((await manager.list()).workspaces, state.sessions);
+  const available = summary.totalAvailable;
+  await chrome.action.setBadgeText({
+    text: !state.connected ? "!" : available === null ? "?" : available > 99 ? "99+" : String(available),
+  });
+  await chrome.action.setBadgeBackgroundColor({
+    color: !state.connected || available === null ? "#667085"
+      : available === 0 ? "#A43145" : "#345FD5",
+  });
+  await chrome.action.setTitle({title: state.connected
+    ? `WebHelm — ${available === null ? "unknown" : available} available slot(s) across ${summary.workspaces.length} workspace(s)`
+    : "WebHelm — daemon offline or status stale"});
+}
 
+function scheduleBadge() {
+  if (badgeTimer !== null) clearTimeout(badgeTimer);
+  badgeTimer = setTimeout(() => {
+    badgeTimer = null;
+    refreshBadge().catch(error => console.warn("WebHelm badge update failed", error));
+  }, 100);
+}
 
-manager.restoreConfiguredWorkspaces().catch((error) => {
-  console.warn("Browser Workspace failed to restore configured workspaces", error);
+const BADGE_ALARM = "webhelm.badge-refresh";
+async function scheduleBadgeAlarm() {
+  await chrome.alarms.create(BADGE_ALARM, {periodInMinutes: 0.5});
+}
+chrome.alarms.onAlarm.addListener(alarm => {
+  if (alarm.name === BADGE_ALARM) scheduleBadge();
 });
+scheduleBadgeAlarm().catch(error => console.warn("WebHelm badge alarm failed", error));
 
-const RELEASE_ALL_MENU_ID = "browser-workspace.release-all";
-
-async function ensureContextMenus() {
-  try {
-    await chrome.contextMenus.remove(RELEASE_ALL_MENU_ID);
-  } catch {
-    // Menu does not exist yet.
-  }
-  chrome.contextMenus.create({
-    id: RELEASE_ALL_MENU_ID,
-    title: "Release all tabs",
-    contexts: ["action"],
-  });
+async function removeLegacyContextMenu() {
+  // Legacy release-all operated on extension tabs but did not stop Node Sessions.
+  try { await chrome.contextMenus.remove("browser-workspace.release-all"); }
+  catch { /* already absent */ }
 }
 
+manager.restoreConfiguredWorkspaces()
+  .then(scheduleBadge)
+  .catch(error => console.warn("WebHelm failed to restore configured workspaces", error));
+removeLegacyContextMenu().catch(() => {});
 chrome.runtime.onInstalled.addListener(() => {
-  ensureContextMenus().catch((error) => {
-    console.warn("Browser Workspace failed to create extension menu", error);
-  });
+  removeLegacyContextMenu().catch(() => {});
+  scheduleBadge();
 });
-
 chrome.runtime.onStartup.addListener(() => {
-  ensureContextMenus().catch((error) => {
-    console.warn("Browser Workspace failed to create extension menu", error);
-  });
-});
-
-ensureContextMenus().catch((error) => {
-  console.warn("Browser Workspace failed to initialize extension menu", error);
+  removeLegacyContextMenu().catch(() => {});
+  scheduleBadge();
 });
 
-chrome.contextMenus.onClicked.addListener((info) => {
-  if (info.menuItemId !== RELEASE_ALL_MENU_ID) return;
-  manager.releaseAll().catch((error) => {
-    console.warn("Browser Workspace failed to release all tabs", error);
-  });
-});
+async function controlRpc(method, args) {
+  switch (method) {
+    case "workspace.control.status": {
+      const state = await control.status();
+      const summary = summarizeWorkspaces((await manager.list()).workspaces, state.sessions);
+      return {...state,...summary};
+    }
+    case "workspace.control.requestStop":
+      return control.requestStop(args.action, args.sessionId, args.workspace);
+    case "workspace.control.heartbeat":
+      return control.heartbeat(args.sessions);
+    case "workspace.control.poll": {
+      const result = await control.poll(args.sessions);
+      scheduleBadge();
+      return result;
+    }
+    case "workspace.control.complete":
+      return control.complete(args.id, args.response);
+    default:
+      throw new Error("Unknown workspace control method");
+  }
+}
 
 globalThis.browserWorkspaceManagerRpc = async (request) => {
   try {
-    return { ok: true, result: await manager.rpc(request) };
+    const method = String(request?.method || "");
+    const result = method.startsWith("workspace.control.")
+      ? await controlRpc(method, request.args || {})
+      : await manager.rpc(request);
+    if (["workspace.acquireIdentity", "workspace.acquire", "workspace.release",
+         "workspace.releaseAll", "workspace.resize", "workspace.ensure",
+         "workspace.delete", "workspace.create"].includes(method)) scheduleBadge();
+    return {ok: true, result};
   } catch (error) {
     return {
       ok: false,
@@ -60,45 +103,53 @@ globalThis.browserWorkspaceManagerRpc = async (request) => {
   }
 };
 
-chrome.runtime.onMessage.addListener((request, _sender, sendResponse) => {
+chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+  if (request?.method?.startsWith("workspace.control.") &&
+      (sender?.url !== chrome.runtime.getURL("popup.html") ||
+        !["workspace.control.requestStop", "workspace.control.status"].includes(request.method))) {
+    sendResponse({ok:false,error:{message:"WebHelm control actions require the toolbar popup"}});
+    return false;
+  }
   globalThis.browserWorkspaceManagerRpc(request).then(sendResponse);
   return true;
 });
 
 chrome.tabs.onCreated.addListener((tab) => {
-  manager.inheritWorkspaceForCreatedTab(tab).catch((error) => {
-    console.warn("Browser Workspace failed to inherit child tab group", error);
+  manager.inheritWorkspaceForCreatedTab(tab).then(scheduleBadge).catch((error) => {
+    console.warn("WebHelm failed to inherit child tab group", error);
   });
 
   setTimeout(() => {
-    manager.reconcileCreatedTab(tab.id).catch((error) => {
+    manager.reconcileCreatedTab(tab.id).then(scheduleBadge).catch((error) => {
       if (!/No tab with id|Invalid tab ID/i.test(String(error?.message || error))) {
-        console.warn("Browser Workspace failed delayed created-tab reconciliation", error);
+        console.warn("WebHelm failed delayed created-tab reconciliation", error);
       }
     });
   }, 150);
 });
 
 chrome.webNavigation.onCreatedNavigationTarget.addListener((details) => {
-  manager.inheritNavigationTarget(details).catch((error) => {
-    console.warn("Browser Workspace failed to inherit navigation target", error);
+  manager.inheritNavigationTarget(details).then(scheduleBadge).catch((error) => {
+    console.warn("WebHelm failed to inherit navigation target", error);
   });
 });
 
 chrome.tabs.onUpdated.addListener((_tabId, changeInfo, tab) => {
+  if (changeInfo.url || Object.prototype.hasOwnProperty.call(changeInfo, "groupId")) scheduleBadge();
   if (!Object.prototype.hasOwnProperty.call(changeInfo, "groupId")) return;
-  manager.inheritWorkspaceForCreatedTab(tab).catch((error) => {
-    console.warn("Browser Workspace failed to reconcile tab group ownership", error);
+  manager.inheritWorkspaceForCreatedTab(tab).then(scheduleBadge).catch((error) => {
+    console.warn("WebHelm failed to reconcile tab group ownership", error);
   });
 });
 
 chrome.tabs.onActivated.addListener((activeInfo) => {
   manager.noteActivatedTab(activeInfo).catch((error) => {
-    console.warn("Browser Workspace failed to record active tab context", error);
+    console.warn("WebHelm failed to record active tab context", error);
   });
 });
 
 chrome.tabs.onRemoved.addListener((_tabId, removeInfo) => {
+  scheduleBadge();
   if (!removeInfo?.isWindowClosing) return;
   closingWindowIds.add(removeInfo.windowId);
   setTimeout(() => closingWindowIds.delete(removeInfo.windowId), 1000);
@@ -110,8 +161,8 @@ chrome.tabGroups.onRemoved.addListener((group) => {
   // reappear, and preserve persisted workspaces across normal window closes.
   setTimeout(() => {
     if (closingWindowIds.has(group.windowId)) return;
-    manager.removeDeletedGroup(group).catch((error) => {
-      console.warn("Browser Workspace failed to remove deleted workspace", error);
+    manager.removeDeletedGroup(group).then(scheduleBadge).catch((error) => {
+      console.warn("WebHelm failed to remove deleted workspace", error);
     });
   }, 100);
 });

package/runtime/extension/workspace-manager.mjs

@@ -42,11 +42,11 @@ export class WorkspaceManager {
   }
 
   idleUrl(workspace, slot) {
-    return this.chrome.runtime.getURL(`workspace.html?${queryString(workspace, slot)}`);
+    return this.chrome.runtime.getURL(`helm.html?${queryString(workspace, slot)}`);
   }
 
   identityTitle(tabId) {
-    return `__BW_TAB_${tabId}__`;
+    return `__WEBHELM_TAB_${tabId}__`;
   }
 
   identityUrl(workspace, tabId) {
@@ -55,14 +55,15 @@ export class WorkspaceManager {
       role: "lease",
       slot: String(tabId),
     }).toString();
-    return this.chrome.runtime.getURL(`workspace.html?${query}`);
+    return this.chrome.runtime.getURL(`helm.html?${query}`);
   }
 
   parseManagedUrl(url) {
     try {
       const parsed = new URL(url);
-      const own = new URL(this.chrome.runtime.getURL("workspace.html"));
-      if (parsed.origin !== own.origin || parsed.pathname !== own.pathname) return null;
+      const own = new URL(this.chrome.runtime.getURL("helm.html"));
+      if (parsed.origin !== own.origin ||
+          !["/helm.html", "/workspace.html"].includes(parsed.pathname)) return null;
       return {
         workspace: parsed.searchParams.get("workspace") || "",
         role: parsed.searchParams.get("role") || "",
@@ -466,6 +467,44 @@ export class WorkspaceManager {
     return { workspaces: result };
   }
 
+  // The legacy default group is only renamed after all its tabs return idle.
+  // Preserve configured custom workspaces, old leased tabs and Chrome tab IDs.
+  async migrateDefaultWorkspace(activeLegacySessions = 0) {
+    const oldName = "Harness", newName = "WebHelm";
+    const config = await this.loadConfig();
+    if (!config.workspaces[oldName]) return {name: newName, migrated: false};
+    if (config.workspaces[newName]) return {name: newName, migrated: false, legacyPreserved: true};
+    if (activeLegacySessions > 0) return {name: oldName, deferred: "active-sessions"};
+    const group = await this.workspaceGroup(oldName);
+    const tabs = group ? await this.groupTabs(group.id) : [];
+    if (group && this.classify(oldName, tabs).leased.length)
+      return {name: oldName, deferred: "leased-tabs"};
+
+    // URL ownership and group identity change together. If navigation fails,
+    // restore both before retrying so no lease is silently adopted.
+    const updated = [];
+    try {
+      // Mark existing legacy tabs as owned before their URLs change. Chrome
+      // can emit grouping callbacks mid-migration.
+      for (const tab of tabs) this.markOwned(tab.id);
+      if (group) await this.chrome.tabGroups.update(group.id, {title: newName});
+      for (const tab of tabs) {
+        await this.chrome.tabs.update(tab.id, {url: this.idleUrl(newName, tab.id), active: false});
+        updated.push(tab);
+      }
+      config.workspaces[newName] = config.workspaces[oldName];
+      delete config.workspaces[oldName];
+      await this.saveConfig(config);
+      return {name: newName, migrated: true, migratedTabs: updated.length};
+    } catch(error) {
+      if (group) await this.chrome.tabGroups.update(group.id, {title: oldName}).catch(() => {});
+      for (const tab of updated) {
+        await this.chrome.tabs.update(tab.id,{url: tab.url,active:false}).catch(() => {});
+      }
+      throw error;
+    }
+  }
+
   async ensure(name, defaultPoolSize = 8) {
     const normalizedName = normalizeWorkspaceName(name);
     const { entry } = await this.configuredWorkspace(normalizedName);
@@ -544,7 +583,7 @@ export class WorkspaceManager {
         active: false,
       });
       // Group reconciliation can fire before the extension idle URL is visible.
-      // Mark ownership first so a legitimate Browser Harness lease is not ejected.
+      // Mark ownership first so a legitimate WebHelm lease is not ejected.
       this.markOwned(tab.id);
       await this.chrome.tabs.group({ groupId: ready.groupId, tabIds: [tab.id] });
       tab = await this.waitForIdleTab(tab.id, normalizedName);
@@ -650,6 +689,7 @@ export class WorkspaceManager {
     if (method === "workspace.ensure") return await this.ensure(args.name, args.poolSize);
     if (method === "workspace.status") return await this.status(args.name);
     if (method === "workspace.list") return await this.list();
+    if (method === "workspace.migrateDefault") return await this.migrateDefaultWorkspace(Number(args.activeLegacySessions || 0));
     if (method === "workspace.acquire") return await this.acquire(args.name, args.url);
     if (method === "workspace.acquireIdentity") return await this.acquireIdentity(args.name);
     if (method === "workspace.release") return await this.release(args.name, args.tabId);

package/runtime/extension/workspace-page.mjs

@@ -1,7 +1,29 @@
 const params = new URLSearchParams(location.search);
+const workspace = params.get("workspace") || "";
 const role = params.get("role") || "";
 const slot = params.get("slot") || "";
+const validSlot = /^\d+$/.test(slot);
 
-document.title = role === "lease" && /^\d+$/.test(slot)
-  ? `__BW_TAB_${slot}__`
-  : "Browser Workspace";
+// Keep this exact lease title: WebHelm's tab identity protocol depends on it.
+document.title = role === "lease" && validSlot
+  ? `${location.pathname.endsWith("/workspace.html") ? "__BW_TAB_" : "__WEBHELM_TAB_"}${slot}__`
+  : role === "idle" && workspace
+    ? "WebHelm · Idle"
+    : "WebHelm";
+
+const setText = (id, value) => {
+  const element = document.getElementById(id);
+  if (element) element.textContent = value;
+};
+
+setText("workspace-name", workspace || "Not assigned");
+setText("slot-number", validSlot ? slot : "—");
+
+if (role === "idle" && workspace) {
+  setText("status-label", "Idle · Awaiting next task");
+  setText("description", "This tab is in the WebHelm pool and will be reused automatically when a task needs it.");
+  setText("help-text", "No action required. Leave this tab open. This status describes the tab, not daemon connectivity.");
+} else if (role === "lease" && validSlot && workspace) {
+  setText("status-label", "Reserved for a task");
+  setText("description", "WebHelm has assigned this tab to a browser session.");
+}

package/runtime/extension/workspace-summary.mjs

@@ -0,0 +1,35 @@
+export function summarizeWorkspaces(workspaces, sessions = []) {
+  if (!Array.isArray(workspaces)) throw new Error('Workspace list is invalid');
+  const configured = workspaces.map(workspace => ({
+    name: workspace.name,
+    initialized: Boolean(workspace.initialized),
+    poolSize: Number.isInteger(workspace.poolSize) ? workspace.poolSize : null,
+    idleTabs: workspace.initialized ? workspace.idle : null,
+    leasedTabs: workspace.initialized ? workspace.leased : null,
+    available: workspace.initialized
+      ? Math.max(0, workspace.poolSize - workspace.leased) : null,
+    sessions: sessions.filter(session => session.workspace === workspace.name),
+    reason: workspace.reason || null,
+  }));
+  const configuredNames = new Set(configured.map(workspace => workspace.name));
+  // A running Session can outlive a deleted workspace group. Do not hide it.
+  for (const session of sessions) {
+    if (configuredNames.has(session.workspace)) continue;
+    configuredNames.add(session.workspace);
+    configured.push({
+      name: session.workspace, initialized: false, poolSize: null, idleTabs: null,
+      leasedTabs: null, available: null, sessions: sessions.filter(s => s.workspace === session.workspace),
+      reason: 'not-configured',
+    });
+  }
+  const known = configured.filter(workspace => workspace.initialized && workspace.available !== null);
+  return {
+    workspaces: configured,
+    totalAvailable: configured.length && known.length === configured.length
+      ? known.reduce((total, workspace) => total + workspace.available, 0) : null,
+    totalPhysicalIdle: known.length === configured.length
+      ? known.reduce((total, workspace) => total + workspace.idleTabs, 0) : null,
+    totalSessions: sessions.length,
+    partial: known.length !== configured.length,
+  };
+}

package/runtime/extension/workspace.html

@@ -1,8 +1,11 @@
 <!doctype html>
+<html lang="en">
+<head>
 <meta charset="utf-8">
-<title>Browser Workspace</title>
+<title>WebHelm · Legacy Tab</title>
 <script type="module" src="workspace-page.mjs"></script>
-<style>
-  body { font-family: system-ui, sans-serif; margin: 24px; }
-</style>
-<p>This tab belongs to a managed Browser Workspace pool.</p>
+</head>
+<body>
+<p>This is a legacy WebHelm tab. It will return to the managed pool when its session ends.</p>
+</body>
+</html>

package/runtime/extension-manager.mjs

@@ -8,7 +8,11 @@ import {LOCAL_ROOT} from './config-paths.mjs';
 export const EXTENSION_ID='kkkpgmhpoeceojalkpfdidffdfnlgdog';
 export const EXTENSION_HOME=path.resolve(process.env.WEBHELM_EXTENSION_HOME || path.join(LOCAL_ROOT,'extension'));
 const SOURCE=fileURLToPath(new URL('./extension/',import.meta.url));
-const FILES=['manifest.json','service-worker.mjs','workspace-manager.mjs','workspace.html','workspace-page.mjs'];
+const FILES=[
+  'manifest.json','service-worker.mjs','workspace-manager.mjs','workspace.html','helm.html','workspace-page.mjs',
+  'control-channel.mjs','workspace-summary.mjs','popup.html','popup.mjs',
+  ...[16,32,48,128].map(size => `icons/webhelm-${size}.png`),
+];
 
 function manifest(dir){
   const data=JSON.parse(fs.readFileSync(path.join(dir,'manifest.json'),'utf8'));
@@ -19,9 +23,20 @@ function manifest(dir){
   return data;
 }
 export const extensionVersion=manifest(SOURCE).version;
+function canonicalPath(value) {
+  try { return fs.realpathSync(value || ''); }
+  catch { return path.resolve(value || ''); }
+}
+
+function listRelativeFiles(dir, prefix='') {
+  return fs.readdirSync(path.join(dir,prefix),{withFileTypes:true}).flatMap(entry => {
+    const relative=path.join(prefix,entry.name);
+    return entry.isDirectory() ? listRelativeFiles(dir,relative) : [relative];
+  });
+}
 function identical(dir){
   return fs.existsSync(path.join(dir,'manifest.json'))&&
-    JSON.stringify(fs.readdirSync(dir).sort())===JSON.stringify([...FILES].sort())&&
+    JSON.stringify(listRelativeFiles(dir).sort())===JSON.stringify([...FILES].sort())&&
     FILES.every(name=>fs.readFileSync(path.join(dir,name)).equals(fs.readFileSync(path.join(SOURCE,name))));
 }
 // Actions checkout contains this self-managed directory, but Git must never publish it.
@@ -44,7 +59,10 @@ export function stageExtension(dir=EXTENSION_HOME){
   const stage=fs.mkdtempSync(path.join(root,'.webhelm-extension-stage-'));
   let backup;
   try {
-    for(const filename of FILES)fs.copyFileSync(path.join(SOURCE,filename),path.join(stage,filename));
+    for(const filename of FILES){
+      fs.mkdirSync(path.dirname(path.join(stage,filename)),{recursive:true});
+      fs.copyFileSync(path.join(SOURCE,filename),path.join(stage,filename));
+    }
     if(!identical(stage))throw Error('WebHelm extension staged content mismatch');
     if(fs.existsSync(target)){
       backup=path.join(root,`.webhelm-extension-backup-${process.pid}-${crypto.randomBytes(4).toString('hex')}`);
@@ -67,7 +85,7 @@ export async function ensureExtensionLoaded(browser, {skip=false,extensionDir=EX
   try{
     const state=await browser.send('Extensions.getExtensions');
     modern=true;installed=state.extensions?.find(e=>e.id===EXTENSION_ID);
-    if(!installed || !installed.enabled || installed.version!==version || path.resolve(installed.path||'')!==dir){
+    if(!installed || !installed.enabled || installed.version!==version || canonicalPath(installed.path)!==canonicalPath(dir)){
       if(!allowUpdate)throw Error('Extension reload deferred: active browser Sessions must finish');
       const loaded=await browser.send('Extensions.loadUnpacked',{path:dir});
       if(loaded.id!==EXTENSION_ID)throw Error('Chrome loaded an unexpected extension ID');
@@ -83,7 +101,7 @@ export async function ensureExtensionLoaded(browser, {skip=false,extensionDir=EX
   let target=targetInfos.find(t=>t.type==='service_worker'&&t.url.startsWith(prefix));
   let temporary=false;
   if(!target){
-    const created=await browser.send('Target.createTarget',{url:`${prefix}workspace.html?webhelm_wakeup=1`,background:true});
+    const created=await browser.send('Target.createTarget',{url:`${prefix}helm.html?webhelm_wakeup=1`,background:true});
     target={targetId:created.targetId};temporary=true;
   }
   let attached;

package/runtime/node-daemon.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { invokePlatformAction } from './platforms.mjs';
 import { ChatGPTQueue } from './chatgpt/chatgpt-queue.mjs';
 import { idleUrlFromIdentity, sameIdleUrl, staleSession } from './session-lifecycle.mjs';
+import { stopMatchingSessions } from './session-control.mjs';
 import { ensureManagedChrome } from './chrome.mjs';
 import { ensureExtensionLoaded } from './extension-manager.mjs';
 import { createManagedChromeGuard } from './managed-chrome-guard.mjs';
@@ -70,8 +71,9 @@ async function acquireIdentityLease(session) {
 }
 
 async function connectBrowser() {
-  if(browserWs && !browserWs.closed)return browserWs;
+  // Never expose a CDP connection before Extension initialization finishes.
   if(connectingBrowser)return connectingBrowser;
+  if(browserWs && !browserWs.closed)return browserWs;
   connectingBrowser=(async()=>{
     managedChrome=await ensureManagedChrome();
     const endpoint=managedChrome.endpoint;
@@ -122,9 +124,18 @@ async function connectBrowser() {
   finally{connectingBrowser=null;}
 }
 
-// The daemon owns both the managed Chrome process and the default Harness
+// The daemon owns both the managed Chrome process and the default WebHelm
 // group. Chrome auto-updates can terminate the browser while the Node daemon
 // survives; an RPC-only health check cannot recover that loss.
+const defaultWorkspaceMutex=new Mutex();
+async function defaultWorkspaceName() {
+  if (process.env.WEBHELM_NO_PROFILE_EXTENSION_PROBE === '1') return 'WebHelm';
+  return defaultWorkspaceMutex.run(async()=>{
+    const activeLegacySessions=[...sessions.values()].filter(s=>s.workspace==='Harness').length;
+    const result=await extensionCall(null,'workspace.migrateDefault',{activeLegacySessions});
+    return result.name;
+  });
+}
 async function guardManagedChrome(){
   if(shuttingDown || process.env.WEBHELM_CDP_URL || process.env.WEBHELM_NO_PROFILE_EXTENSION_PROBE==='1')
     return {skipped:true};
@@ -138,17 +149,18 @@ async function guardManagedChrome(){
   managedChrome=actual;
   // Session leasing also creates missing workspaces. Serialize this short
   // identity transaction with session start so one group is created, not two.
-  const state=await leaseMutex('Harness').run(async()=>{
+  const name=await defaultWorkspaceName();
+  const state=await leaseMutex(name).run(async()=>{
     let current;
-    try {current=await extensionCall(null,'workspace.status',{name:'Harness'});}
+    try {current=await extensionCall(null,'workspace.status',{name});}
     catch(error){
       if(sessions.size)throw error; // Never hot reload an Extension used by active Sessions.
       const browser=await connectBrowser();
       await ensureExtensionLoaded(browser);
-      current=await extensionCall(null,'workspace.status',{name:'Harness'});
+      current=await extensionCall(null,'workspace.status',{name});
     }
     if(!current?.initialized || !Number.isInteger(current.physicalTabs) || current.physicalTabs<1)
-      current=await extensionCall(null,'workspace.ensure',{name:'Harness'});
+      current=await extensionCall(null,'workspace.ensure',{name});
     return current;
   });
   return {managed_chrome_pid:actual.pid,group_id:state.groupId,physical_tabs:state.physicalTabs};
@@ -282,7 +294,13 @@ async function evaluateExtension(browser,sessionId,expression){
   if(!value?.ok)throw Error(value?.error?.message||'workspace extension RPC failed');
   return value.result;
 }
-async function extensionCall(_session,method,args={}) {
+// Extension service-worker RPC uses one debugger attachment and must not
+// race concurrent capacity polls, migration and browser Session allocation.
+const extensionRpcMutex=new Mutex();
+async function extensionCall(session,method,args={}) {
+  return extensionRpcMutex.run(()=>extensionCallSerialized(session,method,args));
+}
+async function extensionCallSerialized(_session,method,args={}) {
   const browser=await connectBrowser();
   const request=JSON.stringify({method,args});
   const {targetInfos=[]}=await browser.send('Target.getTargets');
@@ -297,7 +315,7 @@ async function extensionCall(_session,method,args={}) {
       `globalThis.browserWorkspaceManagerRpc(${request})`);
     }catch(error){debuggerSession=null;throw error;}
   }
-  const page=targetInfos.find(t=>t.type==='page'&&t.url.startsWith(EXTENSION_PREFIX)&&t.url.includes('/workspace.html'));
+  const page=targetInfos.find(t=>t.type==='page'&&t.url.startsWith(EXTENSION_PREFIX)&&(t.url.includes('/workspace.html')||t.url.includes('/helm.html')));
   if(page){
     const {sessionId}=await browser.send('Target.attachToTarget',{targetId:page.targetId,flatten:true});
     try{return await evaluateExtension(browser,sessionId,`chrome.runtime.sendMessage(${request})`);}
@@ -307,7 +325,7 @@ async function extensionCall(_session,method,args={}) {
   // Wake a suspended MV3 worker from a temporary background extension page.
   // Only this temporary target is closed; no user tab is reused or modified.
   const {targetId}=await browser.send('Target.createTarget',{
-    url:`${EXTENSION_PREFIX}workspace.html?webhelm_wakeup=1`,background:true});
+    url:`${EXTENSION_PREFIX}helm.html?webhelm_wakeup=1`,background:true});
   let sessionId;
   try{
     ({sessionId}=await browser.send('Target.attachToTarget',{targetId,flatten:true}));
@@ -333,7 +351,7 @@ function jsonSafe(value){try{JSON.stringify(value);return {value}}catch{return {
 async function createSession(req={}) {
   const browser=await connectBrowser();
   const sid=crypto.randomBytes(8).toString('hex');
-  const s={session_id:sid, workspace:req.workspace||'Harness', targetId:null,
+  const s={session_id:sid, workspace:req.workspace||await defaultWorkspaceName(), targetId:null,
     rootTargetId:null, workspaceSupported:false,targets:new Set(), attachments:new Map(), eventDisposers:new Map(),
     leasedTabs:new Map(), idleUrls:new Map(), mutex:new Mutex(), events:[], namespace:null,context:null,
     inFlight:0, closing:false, last_used_at:Date.now()};
@@ -376,10 +394,10 @@ async function extensionSupported() {
   if(!installed)return false;
   let error;
   for(let attempt=0;attempt<3;attempt++){
-    try{await extensionCall({workspace:'Harness'},'workspace.list');return true;}
+    try{await extensionCall({workspace:'WebHelm'},'workspace.list');return true;}
     catch(e){error=e;if(attempt<2)await delay(150);}
   }
-  throw Error(`Browser Workspace extension installed but RPC unavailable: ${error?.message||'unknown'}`);
+  throw Error(`WebHelm extension installed but RPC unavailable: ${error?.message||'unknown'}`);
 }
 
 async function execute(req) {
@@ -431,7 +449,8 @@ async function closeSessionOwned(s){
   s.closing=true;
   let release_error=null;
   try {
-    const count=s.targets.size;
+    const returnedTabs=s.leasedTabs.size;
+    const closedChildTabs=s.targets.size - returnedTabs;
     await s.mutex.run(async()=>{
       const browser=await connectBrowser();
       // Return managed tabs to their original Extension pool; keep their CDP targets.
@@ -449,7 +468,7 @@ async function closeSessionOwned(s){
       s.targets.clear();s.attachments.clear();s.leasedTabs.clear();s.idleUrls.clear();s.eventDisposers.clear();
       sessions.delete(s.session_id);
     });
-    return {session_id:s.session_id,workspace:s.workspace,target_id:s.rootTargetId,closed_tabs:count,returned_to_idle:true,release_error};
+    return {session_id:s.session_id,workspace:s.workspace,target_id:s.rootTargetId,closed_tabs:closedChildTabs,returned_tabs:returnedTabs,returned_to_idle:true,release_error};
   }catch(error){
     s.closing=false; // Keep ownership for a future retry; never reassign on unconfirmed navigation.
     throw error;
@@ -488,7 +507,7 @@ function heartbeatSession(sid){
   return {session_id:sid,alive:true,last_used_at:s.last_used_at};
 }
 
-async function workspaceOp(req){const h=makeHelpers({workspace:req.name||'Harness',targetId:'',targets:new Set(),attachments:new Map()});if(req.op==='workspace-create')return h.workspace_create(req.name,req.pool_size);if(req.op==='workspace-delete')return h.workspace_delete(req.name,req.force);throw Error(`unknown op: ${req.op}`)}
+async function workspaceOp(req){const h=makeHelpers({workspace:req.name||await defaultWorkspaceName(),targetId:'',targets:new Set(),attachments:new Map()});if(req.op==='workspace-create')return h.workspace_create(req.name,req.pool_size);if(req.op==='workspace-delete')return h.workspace_delete(req.name,req.force);throw Error(`unknown op: ${req.op}`)}
 function getChatGPTQueue() {
   if (chatgptQueue) return chatgptQueue;
   chatgptQueue = new ChatGPTQueue({
@@ -505,7 +524,7 @@ function getChatGPTQueue() {
 }
 
 async function workspaceCapacity(req={}) {
-  const name=typeof req.workspace==='string'&&req.workspace.trim()?req.workspace.trim():'Harness';
+  const name=typeof req.workspace==='string'&&req.workspace.trim()?req.workspace.trim():await defaultWorkspaceName();
   const observedAt=new Date().toISOString();
   try {
     const state=await extensionCall(null,'workspace.status',{name});
@@ -523,6 +542,58 @@ async function workspaceCapacity(req={}) {
   }
 }
 
+// The popup never runs commands. The daemon is the only actor that consumes
+// Extension control requests, over the already-authenticated CDP channel.
+let controlPollActive = false;
+function visibleSessions() {
+  return [...sessions.values()].map(s => ({
+    session_id:s.session_id,workspace:s.workspace,last_used_at:s.last_used_at,
+  }));
+}
+async function pollExtensionControl() {
+  if (controlPollActive || shuttingDown) return;
+  controlPollActive = true;
+  try {
+    const pendingAction = await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions()});
+    if (!pendingAction) return;
+    const {id,action,sessionId} = pendingAction;
+    // Keep the status panel fresh while a lengthy Session stop waits for
+    // browser navigation or an in-flight task.
+    const controlHeartbeat=setInterval(()=>{
+      extensionCall(null,'workspace.control.heartbeat',{sessions:visibleSessions()})
+        .catch(error=>console.warn(`WebHelm control heartbeat: ${error.message}`));
+    },3000);
+    let response;
+    try {
+      if (action === 'stop-all') {
+        response = await stopAllSessions();
+      } else if (action === 'stop-workspace') {
+        response = await stopWorkspaceSessions(pendingAction.workspace);
+      } else if (action === 'stop') {
+        response = {ok:true,stopped:await stopSession(sessionId)};
+      } else {
+        throw Error('Unknown extension control action');
+      }
+    } catch(error) {
+      response = {ok:false,error:String(error?.message||error)};
+    } finally {
+      clearInterval(controlHeartbeat);
+    }
+    await extensionCall(null,'workspace.control.complete',{id,response});
+    await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions()});
+  } catch(error) {
+    console.warn(`WebHelm extension control sync failed: ${error.message}`);
+  } finally {
+    controlPollActive = false;
+  }
+}
+function stopWorkspaceSessions(workspace) {
+  return stopMatchingSessions(sessions, session => session.workspace === workspace, stopSession);
+}
+function stopAllSessions() {
+  return stopMatchingSessions(sessions, () => true, stopSession);
+}
+
 /** Emit one canonical machine-readable action receipt as the final stdout line. */
 export function actionOutput(logs, value) {
   const entries=Array.isArray(logs)?logs:[];
@@ -575,7 +646,7 @@ async function runPlatform(req) {
     self_heal_capable:!auto,result};
 }
 
-export async function handle(req){switch(req.op){case'ping':return {ok:true,pid:process.pid,version:PACKAGE_VERSION,queue_paused:process.env.WEBHELM_CHATGPT_QUEUE_PAUSED==='1',session_count:sessions.size,managed_chrome:managedChrome||{profile_dir:PROFILE_DIR, endpoint:process.env.WEBHELM_CDP_URL||'http://127.0.0.1:9222',reused:true},chrome_guard:managedChromeGuard.status()};case'guard-check':{let status=await managedChromeGuard.tick();for(let retry=0;retry<6 && status.status!=='healthy' && !status.skipped;retry++){await delay(800);status=await managedChromeGuard.tick();}if(status.status!=='healthy' && !status.skipped)throw Error(`WebHelm Chrome health degraded: ${status.error||status.status}`);return {ok:true,chrome_guard:status};}case'heartbeat':return heartbeatSession(req.session_id);case'list':return {session_count:sessions.size,sessions:[...sessions.values()].map(s=>({session_id:s.session_id,workspace:s.workspace,target_id:s.targetId,last_used_at:s.last_used_at}))};case'start':return createSession(req);case'exec':return execute(req);case'stop':return stopSession(req.session_id);case'stop-all':{const stopped=[];for(const id of [...sessions.keys()])stopped.push(await stopSession(id));return {stopped_count:stopped.length,error_count:0,stopped,errors:[]}}case'capacity':return workspaceCapacity(req);case'workspace-create':case'workspace-delete':return workspaceOp(req);case'chatgpt-new-turn-enqueue':return getChatGPTQueue().enqueue(req.config);case'platform-run':return runPlatform(req);default:throw Error(`unknown op: ${req.op}`)}}
+export async function handle(req){switch(req.op){case'ping':return {ok:true,pid:process.pid,version:PACKAGE_VERSION,queue_paused:process.env.WEBHELM_CHATGPT_QUEUE_PAUSED==='1',session_count:sessions.size,managed_chrome:managedChrome||{profile_dir:PROFILE_DIR, endpoint:process.env.WEBHELM_CDP_URL||'http://127.0.0.1:9222',reused:true},chrome_guard:managedChromeGuard.status()};case'guard-check':{let status=await managedChromeGuard.tick();for(let retry=0;retry<6 && status.status!=='healthy' && !status.skipped;retry++){await delay(800);status=await managedChromeGuard.tick();}if(status.status!=='healthy' && !status.skipped)throw Error(`WebHelm Chrome health degraded: ${status.error||status.status}`);return {ok:true,chrome_guard:status};}case'heartbeat':return heartbeatSession(req.session_id);case'list':return {session_count:sessions.size,sessions:[...sessions.values()].map(s=>({session_id:s.session_id,workspace:s.workspace,target_id:s.targetId,last_used_at:s.last_used_at}))};case'start':return createSession(req);case'exec':return execute(req);case'stop':return stopSession(req.session_id);case'stop-all':return stopAllSessions();case'capacity':return workspaceCapacity(req);case'workspace-create':case'workspace-delete':return workspaceOp(req);case'chatgpt-new-turn-enqueue':return getChatGPTQueue().enqueue(req.config);case'platform-run':return runPlatform(req);default:throw Error(`unknown op: ${req.op}`)}}
 function serve(conn) {
   let buffer = '';
   conn.setEncoding('utf8');
@@ -593,7 +664,10 @@ function serve(conn) {
   });
 }
 
-async function main(){fs.mkdirSync(RUNTIME,{recursive:true,mode:0o700});let lockfd;try{lockfd=fs.openSync(LOCK,'wx',0o600);fs.writeFileSync(lockfd,String(process.pid))}catch{throw Error(`Node pilot lock exists: ${LOCK}`)}if(fs.existsSync(SOCKET)){try{const c=net.createConnection(SOCKET);await new Promise((res,rej)=>{c.once('connect',res);c.once('error',rej)});c.destroy();fs.closeSync(lockfd);fs.unlinkSync(LOCK);throw Error(`Node daemon socket already active: ${SOCKET}`)}catch(e){if(e.message.includes('already active'))throw e;fs.unlinkSync(SOCKET)}}socket=net.createServer(serve);await new Promise((res,rej)=>socket.listen(SOCKET,res).once('error',rej));fs.chmodSync(SOCKET,0o600);connectBrowser().catch(()=>{});managedChromeGuard.start();getChatGPTQueue();const cleanup=async()=>{if(shuttingDown)return;shuttingDown=true;managedChromeGuard.stop();if(chatgptQueue)await chatgptQueue.shutdown().catch(()=>{});await handle({op:'stop-all'}).catch(()=>{});socket?.close();try{if(fs.existsSync(SOCKET))fs.unlinkSync(SOCKET)}catch{}try{fs.closeSync(lockfd);fs.unlinkSync(LOCK)}catch{}process.exit(0)};process.on('SIGTERM',cleanup);process.on('SIGINT',cleanup)}
+async function main(){fs.mkdirSync(RUNTIME,{recursive:true,mode:0o700});let lockfd;try{lockfd=fs.openSync(LOCK,'wx',0o600);fs.writeFileSync(lockfd,String(process.pid))}catch{throw Error(`Node pilot lock exists: ${LOCK}`)}if(fs.existsSync(SOCKET)){try{const c=net.createConnection(SOCKET);await new Promise((res,rej)=>{c.once('connect',res);c.once('error',rej)});c.destroy();fs.closeSync(lockfd);fs.unlinkSync(LOCK);throw Error(`Node daemon socket already active: ${SOCKET}`)}catch(e){if(e.message.includes('already active'))throw e;fs.unlinkSync(SOCKET)}}socket=net.createServer(serve);await new Promise((res,rej)=>socket.listen(SOCKET,res).once('error',rej));fs.chmodSync(SOCKET,0o600);connectBrowser().catch(()=>{});managedChromeGuard.start();getChatGPTQueue();
+  const controlTimer=setInterval(()=>pollExtensionControl(),3000);
+  pollExtensionControl().catch(()=>{});
+  const cleanup=async()=>{if(shuttingDown)return;shuttingDown=true;clearInterval(controlTimer);managedChromeGuard.stop();if(chatgptQueue)await chatgptQueue.shutdown().catch(()=>{});await handle({op:'stop-all'}).catch(()=>{});socket?.close();try{if(fs.existsSync(SOCKET))fs.unlinkSync(SOCKET)}catch{}try{fs.closeSync(lockfd);fs.unlinkSync(LOCK)}catch{}process.exit(0)};process.on('SIGTERM',cleanup);process.on('SIGINT',cleanup)}
 async function request(payload,ensure=true){if(ensure)await ensureDaemon();return new Promise((resolve,reject)=>{const c=net.createConnection(SOCKET);let data='';c.setEncoding('utf8');c.on('connect',()=>c.write(JSON.stringify(payload)+'\n'));c.on('data',x=>{data+=x;if(!data.includes('\n'))return;c.end();try{const r=JSON.parse(data);r.error?reject(Error(r.error)):resolve(r)}catch(e){reject(e)}});c.on('error',reject)})}
 export async function ensureDaemon(){try{const p=await request({op:'ping'},false);if(p.ok)return p}catch{}if(!process.env.WEBHELM_CDP_URL)requireMigratedConfig();fs.mkdirSync(RUNTIME,{recursive:true,mode:0o700});if(fs.existsSync(LOCK)){let owner=0;try{owner=Number(fs.readFileSync(LOCK,'utf8').trim())}catch{};let alive=false;if(owner>0)try{process.kill(owner,0);alive=true}catch{};if(alive)throw Error(`daemon owner lock exists but socket is unreachable; refusing duplicate startup (${LOCK})`);fs.unlinkSync(LOCK)}const child=await import('node:child_process');const log=fs.openSync(path.join(RUNTIME,'session-node.log'),'a');child.spawn(process.execPath,[fileURLToPath(import.meta.url),'daemon'],{detached:true,stdio:['ignore',log,log],env:process.env}).unref();for(let i=0;i<100;i++){await delay(100);try{const p=await request({op:'ping'},false);if(p.ok)return p}catch{}}throw Error(`WebHelm Node daemon did not start; see ${path.join(RUNTIME,'session-node.log')}`)}
 if(process.argv[2]==='daemon')main().catch(e=>{console.error(e);process.exit(1)});

package/runtime/session-control.mjs

@@ -0,0 +1,13 @@
+// A Session is stopped by its daemon owner, never by direct tab mutation.
+export async function stopMatchingSessions(entries, predicate, stopSession) {
+  const stopped = [], errors = [];
+  for (const [sessionId, session] of [...entries]) {
+    if (!predicate(session)) continue;
+    try { stopped.push(await stopSession(sessionId)); }
+    catch (error) {
+      errors.push({session_id:sessionId,error:String(error?.message || error)});
+    }
+  }
+  return {ok:errors.length === 0,stopped_count:stopped.length,
+    error_count:errors.length,stopped,errors};
+}

package/runtime/session-lifecycle.mjs

@@ -8,7 +8,7 @@ export function staleSession(session, now = Date.now(), ttl = SESSION_IDLE_MS) {
 
 export function idleUrlFromIdentity(identityUrl, tabId) {
   const url = new URL(identityUrl);
-  if (url.protocol !== 'chrome-extension:' || !url.pathname.endsWith('/workspace.html')) {
+  if (url.protocol !== 'chrome-extension:' || !['/workspace.html','/helm.html'].includes(url.pathname)) {
     throw new Error('invalid extension identity URL');
   }
   url.searchParams.set('role', 'idle');