webhelm 1.0.20 → 1.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webhelm",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Agent browser automation in a visible managed Chrome with persistent JavaScript sessions",
   "type": "module",
   "bin": {

package/runtime/chatgpt/chatgpt-queue.mjs

@@ -60,11 +60,18 @@ const chatgptQueuePolicy = {
     db.prepare("UPDATE turns SET state='CHECKING',lease_owner=?,lease_until=?,attempts=attempts+1 WHERE id=?").run(owner,now+leaseSeconds,row.id);
     return this.one(db, "SELECT * FROM turns WHERE id=?", row.id);
   },
+  // A queue adapter registers a display description; Actions stay unaware of queues.
+  describe(row) {
+    const firstLine = row.message.split(/\r?\n/, 1)[0].replace(/\s+/g, ' ').trim();
+    const title = firstLine ? (firstLine.length > 52 ? `${firstLine.slice(0, 51)}…` : firstLine) : 'ChatGPT message';
+    const prefix = row.project_id ? `/g/${encodeURIComponent(row.project_id)}` : '';
+    return {platform:'ChatGPT', title, url:`https://chatgpt.com${prefix}/c/${encodeURIComponent(row.thread_id)}`};
+  },
   cancel(db, id) {
     const row=this.one(db, "SELECT * FROM turns WHERE id=?", id);
     if (!row) return {ok:false,queue_id:id,error:"queue item not found"};
-    if (row.state!=="QUEUED") return {ok:false,queue_id:id,state:row.state,error:"only queued items can be cancelled"};
-    db.prepare("UPDATE turns SET state='CANCELLED',lease_owner=NULL,lease_until=NULL WHERE id=? AND state='QUEUED'").run(id);
+    if (!["QUEUED","WAITING","BLOCKED","UNCERTAIN"].includes(row.state)) return {ok:false,queue_id:id,state:row.state,error:"cannot remove a running or completed item"};
+    db.prepare("UPDATE turns SET state='CANCELLED',lease_owner=NULL,lease_until=NULL WHERE id=? AND state IN ('QUEUED','WAITING','BLOCKED','UNCERTAIN')").run(id);
     return {ok:true,queue_id:id,state:"CANCELLED"};
   },
   list(db) {

package/runtime/durable-queue-core.mjs

@@ -42,7 +42,22 @@ export class DurableQueueCore {
   cancel(id) {
     return this._transaction(() => this.policy.cancel(this.db, id));
   }
-  list() { return this.policy.list(this.db); }
+  list() {
+    const result = this.policy.list(this.db);
+    if (typeof this.policy.describe !== 'function') return result;
+    const rows = new Map(this.rows().map(row => [row.id, row]));
+    return {...result, items: result.items.map(item => {
+      const row = rows.get(item.id);
+      const description = row && this.policy.describe(row);
+      if (!description) return item;
+      return {
+        ...item,
+        ...(description.title !== undefined ? {title:description.title} : {}),
+        ...(description.url !== undefined ? {url:description.url} : {}),
+        ...(description.platform !== undefined ? {platform:description.platform} : {}),
+      };
+    })};
+  }
   start() {
     if (this.started) return this;
     this.started = true;

package/runtime/extension/control-channel.mjs

@@ -85,7 +85,7 @@ export class ControlChannel {
       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');
-      if (!(state.queue || []).some(item => item.id === queueId && item.state === 'QUEUED'))
+      if (!(state.queue || []).some(item => item.id === queueId && ['QUEUED','WAITING','BLOCKED','UNCERTAIN'].includes(item.state)))
         throw new Error('Queue item is no longer cancellable');
       const request = {id:this.makeId(), action:'queue-cancel', queueId, state:'pending', createdAt:this.now()};
       await this.save({...state, request, lastResult:null});

package/runtime/extension/control-rpc.mjs

@@ -1,10 +1,54 @@
-export function createControlRpc({control, manager, summarizeWorkspaces, scheduleBadge}) {
+function validTabId(tabId) { return Number.isSafeInteger(tabId) && tabId > 0; }
+function validateQueueUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== 'https:' || !parsed.hostname) throw Error('Queue target must be an HTTPS URL');
+  return parsed.href;
+}
+
+export function createControlRpc({control, manager, summarizeWorkspaces, scheduleBadge, chromeApi=globalThis.chrome ?? control.chrome}) {
   return 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};
+        const workspaces = await Promise.all(summary.workspaces.map(async workspace => ({
+          ...workspace,
+          sessions: await Promise.all(workspace.sessions.map(async session => {
+            if (!validTabId(session.tabId)) return session;
+            try {
+              const tab = await chromeApi.tabs.get(session.tabId);
+              return {...session, tab_title: tab.title || 'Untitled tab'};
+            } catch { return {...session, tabId:null}; }
+          })),
+        })));
+        return {...state,...summary,workspaces};
+      }
+      case "workspace.control.activateTab": {
+        const state = await control.status();
+        if (!state.connected) throw Error('WebHelm daemon is not responding');
+        const session = state.sessions.find(s => s.session_id === args.sessionId);
+        if (!session || !validTabId(session.tabId)) throw Error('Session tab is no longer active');
+        const tab = await chromeApi.tabs.get(session.tabId);
+        await chromeApi.tabs.update(tab.id,{active:true});
+        await chromeApi.windows.update(tab.windowId,{focused:true});
+        return {ok:true};
+      }
+      case "workspace.control.openQueue": {
+        const state = await control.status();
+        if (!state.connected) throw Error('WebHelm daemon is not responding');
+        const item = state.queue.find(item => item.id === args.queueId);
+        if (!item || typeof item.url !== 'string') throw Error('Queue entry no longer available');
+        const url = validateQueueUrl(item.url);
+        const existing = (await chromeApi.tabs.query({})).find(tab => {
+          try { return new URL(tab.url).href === url; } catch { return false; }
+        });
+        if (existing) {
+          await chromeApi.tabs.update(existing.id,{active:true});
+          await chromeApi.windows.update(existing.windowId,{focused:true});
+          return {ok:true,tabId:existing.id,focused:true};
+        }
+        const opened = await chromeApi.tabs.create({url, active:true});
+        return {ok:true,tabId:opened.id,opened:true};
       }
       case "workspace.control.requestStop":
         return control.requestStop(args.action, args.sessionId, args.workspace);

package/runtime/extension/popup.html

@@ -22,8 +22,8 @@
     #confirmation p { color:inherit; }
     .buttons { display:flex; gap:8px; }
     .session-list { max-height:360px; overflow-y:auto; }
-    .workspace-row { padding:9px 0; border-bottom:1px solid light-dark(var(--border),#334155); }
-    .workspace-row:last-child { border-bottom:0; }
+    .workspace-row { padding:7px 0; }
+    .workspace-row + .workspace-row { border-top: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:4px 8px; font-size:11px; }
@@ -33,10 +33,20 @@
     .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; }
-    .queue-row { display:flex; align-items:center; gap:8px; padding:7px 0; border-bottom:1px solid light-dark(var(--border),#334155); }
+    #queue-list { border-top:1px solid light-dark(var(--border),#334155); padding-top:6px; margin-top:2px; }
+    .queue-platform { padding:5px 0; }
+    .queue-platform + .queue-platform { border-top:1px solid light-dark(var(--border),#334155); }
+    .queue-platform-title { font-size:12px; }
+    .queue-row { display:flex; align-items:center; gap:8px; padding:5px 0; }
     .queue-info { min-width:0; flex:1; overflow-wrap:anywhere; }
     .queue-info span { display:block; color:light-dark(var(--muted),#acb8c9); font-size:11px; }
     .queue-row button { width:auto; padding:5px 9px; font-size:11px; }
+    button.tab-title, button.queue-title { flex:1; min-width:0; width:100%; padding:0; border:0; border-radius:2px; background:transparent; color:inherit; text-align:left; font-size:12px; font-weight:600; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; cursor:pointer; }
+    button.tab-title:hover, button.queue-title:hover { text-decoration:underline; }
+    button.tab-title:disabled, button.queue-title:disabled { cursor:default; text-decoration:none; }
+    .session-info, .queue-info { overflow:hidden; }
+    .queue-info .queue-title { margin:0; }
+
     #message { margin-top:8px; font-size:11px; overflow-wrap:anywhere; }
     #message:empty { display:none; }
     [hidden] { display:none !important; }
@@ -48,8 +58,7 @@
     <span id="daemon-status" class="daemon-state" role="status">Connecting…</span>
   </header>
   <div id="workspace-list" class="session-list" aria-label="Workspaces" aria-live="polite">Connecting…</div>
-  <strong>ChatGPT queue</strong>
-  <div id="queue-list" class="session-list" aria-label="ChatGPT queue" aria-live="polite">No queued turns</div>
+  <div id="queue-list" class="session-list" aria-label="Queue" aria-live="polite">No queue entries</div>
   <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">

package/runtime/extension/popup.mjs

@@ -2,7 +2,10 @@ const el = id => document.getElementById(id);
 let confirming = false;
 let chosen = null;
 let lastSignature = '';
+let lastQueueSignature = '';
 let refreshRunning = false;
+const queueRows = new Map();
+const queueGroups = new Map();
 
 async function rpc(method, args = {}) {
   const response = await chrome.runtime.sendMessage({method, args});
@@ -23,9 +26,10 @@ function showConfirmation(action, params = {}) {
   }
 }
 
-function actionButton(label, disabled, onClick) {
+function actionButton(label, disabled, onClick, className = '') {
   const button = document.createElement('button');
   button.textContent = label;
+  if (className) button.className = className;
   button.disabled = disabled;
   button.addEventListener('click', onClick);
   return button;
@@ -33,7 +37,7 @@ function actionButton(label, disabled, onClick) {
 
 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),
+    w.name,w.initialized,w.available,w.poolSize,w.idleTabs,w.leasedTabs,w.sessions.map(s => [s.session_id,s.tab_title,s.tabId]),
   ])) + ':' + busy + ':' + connected;
   if (signature === lastSignature) return;
   lastSignature = signature;
@@ -63,9 +67,12 @@ function renderWorkspaces(workspaces, busy, connected) {
       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);
+      const title = actionButton(session.tab_title || 'Untitled tab', busy || !connected || !session.tabId, async () => {
+        try { await rpc('workspace.control.activateTab', {sessionId:session.session_id}); }
+        catch(error) { el('message').textContent=error.message; }
+      }, 'tab-title');
+      title.title = session.tab_title || 'Untitled tab';
+      details.append(title);
       sessionRow.append(details, actionButton('Stop', busy || !connected,
         () => showConfirmation('stop', {sessionId:session.session_id})));
       row.append(sessionRow);
@@ -75,21 +82,72 @@ function renderWorkspaces(workspaces, busy, connected) {
 }
 
 function renderQueue(items, busy, connected) {
+  const signature=JSON.stringify(items.map(item=>[item.id,item.platform,item.title,item.url,item.state,item.attempts]))+`:${busy}:${connected}`;
+  if (signature===lastQueueSignature) return;
+  lastQueueSignature=signature;
   const target=el('queue-list');
-  target.replaceChildren();
-  if (!items.length) { target.textContent='No active turns'; return; }
+  const grouped = new Map();
   for (const item of items) {
-    const row=document.createElement('div'); row.className='queue-row';
-    const info=document.createElement('div'); info.className='queue-info';
-    const title=document.createElement('strong'); title.textContent=`Thread ${item.thread_id}`;
-    const detail=document.createElement('span'); detail.textContent=`${item.state.toLowerCase()} · ${item.attempts} attempt${item.attempts===1?'':'s'}`;
-    info.append(title,detail); row.append(info);
-    if (item.state==='QUEUED') row.append(actionButton('Cancel',busy || !connected,async()=>{
-      try { const result=await rpc('workspace.control.queueCancel',{queueId:item.id}); if(!result.id) throw new Error('Missing queue request ID'); el('message').textContent='Waiting for WebHelm daemon…'; }
-      catch(error) { el('message').textContent=error.message; }
-      refresh();
-    }));
-    target.append(row);
+    const platform = String(item.platform || 'Queue');
+    if (!grouped.has(platform)) grouped.set(platform, []);
+    grouped.get(platform).push(item);
+  }
+  const activeGroupKeys = new Set(grouped.keys());
+  const activeRowKeys = new Set(items.map(item => `${item.platform || 'Queue'}:${item.id}`));
+  for (const [key, group] of queueGroups) if (!activeGroupKeys.has(key)) {
+    group.remove(); queueGroups.delete(key);
+  }
+  for (const [key, row] of queueRows) if (!activeRowKeys.has(key)) {
+    row.remove(); queueRows.delete(key);
+  }
+  if (!items.length) {
+    target.replaceChildren();
+    const empty=document.createElement('div'); empty.className='empty-queue'; empty.textContent='No queue entries';
+    target.append(empty);
+    return;
+  }
+  target.querySelector('.empty-queue')?.remove();
+  for (const [platform, entries] of grouped) {
+    let group = queueGroups.get(platform);
+    if (!group) {
+      group = document.createElement('section'); group.className='queue-platform';
+      const heading = document.createElement('strong'); heading.className='queue-platform-title';
+      heading.textContent=platform==='Queue'?'Queue':`${platform} Queue`;
+      const rows = document.createElement('div'); rows.className='queue-platform-rows';
+      group.append(heading, rows); queueGroups.set(platform, group); target.append(group);
+    }
+    for (const item of entries) {
+      const key = `${platform}:${item.id}`;
+      let row = queueRows.get(key);
+      if (!row) {
+        row=document.createElement('div'); row.className='queue-row';
+        const info=document.createElement('div'); info.className='queue-info';
+        const title=actionButton('', false, async()=>{
+          try { await rpc('workspace.control.openQueue',{queueId:item.id}); el('message').textContent='Queue destination opened.'; }
+          catch(error) { el('message').textContent=error.message; }
+        }, 'queue-title');
+        const detail=document.createElement('span'); detail.className='queue-detail';
+        const remove=actionButton('Remove', false, async()=>{
+          try { const result=await rpc('workspace.control.queueCancel',{queueId:item.id}); if(!result.id) throw new Error('Missing queue request ID'); el('message').textContent='Waiting for WebHelm daemon…'; }
+          catch(error) { el('message').textContent=error.message; }
+          refresh();
+        });
+        row.append(info, remove); info.append(title, detail);
+        queueRows.set(key,row);
+      }
+      const title=row.querySelector('.queue-title');
+      title.textContent=item.title || `${platform} message`;
+      title.title=item.title || `${platform} message`;
+      title.disabled=!connected || !item.url;
+      row.querySelector('.queue-detail').textContent=`${item.state.toLowerCase()} · ${item.attempts} attempt${item.attempts===1?'':'s'}`;
+      const remove=row.querySelector('button:last-child');
+      const safe=['QUEUED','WAITING','BLOCKED','UNCERTAIN'].includes(item.state);
+      remove.disabled=!safe || busy || !connected;
+      remove.title=safe?'':'Cannot remove a running or completed submission';
+      const rows=group.querySelector('.queue-platform-rows');
+      if (row.parentElement!==rows) rows.append(row);
+    }
+    if (group.parentElement!==target) target.append(group);
   }
 }
 
@@ -105,10 +163,10 @@ async function refresh() {
     renderQueue(state.queue || [], busy, state.connected);
     el('confirm').disabled = !state.connected || busy;
     if (busy) {
-      el('message').textContent = 'Stopping sessions…';
+      el('message').textContent = 'Applying WebHelm action…';
     } else if (state.lastResult) {
       el('message').textContent = state.lastResult.ok
-        ? `Last action: stopped ${state.lastResult.stoppedCount} session(s).`
+        ? (state.lastResult.queue_id ? 'Queue entry removed.' : `Last action: stopped ${state.lastResult.stoppedCount} session(s).`)
         : `Last action failed: ${state.lastResult.error}`;
     }
   } catch (error) {

package/runtime/extension/service-worker.mjs

@@ -6,6 +6,10 @@ import { createControlRpc } from "./control-rpc.mjs";
 
 const manager = new WorkspaceManager(chrome);
 const control = new ControlChannel(chrome);
+manager.setOwnershipProvider(async () => {
+  const state = await control.status();
+  return state.connected ? state.sessions : null;
+});
 const closingWindowIds = new Set();
 let badgeTimer = null;
 
@@ -26,11 +30,16 @@ function scheduleBadge() {
 }
 
 const BADGE_ALARM = "webhelm.badge-refresh";
+const ORPHAN_ALARM = "webhelm.orphan-lease-recovery";
 async function scheduleBadgeAlarm() {
   await chrome.alarms.create(BADGE_ALARM, {periodInMinutes: 0.5});
+  await chrome.alarms.create(ORPHAN_ALARM, {periodInMinutes: 1});
 }
 chrome.alarms.onAlarm.addListener(alarm => {
   if (alarm.name === BADGE_ALARM) scheduleBadge();
+  if (alarm.name === ORPHAN_ALARM) manager.recoverConfiguredOrphans().catch(error => {
+    console.warn("WebHelm orphan lease recovery failed", error);
+  });
 });
 scheduleBadgeAlarm().catch(error => console.warn("WebHelm badge alarm failed", error));
 
@@ -92,7 +101,8 @@ 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.queueCancel", "workspace.control.status"].includes(request.method))) {
+        !["workspace.control.requestStop", "workspace.control.queueCancel", "workspace.control.status",
+         "workspace.control.activateTab", "workspace.control.openQueue"].includes(request.method))) {
     sendResponse({ok:false,error:{message:"WebHelm control actions require the toolbar popup"}});
     return false;
   }

package/runtime/extension/workspace-manager.mjs

@@ -2,6 +2,20 @@ const STORAGE_KEY = "browserWorkspaceManager.v1";
 const MIN_POOL_SIZE = 1;
 const MAX_POOL_SIZE = 64;
 const EXTENSION_MANAGEMENT_RECENCY_MS = 15_000;
+const ORPHAN_LEASE_GRACE_MS = 60_000;
+const ORPHAN_OBSERVED_KEY = "webhelm.orphan-observed.v1";
+
+class Mutex {
+  constructor() { this.tail = Promise.resolve(); }
+  async run(fn) {
+    let release;
+    const gate = new Promise(resolve => { release = resolve; });
+    const previous = this.tail;
+    this.tail = previous.then(() => gate);
+    await previous;
+    try { return await fn(); } finally { release(); }
+  }
+}
 
 export function normalizeWorkspaceName(value) {
   const name = String(value || "").trim();
@@ -23,12 +37,112 @@ function queryString(workspace) {
 }
 
 export class WorkspaceManager {
-  constructor(chromeApi) {
+  constructor(chromeApi, { now = () => Date.now(), orphanGraceMs = ORPHAN_LEASE_GRACE_MS } = {}) {
     this.chrome = chromeApi;
+    this.now = now;
+    this.orphanGraceMs = orphanGraceMs;
+    this.getDaemonSessions = async () => null;
+    this.workspaceLocks = new Map();
+    this.orphanObserved = new Map();
+    this.orphanObservedLoaded = false;
+    this.inFlightTabIds = new Set();
     this.recentExtensionManagementByWindow = new Map();
     this.ownedTabIds = new Set();
   }
 
+  setOwnershipProvider(provider) {
+    this.getDaemonSessions = provider;
+  }
+
+  workspaceLock(name) {
+    if (!this.workspaceLocks.has(name)) this.workspaceLocks.set(name, new Mutex());
+    return this.workspaceLocks.get(name);
+  }
+
+  async loadOrphanObservations() {
+    if (this.orphanObservedLoaded) return;
+    this.orphanObservedLoaded = true;
+    if (!this.chrome.storage.session) return;
+    const saved = (await this.chrome.storage.session.get(ORPHAN_OBSERVED_KEY))[ORPHAN_OBSERVED_KEY] || {};
+    this.orphanObserved = new Map(Object.entries(saved).map(([key, value]) => [key, Number(value)]));
+  }
+
+  async saveOrphanObservations() {
+    if (!this.chrome.storage.session) return;
+    await this.chrome.storage.session.set({[ORPHAN_OBSERVED_KEY]:Object.fromEntries(this.orphanObserved)});
+  }
+
+  async recoverOrphanedLeases(name, { sessions = null, graceMs = this.orphanGraceMs } = {}) {
+    await this.loadOrphanObservations();
+    const normalizedName = normalizeWorkspaceName(name);
+    const { entry } = await this.configuredWorkspace(normalizedName);
+    if (!entry) return [];
+    const group = await this.workspaceGroup(normalizedName);
+    if (!group) return [];
+    const daemonSessions = sessions ?? await this.getDaemonSessions();
+    // A disconnected daemon cannot certify that an apparently leased tab is orphaned.
+    if (!Array.isArray(daemonSessions)) return [];
+    const ownedTabIds = new Set((daemonSessions || []).flatMap(session => [session.tabId, ...(session.tabIds || [])])
+      .map(Number).filter(Number.isInteger));
+    const tabs = await this.groupTabs(group.id);
+    const candidates = tabs.filter(tab => {
+      const url = this.tabUrl(tab);
+      const meta = this.parseManagedUrl(url);
+      return url === 'about:blank' ||
+        (meta?.workspace === normalizedName && meta.role === 'lease' && meta.tabId === String(tab.id));
+    });
+    const candidateIds = new Set(candidates.map(tab => tab.id));
+    for (const key of this.orphanObserved.keys()) {
+      const [workspace, id] = key.split('\0');
+      if (workspace === normalizedName && !candidateIds.has(Number(id))) this.orphanObserved.delete(key);
+    }
+    await this.saveOrphanObservations();
+    const recovered = [];
+    for (const candidate of candidates) {
+      const key = `${normalizedName}\0${candidate.id}`;
+      if (ownedTabIds.has(candidate.id) || this.inFlightTabIds.has(candidate.id)) {
+        this.orphanObserved.delete(key);
+        continue;
+      }
+      const firstSeen = this.orphanObserved.get(key) ?? this.now();
+      this.orphanObserved.set(key, firstSeen);
+      await this.saveOrphanObservations();
+      if (this.now() - firstSeen < graceMs) continue;
+
+      // Re-read both Chrome ownership and the daemon's current session list
+      // immediately before navigating. The workspace lock excludes acquisition.
+      const current = await this.chrome.tabs.get(candidate.id).catch(() => null);
+      const currentUrl = this.tabUrl(current);
+      const currentMeta = this.parseManagedUrl(currentUrl);
+      const stillCandidate = current?.groupId === group.id && (currentUrl === 'about:blank' ||
+        (currentMeta?.workspace === normalizedName && currentMeta.role === 'lease' && currentMeta.tabId === String(current.id)));
+      const latestSessions = await this.getDaemonSessions();
+      if (!Array.isArray(latestSessions)) continue;
+      if (!stillCandidate || latestSessions.some(session =>
+          Number(session.tabId) === candidate.id || (session.tabIds || []).some(tabId => Number(tabId) === candidate.id)) ||
+          this.inFlightTabIds.has(candidate.id)) {
+        if (!stillCandidate) this.orphanObserved.delete(key);
+        continue;
+      }
+      await this.chrome.tabs.update(candidate.id, { url: this.idleUrl(normalizedName), active: false });
+      const idle = await this.waitForIdleTab(candidate.id, normalizedName);
+      this.markOwned(idle.id);
+      this.orphanObserved.delete(key);
+      await this.saveOrphanObservations();
+      recovered.push({ workspace: normalizedName, tabId: candidate.id, recovered: true });
+    }
+    return recovered;
+  }
+
+  async recoverConfiguredOrphans() {
+    const config = await this.loadConfig();
+    const recovered = [];
+    for (const name of Object.keys(config.workspaces || {}).sort()) {
+      recovered.push(...await this.workspaceLock(name).run(() => this.recoverOrphanedLeases(name)));
+    }
+    return recovered;
+  }
+
   isOwnedTab(tab) {
     const tabId = Number(tab?.id);
     if (Number.isInteger(tabId) && this.ownedTabIds.has(tabId)) return true;
@@ -550,6 +664,7 @@ export class WorkspaceManager {
 
   async acquireIdentity(name) {
     const normalizedName = normalizeWorkspaceName(name);
+    return await this.workspaceLock(normalizedName).run(async () => {
     // Leasing may allocate a Tab inside an existing Workspace, but must never
     // provision a new Workspace as a side effect. Only app-owned creation can.
     const { entry } = await this.configuredWorkspace(normalizedName);
@@ -558,6 +673,7 @@ export class WorkspaceManager {
     // Previously provisioned workspaces may restore a missing physical group
     // from their durable configuration; this never creates a new name.
     const ready = await this.ensureWorkspace(normalizedName);
+    await this.recoverOrphanedLeases(normalizedName);
     const tabs = await this.groupTabs(ready.groupId);
     const { idle, leased } = this.classify(normalizedName, tabs);
     if (!idle.length && leased.length >= ready.poolSize) {
@@ -576,9 +692,12 @@ export class WorkspaceManager {
     }
 
     this.markOwned(tab.id);
+    this.inFlightTabIds.add(tab.id);
     const identityTitle = this.identityTitle(tab.id);
     const identityUrl = this.identityUrl(normalizedName, tab.id);
-    const updated = await this.chrome.tabs.update(tab.id, { url: identityUrl, active: false });
+    let updated;
+    try { updated = await this.chrome.tabs.update(tab.id, { url: identityUrl, active: false }); }
+    finally { this.inFlightTabIds.delete(tab.id); }
     await this.chrome.tabGroups.update(ready.groupId, { title: normalizedName, collapsed: true });
     return {
       workspace: normalizedName,
@@ -589,6 +708,7 @@ export class WorkspaceManager {
       idleUrl: this.idleUrl(normalizedName),
       active: Boolean(updated.active),
     };
+    });
   }
 
   async acquire(name, url) {
@@ -597,6 +717,7 @@ export class WorkspaceManager {
     if (!["http:", "https:", "chrome-extension:"].includes(parsed.protocol)) {
       throw new Error("Workspace acquire requires an http(s) or chrome-extension URL");
     }
+    return await this.workspaceLock(normalizedName).run(async () => {
 
     // Leasing may allocate a Tab inside an existing Workspace, but must never
     // provision a new Workspace as a side effect. Only app-owned creation can.
@@ -606,6 +727,7 @@ export class WorkspaceManager {
     // Previously provisioned workspaces may restore a missing physical group
     // from their durable configuration; this never creates a new name.
     const ready = await this.ensureWorkspace(normalizedName);
+    await this.recoverOrphanedLeases(normalizedName);
     const tabs = await this.groupTabs(ready.groupId);
     const { idle, leased } = this.classify(normalizedName, tabs);
     if (!idle.length && leased.length >= ready.poolSize) {
@@ -634,6 +756,7 @@ export class WorkspaceManager {
       url: updated.url || parsed.href,
       active: Boolean(updated.active),
     };
+    });
   }
 
   async release(name, tabId) {

package/runtime/node-daemon.mjs

@@ -615,6 +615,8 @@ 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,
+    tabId:s.leasedTabs.get(s.targetId) ?? s.leasedTabs.get(s.rootTargetId) ?? null,
+    tabIds:[...s.leasedTabs.values()],
   }));
 }
 async function pollExtensionControl() {