webhelm 1.0.17 → 1.0.19

package/README.md

@@ -47,7 +47,7 @@ The Actions checkout is `~/.local/webhelm`, with site modules at `~/.local/webhe
 
 ## Architecture and compatibility
 
-The Runtime stores its managed Chrome profile, persistent FIFO queue, and IPC socket under `~/.config/webhelm/`. Run `webhelm migrate` with the legacy daemon and Chrome stopped to migrate existing `~/.config/browser-workspace/` data without dropping logins or queued turns. The command leaves a compatibility symlink for legacy maintenance scripts. Session idle GC runs on Node before new Session allocation (5 minutes without operations or explicit heartbeat). Managed tabs are navigated back to their Extension idle URL instead of closing CDP targets; the Extension does not use `tab.lastAccessed` GC. Only one daemon is permitted to own the queue. A CLI package update does not kill a running daemon or close another agent's tabs; upgrade daemons when idle.
+The Runtime stores its managed Chrome profile, persistent FIFO queue, and IPC socket under `~/.config/webhelm/`. Run `webhelm migrate` with the legacy daemon and Chrome stopped to migrate existing `~/.config/browser-workspace/` data without dropping logins or queued turns. The command leaves a compatibility symlink for legacy maintenance scripts. Session idle GC runs on Node before new Session allocation (5 minutes without operations or explicit heartbeat); no background sweep is started. A timed-out Session refuses subsequent exec, platform Actions and heartbeat, while already-issued browser effects retain tab ownership until settled. A stop that times out while queued cannot execute a late release, and a stop already physically releasing keeps its Session closing until the release finishes. Managed tabs are navigated back to their Extension idle URL instead of closing CDP targets; the Extension does not use `tab.lastAccessed` GC. An async Session execution has a finite deadline: if it expires, its helper capabilities are revoked and the poisoned Session is collected on the next Tab request (or immediately by an explicit stop). Session stop also has a bounded drain/release deadline and cannot leave a permanent closing flag. Client IPC requests have an independent absolute timeout and return an error if the daemon does not respond. These safeguards do not introduce periodic background GC. Only one daemon is permitted to own the queue. A CLI package update does not kill a running daemon or close another agent's tabs; upgrade daemons when idle.
 
 NeoY and Relay can continue using `webhelm` session commands, `result.stdout` JSON receipts, and `admin_helper` returned by `status`. An `admin_helper` inside the installed Skill is a stable connector to the same Node IPC socket. `webhelm capacity` replaces the legacy Python capacity probe.
 
@@ -63,7 +63,7 @@ Keep platform-specific code and tests in `lalalic/webhelm-actions`. Runtime test
 
 ### Adding an unsupported platform
 
-The repository provides [`docs/NEW_PLATFORM.md`](docs/NEW_PLATFORM.md) for maintainers. All new platform code belongs in **`~/.local/webhelm/platforms/<slug>`**, checked out from `lalalic/webhelm-actions`, including tests and docs. There is no separate `platforms/` directory in the Skill or npm package. Publishing an Action uses Git, not npm.
+For new platforms, follow the canonical [`platforms/NEW_PLATFORM.md`](https://github.com/lalalic/webhelm-actions/blob/main/platforms/NEW_PLATFORM.md) in the installed Actions checkout. All new platform code belongs in **`~/.local/webhelm/platforms/<slug>`**, checked out from `lalalic/webhelm-actions`, including tests and docs. There is no separate `platforms/` directory in the Skill or npm package. Publishing an Action uses Git, not npm.
 
 ## npm publishing
 

package/package.json

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

package/runtime/chatgpt/chatgpt-queue.mjs

@@ -1,9 +1,10 @@
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { classifyProbe, PROBE_JS, targetUrl } from "./chatgpt-probe.mjs";
 import { CLICK_SEND_JS, SEND_ENABLED_JS } from "./lifecycle-common.mjs";
+import { DurableQueueCore } from "../durable-queue-core.mjs";
 
 const transitions = new Set([
   "CHECKING>WAITING",
@@ -15,15 +16,63 @@ const transitions = new Set([
   "UNCERTAIN>WAITING",
   "BLOCKED>WAITING",
 ]);
-const ACTIVE = [
-  "QUEUED",
-  "CHECKING",
-  "WAITING",
-  "SENDING",
-  "UNCERTAIN",
-  "BLOCKED",
-];
-export class ChatGPTQueue {
+
+// ChatGPT owns its legacy turns/merged_requests schema and all turn payload,
+// idempotency, merge, FIFO partition, and recovery semantics.
+const chatgptQueuePolicy = {
+  one(db, sql, ...args) { return db.prepare(sql).get(...args) || null; },
+  rows(db) { return db.prepare("SELECT * FROM turns ORDER BY seq").all(); },
+  enqueue(db, request = {}, now) {
+    const {thread_id, message, idempotency_key, idempotencyKey, project_id=null, mergeable=false} = request;
+    const key=idempotency_key ?? idempotencyKey;
+    if (!thread_id || !message || !key) throw new TypeError("thread_id, message, idempotency_key required");
+    if (typeof mergeable !== "boolean") throw new TypeError("mergeable must be a boolean");
+    const merged=this.one(db, "SELECT * FROM merged_requests WHERE idem_key=?", key);
+    if (merged) {
+      if (merged.thread_id!==thread_id || merged.message!==message || merged.project_id!==project_id) throw new Error("idempotency key reused with different payload");
+      const row=this.one(db, "SELECT * FROM turns WHERE id=?", merged.queue_id);
+      return {ok:true,status:"queued",queue_id:row.id,thread_id:row.thread_id,state:row.state};
+    }
+    const same=this.one(db, "SELECT * FROM turns WHERE idem_key=?", key);
+    if (same) {
+      if (same.thread_id!==thread_id || same.message!==message || same.project_id!==project_id) throw new Error("idempotency key reused with different payload");
+      return {ok:true,status:"queued",queue_id:same.id,thread_id:same.thread_id,state:same.state};
+    }
+    const tail=mergeable ? this.one(db, "SELECT * FROM turns WHERE thread_id=? ORDER BY seq DESC LIMIT 1", thread_id) : null;
+    // WAITING denotes admitted work being retried; only QUEUED is cancellable
+    // and eligible for a new enqueue-time merge.
+    if (tail && tail.mergeable && tail.project_id===project_id && tail.state==="QUEUED") {
+      db.prepare("INSERT OR IGNORE INTO merged_requests VALUES(?,?,?,?,?)").run(tail.idem_key,tail.project_id,thread_id,tail.message,tail.id);
+      db.prepare("INSERT INTO merged_requests VALUES(?,?,?,?,?)").run(key,project_id,thread_id,message,tail.id);
+      db.prepare("UPDATE turns SET message=message || ? WHERE id=?").run("\n"+message,tail.id);
+      const row=this.one(db, "SELECT * FROM turns WHERE id=?", tail.id);
+      return {ok:true,status:"queued",queue_id:row.id,thread_id:row.thread_id,state:row.state};
+    }
+    const id=randomUUID();
+    db.prepare("INSERT INTO turns(id,idem_key,project_id,thread_id,message,state,next_check_at,created_at,mergeable) VALUES(?,?,?,?,?,'QUEUED',?,?,?)").run(id,key,project_id,thread_id,message,now,now,mergeable?1:0);
+    return {ok:true,status:"queued",queue_id:id,thread_id,state:"QUEUED"};
+  },
+  claim(db, owner, now, leaseSeconds) {
+    db.prepare("UPDATE turns SET state='UNCERTAIN',lease_owner=NULL,lease_until=NULL WHERE state='SENDING' AND lease_until<=?").run(now);
+    db.prepare("UPDATE turns SET state='WAITING',lease_owner=NULL,lease_until=NULL,next_check_at=? WHERE state='CHECKING' AND lease_until<=?").run(now,now);
+    const row=this.one(db, `SELECT t.* FROM turns t WHERE t.state IN ('QUEUED','WAITING') AND t.next_check_at<=? AND NOT EXISTS(SELECT 1 FROM turns older WHERE older.thread_id=t.thread_id AND older.seq<t.seq AND (older.state NOT IN ('SENT','CANCELLED') OR (older.state='SENT' AND older.next_check_at>?))) ORDER BY t.seq LIMIT 1`,now,now);
+    if (!row) return null;
+    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);
+  },
+  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);
+    return {ok:true,queue_id:id,state:"CANCELLED"};
+  },
+  list(db) {
+    return {ok:true,items:this.rows(db).filter(row=>!["SENT","CANCELLED"].includes(row.state)).map(({id,thread_id,state,attempts,created_at,receipt})=>({id,queue_id:id,thread_id,state,attempts,created_at,receipt}))};
+  },
+};
+
+export class ChatGPTQueue extends DurableQueueCore {
   constructor(
     {
       persistenceRoot,
@@ -49,155 +98,36 @@ export class ChatGPTQueue {
         throw new TypeError(`${name} callback is required`);
       }
     }
-    this.root = resolve(persistenceRoot);
-    mkdirSync(this.root, { recursive: true });
-    this.dbPath = join(this.root, "chatgpt-new-turn.sqlite3");
-    this.db = new DatabaseSync(this.dbPath);
-    this.db.exec(
+    const root = resolve(persistenceRoot);
+    mkdirSync(root, { recursive: true });
+    const dbPath = join(root, "chatgpt-new-turn.sqlite3");
+    const db = new DatabaseSync(dbPath);
+    db.exec(
       "PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=5000",
     );
-    this.db.exec(
+    db.exec(
       `CREATE TABLE IF NOT EXISTS turns(seq INTEGER PRIMARY KEY AUTOINCREMENT,id TEXT NOT NULL UNIQUE,idem_key TEXT NOT NULL UNIQUE,project_id TEXT,thread_id TEXT NOT NULL,message TEXT NOT NULL,state TEXT NOT NULL,lease_owner TEXT,lease_until REAL,next_check_at REAL NOT NULL,created_at REAL NOT NULL,attempts INTEGER NOT NULL DEFAULT 0,receipt TEXT,mergeable INTEGER NOT NULL DEFAULT 0); CREATE INDEX IF NOT EXISTS turns_thread_order ON turns(thread_id,seq); CREATE TABLE IF NOT EXISTS merged_requests(idem_key TEXT PRIMARY KEY,project_id TEXT,thread_id TEXT NOT NULL,message TEXT NOT NULL,queue_id TEXT NOT NULL);`,
     );
+    super(db, chatgptQueuePolicy, now, {
+      concurrency: Math.min(4, Math.max(1, Number(concurrency) || 4)), intervalMs,
+    });
+    this.root = root;
+    this.dbPath = dbPath;
+    this.db = db;
     this.startSession = startSession;
     this.execSession = execSession;
     this.stopSession = stopSession;
-    this.intervalMs = intervalMs;
-    this.concurrency = concurrency;
     this.leaseSeconds = leaseSeconds;
-    this.now = now;
     this.logger = logger;
-    this.active = new Map();
     this.sessions = new Map();
-    this.started = false;
-    this.closed = false;
-    this.wakeTimer = null;
-  }
-  _transaction(fn) {
-    this.db.exec("BEGIN IMMEDIATE");
-    try {
-      const v = fn();
-      this.db.exec("COMMIT");
-      return v;
-    } catch (e) {
-      this.db.exec("ROLLBACK");
-      throw e;
-    }
-  }
-  _one(sql, ...args) {
-    return this.db.prepare(sql).get(...args) || null;
   }
-  _rows() {
-    return this.db.prepare("SELECT * FROM turns ORDER BY seq").all();
-  }
-  enqueue(
-    {
-      thread_id,
-      message,
-      idempotency_key,
-      idempotencyKey,
-      project_id = null,
-      mergeable = false,
-    } = {},
-  ) {
-    const key = idempotency_key ?? idempotencyKey;
-    if (!thread_id || !message || !key) {
-      throw new TypeError("thread_id, message, idempotency_key required");
-    }
-    if (typeof mergeable !== "boolean") {
-      throw new TypeError("mergeable must be a boolean");
-    }
-    const now = this.now();
-    const row = this._transaction(() => {
-      const merged = this._one(
-        "SELECT * FROM merged_requests WHERE idem_key=?",
-        key,
-      );
-      if (merged) {
-        if (
-          merged.thread_id !== thread_id || merged.message !== message ||
-          merged.project_id !== project_id
-        ) throw new Error("idempotency key reused with different payload");
-        return this._one("SELECT * FROM turns WHERE id=?", merged.queue_id);
-      }
-      const same = this._one("SELECT * FROM turns WHERE idem_key=?", key);
-      if (same) {
-        if (
-          same.thread_id !== thread_id || same.message !== message ||
-          same.project_id !== project_id
-        ) throw new Error("idempotency key reused with different payload");
-        return same;
-      }
-      const tail = mergeable
-        ? this._one(
-          "SELECT * FROM turns WHERE thread_id=? ORDER BY seq DESC LIMIT 1",
-          thread_id,
-        )
-        : null;
-      if (
-        tail && tail.mergeable && tail.project_id === project_id &&
-        ["QUEUED", "WAITING"].includes(tail.state)
-      ) {
-        this.db.prepare(
-          "INSERT OR IGNORE INTO merged_requests VALUES(?,?,?,?,?)",
-        ).run(tail.idem_key, tail.project_id, thread_id, tail.message, tail.id);
-        this.db.prepare("INSERT INTO merged_requests VALUES(?,?,?,?,?)").run(
-          key,
-          project_id,
-          thread_id,
-          message,
-          tail.id,
-        );
-        this.db.prepare("UPDATE turns SET message=message || ? WHERE id=?").run(
-          "\n" + message,
-          tail.id,
-        );
-        return this._one("SELECT * FROM turns WHERE id=?", tail.id);
-      }
-      const id = randomUUID();
-      this.db.prepare(
-        "INSERT INTO turns(id,idem_key,project_id,thread_id,message,state,next_check_at,created_at,mergeable) VALUES(?,?,?,?,? ,'QUEUED',?,?,?)",
-      ).run(
-        id,
-        key,
-        project_id,
-        thread_id,
-        message,
-        now,
-        now,
-        mergeable ? 1 : 0,
-      );
-      return this._one("SELECT * FROM turns WHERE id=?", id);
-    });
+  enqueue(request) {
+    const result = super.enqueue(request);
     if (this.started) this._wake(0);
-    return {
-      ok: true,
-      status: "queued",
-      queue_id: row.id,
-      thread_id: row.thread_id,
-      state: row.state,
-    };
-  }
-  claim(owner, now = this.now()) {
-    return this._transaction(() => {
-      this.db.prepare(
-        "UPDATE turns SET state='UNCERTAIN',lease_owner=NULL,lease_until=NULL WHERE state='SENDING' AND lease_until<=?",
-      ).run(now);
-      this.db.prepare(
-        "UPDATE turns SET state='WAITING',lease_owner=NULL,lease_until=NULL,next_check_at=? WHERE state='CHECKING' AND lease_until<=?",
-      ).run(now, now);
-      const row = this._one(
-        `SELECT t.* FROM turns t WHERE t.state IN ('QUEUED','WAITING') AND t.next_check_at<=? AND NOT EXISTS(SELECT 1 FROM turns older WHERE older.thread_id=t.thread_id AND older.seq<t.seq AND (older.state NOT IN ('SENT','CANCELLED') OR (older.state='SENT' AND older.next_check_at>?))) ORDER BY t.seq LIMIT 1`,
-        now,
-        now,
-      );
-      if (!row) return null;
-      this.db.prepare(
-        "UPDATE turns SET state='CHECKING',lease_owner=?,lease_until=?,attempts=attempts+1 WHERE id=?",
-      ).run(owner, now + this.leaseSeconds, row.id);
-      return this._one("SELECT * FROM turns WHERE id=?", row.id);
-    });
+    return result;
   }
+  _one(sql, ...args) { return this.db.prepare(sql).get(...args) || null; }
+  claim(owner, now = this.now()) { return super.claim(owner, now, this.leaseSeconds); }
   transition(
     id,
     owner,
@@ -238,24 +168,7 @@ export class ChatGPTQueue {
       );
     });
   }
-  rows() {
-    return this._rows();
-  }
-  inspect() {
-    return {
-      ok: true,
-      items: this.rows().filter((r) => !["SENT", "CANCELLED"].includes(r.state))
-        .map(({ id, thread_id, state, attempts, created_at, receipt }) => ({
-          id,
-          queue_id: id,
-          thread_id,
-          state,
-          attempts,
-          created_at,
-          receipt,
-        })),
-    };
-  }
+  inspect() { return this.list(); }
   reconcile({ queue_id, evidence, accepted } = {}) {
     if (!queue_id || !evidence || typeof accepted !== "boolean") {
       throw new TypeError("queue_id, evidence and boolean accepted required");
@@ -270,35 +183,8 @@ export class ChatGPTQueue {
     if (this.started) this._wake(0);
     return { ok: true, queue_id, state: accepted ? "SENT" : "WAITING" };
   }
-  start() {
-    if (this.started) return this;
-    this.started = true;
-    this.closed = false;
-    this._wake(0);
-    return this;
-  }
-  _wake(ms = this.intervalMs) {
-    if (this.closed) return;
-    clearTimeout(this.wakeTimer);
-    this.wakeTimer = setTimeout(() => this._tick(), ms);
-    this.wakeTimer.unref?.();
-  }
-  async _tick() {
-    if (this.closed) return;
-    while (this.active.size < this.concurrency) {
-      const owner = `dispatcher-${process.pid}-${randomUUID()}`;
-      const item = this.claim(owner);
-      if (!item) break;
-      const promise = this._process(item).catch((e) =>
-        this.logger({ event: "dispatcher_error", error: String(e) })
-      ).finally(() => {
-        this.active.delete(item.id);
-        this._wake(0);
-      });
-      this.active.set(item.id, promise);
-    }
-    if (!this.closed) this._wake(this.intervalMs);
-  }
+  process(item) { return this._process(item); }
+  onDispatchError(error) { this.logger({event:"dispatcher_error",error:String(error)}); }
   async _exec(sid, code) {
     const response = await this.execSession(sid, code);
     if (response?.ok === false) {
@@ -426,9 +312,7 @@ export class ChatGPTQueue {
   }
   async shutdown() {
     if (this.closed) return;
-    this.closed = true;
-    clearTimeout(this.wakeTimer);
-    await Promise.allSettled([...this.active.values()]);
+    await this.stopScheduler();
     for (const id of [...this.sessions.keys()]) await this._finish(id);
     this.db.close();
   }

package/runtime/cli-help.mjs

@@ -14,6 +14,8 @@ Commands:
   webhelm status                           Report browser and daemon status (JSON)
   webhelm ensure                           Check and recover managed Chrome health
   webhelm capacity                         Report available browser capacity (JSON)
+  webhelm queue list                       List active ChatGPT new-turn queue items
+  webhelm queue cancel QUEUE_ID             Cancel an item that is still queued
   webhelm session start [--url URL]        Start a persistent browser Session
   webhelm session list                    List CLI-owned Sessions
   webhelm session exec ID [--code-file F]  Run JavaScript in a Session
@@ -87,6 +89,15 @@ Output: JSON capacity information.
 
 Example:
   webhelm capacity`,
+  queue: `webhelm queue — inspect or cancel ChatGPT new-turn queue items
+
+Usage:
+  webhelm queue list
+  webhelm queue cancel QUEUE_ID
+
+Cancellation succeeds only while an item remains QUEUED. Items already being
+checked, sent, or awaiting reconciliation cannot be cancelled.
+Output: JSON queue state or cancellation receipt.`,
   migrate: `webhelm migrate — migrate supported legacy local browser data
 
 Usage:

package/runtime/cli.mjs

@@ -149,6 +149,15 @@ async function main(args = process.argv.slice(2)) {
     // reload an older daemon's Extension while its Sessions are still active.
     return emit(await request(payload));
   }
+  if (group === 'queue') {
+    if (command === 'list') return emit(await request({op:'queue-list'}));
+    if (command === 'cancel') {
+      const queueId=args[2];
+      if (!queueId) throw Error('queue cancel requires QUEUE_ID');
+      return emit(await request({op:'queue-cancel',queue_id:queueId}));
+    }
+    throw Error('queue requires list or cancel QUEUE_ID');
+  }
   if (group === 'session') {
     if (command === 'start') return emit(await request({op:'start', workspace:CLI_WORKSPACE, url:arg(args,'--url')}));
     if (command === 'list') {

package/runtime/durable-queue-core.mjs

@@ -0,0 +1,82 @@
+import { randomUUID } from "node:crypto";
+
+/**
+ * Queue-neutral transaction boundary for durable queue policies.
+ *
+ * Policies own their persistence schema, idempotency and payload semantics,
+ * merge rules, partition ordering, recovery rules, and public receipts. Every
+ * mutating operation is run in one immediate transaction so policy decisions
+ * (including optional enqueue-time merges) are atomic with persistence.
+ */
+export class DurableQueueCore {
+  constructor(db, policy, now = () => Date.now() / 1000, {concurrency = 1, intervalMs = 1000} = {}) {
+    if (!db || !policy) throw new TypeError("db and queue policy are required");
+    this.db = db;
+    this.policy = policy;
+    this.now = now;
+    this.concurrency = Math.max(1, Number(concurrency) || 1);
+    this.intervalMs = intervalMs;
+    this.active = new Map();
+    this.started = false;
+    this.closed = false;
+    this.wakeTimer = null;
+  }
+  _transaction(fn) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const value = fn();
+      this.db.exec("COMMIT");
+      return value;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  rows() { return this.policy.rows(this.db); }
+  enqueue(request) {
+    return this._transaction(() => this.policy.enqueue(this.db, request, this.now()));
+  }
+  claim(owner, now = this.now(), ...policyArgs) {
+    return this._transaction(() => this.policy.claim(this.db, owner, now, ...policyArgs));
+  }
+  cancel(id) {
+    return this._transaction(() => this.policy.cancel(this.db, id));
+  }
+  list() { return this.policy.list(this.db); }
+  start() {
+    if (this.started) return this;
+    this.started = true;
+    this.closed = false;
+    this._wake(0);
+    return this;
+  }
+  _wake(ms = this.intervalMs) {
+    if (this.closed) return;
+    clearTimeout(this.wakeTimer);
+    this.wakeTimer = setTimeout(() => this._tick(), ms);
+    this.wakeTimer.unref?.();
+  }
+  async _tick() {
+    if (this.closed) return;
+    while (this.active.size < this.concurrency) {
+      const owner = `queue-worker-${process.pid}-${randomUUID()}`;
+      const item = this.claim(owner);
+      if (!item) break;
+      const promise = Promise.resolve().then(() => this.process(item)).catch(error => {
+        this.onDispatchError(error);
+      }).finally(() => {
+        this.active.delete(item.id);
+        this._wake(0);
+      });
+      this.active.set(item.id, promise);
+    }
+    if (!this.closed) this._wake(this.intervalMs);
+  }
+  async process() { throw new Error("queue process handler is not implemented"); }
+  onDispatchError() {}
+  async stopScheduler() {
+    this.closed = true;
+    clearTimeout(this.wakeTimer);
+    await Promise.allSettled([...this.active.values()]);
+  }
+}

package/runtime/extension/control-channel.mjs

@@ -53,6 +53,7 @@ export class ControlChannel {
       sessions: connected ? state.daemon.sessions || [] : [],
       request: state.request || null,
       lastResult: state.lastResult || null,
+      queue: state.queue || [],
     };
   }
 
@@ -77,16 +78,31 @@ export class ControlChannel {
     });
   }
 
-  async heartbeat(sessions) {
+  async requestQueueCancel(queueId) {
+    return this.serialize(async () => {
+      if (typeof queueId !== 'string' || !queueId) throw new Error('Queue item is required');
+      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');
+      if (!(state.queue || []).some(item => item.id === queueId && item.state === 'QUEUED'))
+        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});
+      return {id:request.id,state:'pending'};
+    });
+  }
+
+  async heartbeat(sessions, queue = []) {
     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}});
+      await this.save({...state,daemon:{seenAt:this.now(),sessions},queue});
       return {updated:true};
     });
   }
 
-  async poll(sessions) {
+  async poll(sessions, queue = []) {
     return this.serialize(async () => {
       if (!Array.isArray(sessions) || sessions.some(s =>
         typeof s?.session_id !== 'string' || typeof s?.workspace !== 'string'))
@@ -95,10 +111,10 @@ export class ControlChannel {
       const request = state.request?.state === 'pending'
         ? {...state.request, state: 'processing'}
         : state.request || null;
-      await this.save({...state, request, daemon: {seenAt: this.now(), sessions}});
+      await this.save({...state, request, daemon: {seenAt: this.now(), sessions}, queue});
       return request?.state === 'processing' && state.request?.state === 'pending'
         ? {id: request.id, action: request.action, ...(request.sessionId ? {sessionId:request.sessionId} : {}),
-          ...(request.workspace ? {workspace:request.workspace} : {})}
+          ...(request.workspace ? {workspace:request.workspace} : {}), ...(request.queueId ? {queueId:request.queueId} : {})}
         : null;
     });
   }
@@ -111,7 +127,7 @@ export class ControlChannel {
       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: errors.length === 0, stoppedCount, errors, ...(response.queue_id ? {queue_id:response.queue_id,state:response.state} : {}), ...(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/control-rpc.mjs

@@ -0,0 +1,26 @@
+export function createControlRpc({control, manager, summarizeWorkspaces, scheduleBadge}) {
+  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};
+      }
+      case "workspace.control.requestStop":
+        return control.requestStop(args.action, args.sessionId, args.workspace);
+      case "workspace.control.queueCancel":
+        return control.requestQueueCancel(args.queueId);
+      case "workspace.control.heartbeat":
+        return control.heartbeat(args.sessions, args.queue);
+      case "workspace.control.poll": {
+        const result = await control.poll(args.sessions, args.queue);
+        scheduleBadge();
+        return result;
+      }
+      case "workspace.control.complete":
+        return control.complete(args.id, args.response);
+      default:
+        throw new Error("Unknown workspace control method");
+    }
+  };
+}

package/runtime/extension/popup.html

@@ -33,6 +33,10 @@
     .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-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; }
     #message { margin-top:8px; font-size:11px; overflow-wrap:anywhere; }
     #message:empty { display:none; }
     [hidden] { display:none !important; }
@@ -44,6 +48,8 @@
     <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>
   <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

@@ -74,6 +74,25 @@ function renderWorkspaces(workspaces, busy, connected) {
   }
 }
 
+function renderQueue(items, busy, connected) {
+  const target=el('queue-list');
+  target.replaceChildren();
+  if (!items.length) { target.textContent='No active turns'; return; }
+  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);
+  }
+}
+
 async function refresh() {
   if (refreshRunning) return;
   refreshRunning = true;
@@ -83,6 +102,7 @@ async function refresh() {
     el('daemon-status').className = `daemon-state ${state.connected ? 'online' : 'offline'}`;
     const busy = Boolean(state.request);
     renderWorkspaces(state.workspaces || [], busy, state.connected);
+    renderQueue(state.queue || [], busy, state.connected);
     el('confirm').disabled = !state.connected || busy;
     if (busy) {
       el('message').textContent = 'Stopping sessions…';

package/runtime/extension/service-worker.mjs

@@ -2,6 +2,7 @@ import { WorkspaceManager } from "./workspace-manager.mjs";
 import { ControlChannel } from "./control-channel.mjs";
 import { summarizeWorkspaces } from "./workspace-summary.mjs";
 import { sessionBadge } from "./session-badge.mjs";
+import { createControlRpc } from "./control-rpc.mjs";
 
 const manager = new WorkspaceManager(chrome);
 const control = new ControlChannel(chrome);
@@ -52,28 +53,7 @@ chrome.runtime.onStartup.addListener(() => {
   scheduleBadge();
 });
 
-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");
-  }
-}
+const controlRpc = createControlRpc({control, manager, summarizeWorkspaces, scheduleBadge});
 
 globalThis.browserWorkspaceManagerRpc = async (request) => {
   try {
@@ -112,7 +92,7 @@ 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))) {
+        !["workspace.control.requestStop", "workspace.control.queueCancel", "workspace.control.status"].includes(request.method))) {
     sendResponse({ok:false,error:{message:"WebHelm control actions require the toolbar popup"}});
     return false;
   }

package/runtime/extension-manager.mjs

@@ -12,7 +12,7 @@ export const EXTENSION_HOME=path.resolve(process.env.WEBHELM_EXTENSION_HOME ||
   (SOURCE_MODE ? SOURCE : path.join(LOCAL_ROOT,'extension')));
 const FILES=[
   'manifest.json','service-worker.mjs','workspace-manager.mjs','workspace.html','helm.html','workspace-page.mjs',
-  'control-channel.mjs','workspace-summary.mjs','session-badge.mjs','popup.html','popup.mjs',
+  'control-channel.mjs','control-rpc.mjs','workspace-summary.mjs','session-badge.mjs','popup.html','popup.mjs',
   ...[16,32,48,128].map(size => `icons/webhelm-${size}.png`),
 ];
 

package/runtime/node-daemon.mjs

@@ -8,7 +8,7 @@ import crypto from 'node:crypto';
 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 { idleUrlFromIdentity, sameIdleUrl, staleSession, withinDeadline, SessionDeadlineError } from './session-lifecycle.mjs';
 import { stopMatchingSessions } from './session-control.mjs';
 import { ensureManagedChrome } from './chrome.mjs';
 import { ensureExtensionLoaded } from './extension-manager.mjs';
@@ -173,8 +173,8 @@ const managedChromeGuard=createManagedChromeGuard(guardManagedChrome,{
 function adoptPopup(info){if(info?.type!=='page'||!info.openerId)return;const owner=targets.get(info.openerId);if(owner){owner.targets.add(info.targetId);targets.set(info.targetId,owner)}}
 async function attach(s,targetId,b=null){b ||= await connectBrowser();const {sessionId}=await b.send('Target.attachToTarget',{targetId,flatten:true});s.targets.add(targetId);s.attachments.set(targetId,sessionId);targets.set(targetId,s);for(const d of ['Page','DOM','Runtime','Network'])await b.send(`${d}.enable`,{},sessionId);for(const dispose of s.eventDisposers?.get(targetId)||[])dispose();const removers=[];for(const method of ['Page.loadEventFired','Page.domContentEventFired','Page.javascriptDialogOpening','Page.javascriptDialogClosed','Runtime.exceptionThrown','Network.requestWillBeSent','Network.responseReceived'])removers.push(b.on(method,(params,owner)=>{if(owner===sessionId){if(s.events.length>=500)s.events.shift();s.events.push({method,params,session_id:sessionId,target_id:targetId})}}));s.eventDisposers?.set(targetId,removers);return sessionId}
 function sidFor(s,targetId=s.targetId){const sid=s.attachments.get(targetId);if(!sid)throw new Error(`target ${targetId} is not attached to this session`);return sid}
-async function evaluate(s,expression,targetId=s.targetId,awaitPromise=true){if(!s.targets.has(targetId))throw Error('cannot evaluate a target outside the active WebHelm session');const b=await connectBrowser();const r=await b.send('Runtime.evaluate',{expression,returnByValue:true,awaitPromise,userGesture:true},sidFor(s,targetId));if(r.exceptionDetails)throw new Error(r.exceptionDetails.exception?.description||r.exceptionDetails.text);return r.result?.value}
-async function cdp(s,method,params={},targetId=s.targetId){if(method==='Target.createTarget')throw Error('Target.createTarget is disabled; use new_tab(url)');if(method==='Target.attachToTarget'||method==='Target.detachFromTarget')throw Error('direct target attachment changes are disabled in WebHelm sessions');if(['Target.closeTarget','Target.activateTarget'].includes(method)&&!s.targets.has(params.targetId))throw Error('cannot operate on a tab outside the active WebHelm session');if(method.startsWith('Target.')||method.startsWith('Browser.')||method.startsWith('ServiceWorker.'))return connectBrowser().then(b=>b.send(method,params));return connectBrowser().then(b=>b.send(method,params,sidFor(s,targetId)))}
+async function evaluate(s,expression,targetId=s.targetId,awaitPromise=true){if(s.poisoned || s.closing)throw Error('Session execution expired or closing');if(!s.targets.has(targetId))throw Error('cannot evaluate a target outside the active WebHelm session');const b=await connectBrowser();if(s.poisoned || s.closing)throw Error('Session execution expired or closing');const r=await b.send('Runtime.evaluate',{expression,returnByValue:true,awaitPromise,userGesture:true},sidFor(s,targetId));if(r.exceptionDetails)throw new Error(r.exceptionDetails.exception?.description||r.exceptionDetails.text);return r.result?.value}
+async function cdp(s,method,params={},targetId=s.targetId){if(s.poisoned || s.closing)throw Error('Session execution expired or closing');if(method==='Target.createTarget')throw Error('Target.createTarget is disabled; use new_tab(url)');if(method==='Target.attachToTarget'||method==='Target.detachFromTarget')throw Error('direct target attachment changes are disabled in WebHelm sessions');if(['Target.closeTarget','Target.activateTarget'].includes(method)&&!s.targets.has(params.targetId))throw Error('cannot operate on a tab outside the active WebHelm session');return connectBrowser().then(browser=>{if(s.poisoned || s.closing)throw Error('Session execution expired or closing');if(method.startsWith('Target.')||method.startsWith('Browser.')||method.startsWith('ServiceWorker.'))return browser.send(method,params);return browser.send(method,params,sidFor(s,targetId));})}
 function makeHelpers(s){
  const h={
   js:(expression,target_id)=>evaluate(s,expression,target_id||s.targetId),
@@ -183,9 +183,11 @@ function makeHelpers(s){
   async current_tab(){const info=await cdp(s,'Target.getTargetInfo',{targetId:s.targetId});return info.targetInfo},
   async new_tab(url='about:blank') {
     const browser=await connectBrowser();
+    if(s.poisoned || s.closing)throw Error('Session execution expired or closing');
     let targetId,lease;
     if(s.workspaceSupported){
       ({lease,targetId}=await acquireIdentityLease(s));
+      if(s.poisoned || s.closing){await extensionCall(s,'workspace.release',{name:s.workspace,tabId:lease.tabId});throw Error('Session execution expired');}
       s.leasedTabs.set(targetId,lease.tabId);
       s.idleUrls.set(targetId,lease.idleUrl);
     }else ({targetId}=await browser.send('Target.createTarget',{url:'about:blank'}));
@@ -200,6 +202,7 @@ function makeHelpers(s){
     if(!s.targets.has(tid))throw Error('cannot close a tab outside the active WebHelm Session');
     return leaseMutex(s.workspace).run(async()=>{
       const browser=await connectBrowser();
+      if(s.poisoned || s.closing)throw Error('Session execution expired or closing');
       if(s.leasedTabs.has(tid))await navigateIdle(browser,s,tid,s.idleUrls.get(tid));
       else await browser.send('Target.closeTarget',{targetId:tid}); // Popup without pool slot.
       const attachment=s.attachments.get(tid);
@@ -227,7 +230,7 @@ function makeHelpers(s){
   },
   async fill_input(selector,text){if(!await h.wait_for_element(selector))throw Error(`element not found: ${selector}`);return evaluate(s,`(()=>{const e=document.querySelector(${JSON.stringify(selector)});const set=Object.getOwnPropertyDescriptor(Object.getPrototypeOf(e),'value')?.set;if(set)set.call(e,${JSON.stringify(String(text))});else e.textContent=${JSON.stringify(String(text))};e.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:${JSON.stringify(String(text))}}));e.dispatchEvent(new Event('change',{bubbles:true}));return true})()`)},
   async click(selector){if(!await h.wait_for_element(selector))throw Error(`element not found: ${selector}`);return evaluate(s,`(()=>{const e=document.querySelector(${JSON.stringify(selector)});e.click();return true})()`)},
-  async capture_screenshot(pathname){const b=await connectBrowser();const data=await b.send('Page.captureScreenshot',{format:'png'},sidFor(s));if(pathname)fs.writeFileSync(pathname,Buffer.from(data.data,'base64'));return data.data},
+  async capture_screenshot(pathname){const b=await connectBrowser();if(s.poisoned || s.closing)throw Error('Session execution expired or closing');const data=await b.send('Page.captureScreenshot',{format:'png'},sidFor(s));if(s.poisoned || s.closing)throw Error('Session execution expired or closing');if(pathname)fs.writeFileSync(pathname,Buffer.from(data.data,'base64'));return data.data},
   async snapshot(interactive_only=false){const result=await evaluate(s,`(()=>{let n=0;const xs=[...document.querySelectorAll('button,a,input,textarea,select,[role],[tabindex]')].filter(e=>{const r=e.getBoundingClientRect(),s=getComputedStyle(e);return r.width&&r.height&&s.visibility!=='hidden'&&s.display!=='none'});return xs.map(e=>{const id='e'+(++n);e.setAttribute('data-ref',id);const role=e.getAttribute('role')||({BUTTON:'button',A:'link',INPUT:'textbox',TEXTAREA:'textbox',SELECT:'combobox'}[e.tagName]||e.tagName.toLowerCase());const name=e.getAttribute('aria-label')||e.innerText||e.value||e.placeholder||'';return '- '+role+' '+JSON.stringify(name.trim().slice(0,100))+' [ref='+id+']'}).join('\\n')})()`);return result||''},
   async workspace_status(){return extensionCall(s,'workspace.status',{name:s.workspace})},
   async workspace_capacity(){const r=await h.workspace_status();const idle=Array.isArray(r.idleTabIds)?r.idleTabIds.length:null,leased=Array.isArray(r.leasedTabIds)?r.leasedTabIds.length:null;return {name:r.name,poolSize:r.poolSize??null,maxCapacity:r.maxCapacity??r.poolSize??null,physicalTabs:r.physicalTabs??(idle!==null&&leased!==null?idle+leased:null),idle,leased,available:Number.isInteger(r.maxCapacity??r.poolSize)&&leased!==null?Math.max(0,(r.maxCapacity??r.poolSize)-leased):null}} ,
@@ -263,6 +266,22 @@ function makeHelpers(s){
   async current_url(){return (await h.page_info()).url},
   async title(){return (await h.page_info()).title}
  };
+ // Revoke even helper references retained by unresolved async VM scripts.
+ // A rejected async VM execution does not cancel browser operations it
+ // already started. Keep their tab ownership until those operations settle.
+ const effectHelpers=new Set(['js','cdp','goto_url','new_tab','close_tab','fill_input',
+   'click','capture_screenshot','snapshot','type_text','upload_file','switch_tab','activate_tab']);
+ for(const [name,helper] of Object.entries(h)){
+   if(typeof helper!=='function')continue;
+   h[name]=(...args)=>{
+     if(s.poisoned || s.closing)throw Error('Session execution expired or closing');
+     if(!effectHelpers.has(name))return helper(...args);
+     s.pendingEffects++;
+     try{
+       return Promise.resolve(helper(...args)).finally(()=>{s.pendingEffects--;});
+     }catch(error){s.pendingEffects--;throw error;}
+   };
+ }
  Object.defineProperty(h,'target_id',{get:()=>s.targetId});
  Object.defineProperty(h,'targetId',{get:()=>s.targetId});
  return h;
@@ -363,7 +382,7 @@ async function createSession(req={}) {
   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()};
+    inFlight:0, pendingEffects:0, closing:false, poisoned:false, last_used_at:Date.now()};
   let targetId,lease;
   try {
     if(await extensionSupported()) {
@@ -411,10 +430,10 @@ async function extensionSupported() {
 
 async function execute(req) {
   const s=sessions.get(req.session_id);
-  if(!s || s.closing)throw Error(`unknown session_id: ${req.session_id} (missing or closing)`);
+  if(!s || s.closing || s.poisoned)throw Error(`unknown session_id: ${req.session_id} (missing or closing)`);
   s.inFlight++;
   try {return await s.mutex.run(async()=>{
-    if(s.closing)throw Error('session closing');
+    if(s.closing || s.poisoned)throw Error('session closing or expired');
     s.last_used_at=Date.now();
     const logs=[],errors=[];
     const sandbox={...s.namespace};
@@ -427,12 +446,15 @@ async function execute(req) {
       if(last&&!last.endsWith(';')&&!/^(return|throw|if|for|while|function|class|\}|\/\/)/.test(last))lines[lines.length-1]=`return (${last})`;
       source=lines.join('\n');
       const script=new vm.Script(`(async()=>{${source}\n})()`,{filename:'<webhelm-session>'});
-      const result=await script.runInContext(s.context,{timeout:30000});
+      const timeoutMs=Math.max(30,Math.min(30000,Number(process.env.WEBHELM_SESSION_EXEC_TIMEOUT_MS)||30000));
+      const result=await withinDeadline(
+        Promise.resolve().then(()=>script.runInContext(s.context,{timeout:timeoutMs})),timeoutMs,'Session exec');
+      if(s.poisoned)throw Error('Session expired during execution');
       Object.assign(s.namespace,sandbox);
       const out={session_id:s.session_id,workspace:s.workspace,target_id:s.targetId,ok:true,stdout:logs.join('\n'),stderr:errors.join('\n')};
       if(result!==undefined)Object.assign(out,jsonSafe(result));
       return out;
-    }catch(e){return {session_id:s.session_id,workspace:s.workspace,target_id:s.targetId,ok:false,stdout:logs.join('\n'),stderr:errors.join('\n'),error:`${e.name}: ${e.message}`}}
+    }catch(e){if(e instanceof SessionDeadlineError || (e?.message||'').includes('Script execution timed out'))s.poisoned=true;return {session_id:s.session_id,workspace:s.workspace,target_id:s.targetId,ok:false,stdout:logs.join('\n'),stderr:errors.join('\n'),error:`${e.name}: ${e.message}`}}
   });} finally {s.inFlight--;s.last_used_at=Date.now();}
 }
 
@@ -456,6 +478,7 @@ async function navigateIdle(browser,s,targetId,idleUrl){
 async function closeSessionOwned(s){
   if(sessions.get(s.session_id)!==s)return {session_id:s.session_id,already_closed:true};
   s.closing=true;
+  s.poisoned=true; // Revoke delayed helpers after terminal close.
   let release_error=null;
   try {
     const returnedTabs=s.leasedTabs.size;
@@ -487,7 +510,7 @@ async function closeSessionOwned(s){
 async function reconcileWorkspaceSessions(workspace){
   const browser=await connectBrowser();
   for(const s of [...sessions.values()]){
-    if(s.workspace!==workspace||s.closing||s.inFlight>0)continue;
+    if(s.workspace!==workspace||s.closing||s.inFlight>0||s.pendingEffects>0)continue;
     let alreadyIdle=false;
     for(const [tid,idleUrl] of s.idleUrls){
       try {if(sameIdleUrl(await targetUrl(browser,tid),idleUrl)){alreadyIdle=true;break;}}
@@ -503,15 +526,39 @@ async function stopSession(sid){
   const s=sessions.get(sid);
   if(!s)throw Error(`unknown session_id: ${sid}`);
   s.closing=true;
-  // Do not hold the workspace allocation lock while an in-flight operation
-  // might be acquiring a new tab: that would deadlock its Session mutex.
-  await s.mutex.run(async()=>{});
-  return leaseMutex(s.workspace).run(()=>closeSessionOwned(s));
+  // A timeout does not cancel a queued mutex callback. Fence this stop
+  // attempt before it can touch a Session whose close request failed.
+  const attempt={valid:true,releaseStarted:false};
+  const timeoutMs=Math.max(50,Math.min(90000,Number(process.env.WEBHELM_SESSION_STOP_TIMEOUT_MS)||60000));
+  const deadline=performance.now()+timeoutMs;
+  try {
+    await withinDeadline(s.mutex.run(async()=>{}),timeoutMs,'Session stop drain');
+    // Browser effects already dispatched by an expired VM may outlive its
+    // mutex. They must settle before an idle Tab can be reassigned.
+    while(s.pendingEffects>0){
+      const remaining=deadline-performance.now();
+      if(remaining<=0)throw new SessionDeadlineError('Session stop effects',timeoutMs);
+      await withinDeadline(delay(Math.min(25,remaining)),remaining,'Session stop effects');
+    }
+    return await withinDeadline(leaseMutex(s.workspace).run(async()=>{
+      if(!attempt.valid)throw new SessionDeadlineError('Cancelled Session stop',timeoutMs);
+      attempt.releaseStarted=true;
+      return closeSessionOwned(s);
+    }),Math.max(1,deadline-performance.now()),'Session stop release');
+  }catch(error){
+    attempt.valid=false;
+    if(sessions.get(sid)===s && !attempt.releaseStarted){
+      s.closing=false;s.poisoned=true;
+    }
+    // If physical close already started, keep closing=true until its own
+    // success/failure path finishes; otherwise GC could race its navigation.
+    throw error;
+  }
 }
 
 function heartbeatSession(sid){
   const s=sessions.get(sid);
-  if(!s||s.closing)throw Error(`unknown session_id: ${sid} (missing or closing)`);
+  if(!s||s.closing||s.poisoned)throw Error(`unknown session_id: ${sid} (missing, closing or expired)`);
   s.last_used_at=Date.now();
   return {session_id:sid,alive:true,last_used_at:s.last_used_at};
 }
@@ -574,13 +621,13 @@ async function pollExtensionControl() {
   if (controlPollActive || shuttingDown) return;
   controlPollActive = true;
   try {
-    const pendingAction = await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions()});
+    const pendingAction = await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions(),queue:getChatGPTQueue().list().items});
     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()})
+      extensionCall(null,'workspace.control.heartbeat',{sessions:visibleSessions(),queue:getChatGPTQueue().list().items})
         .catch(error=>console.warn(`WebHelm control heartbeat: ${error.message}`));
     },3000);
     let response;
@@ -591,6 +638,8 @@ async function pollExtensionControl() {
         response = await stopWorkspaceSessions(pendingAction.workspace);
       } else if (action === 'stop') {
         response = {ok:true,stopped:await stopSession(sessionId)};
+      } else if (action === 'queue-cancel') {
+        response = getChatGPTQueue().cancel(pendingAction.queueId);
       } else {
         throw Error('Unknown extension control action');
       }
@@ -600,7 +649,7 @@ async function pollExtensionControl() {
       clearInterval(controlHeartbeat);
     }
     await extensionCall(null,'workspace.control.complete',{id,response});
-    await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions()});
+    await extensionCall(null,'workspace.control.poll',{sessions:visibleSessions(),queue:getChatGPTQueue().list().items});
   } catch(error) {
     console.warn(`WebHelm extension control sync failed: ${error.message}`);
   } finally {
@@ -629,25 +678,26 @@ async function runPlatform(req) {
   const sid=started.session_id;
   if (!sid) throw Error('platform run requires a session_id or auto_session');
   const session=sessions.get(sid);
-  if (!session) throw Error(`unknown session_id: ${sid}`);
+  if (!session || session.poisoned || session.closing) throw Error(`unknown session_id: ${sid}`);
   let result, cleanup;
   session.inFlight++;
   try {
     result=await session.mutex.run(async()=>{
+      if(session.poisoned||session.closing)throw Error('Session expired while waiting for platform action');
       const logs=[];
       const helpers=makeHelpers(session);
-      helpers.enqueueChatGPTTurn=request=>getChatGPTQueue().enqueue(request);
-      helpers.chatgptQueue=getChatGPTQueue();
       try {
-        const value=await invokePlatformAction(platform,action,{
+        const actionTimeoutMs=Math.max(50,Math.min(300000,Number(process.env.WEBHELM_PLATFORM_TIMEOUT_MS)||180000));
+        const value=await withinDeadline(Promise.resolve().then(()=>invokePlatformAction(platform,action,{
           helpers, config,
           log:(...items)=>logs.push(items.map(v=>typeof v==='string'?v:JSON.stringify(v)).join(' ')),
-        });
+        })),actionTimeoutMs,'Platform action');
         // Keep the legacy stdout JSON receipt for NeoY/Relay callers, while
         // retaining the structured `value` for new integrations. Do not print
         // a duplicate receipt if the Action already logged its JSON result.
         return {ok:true,stdout:actionOutput(logs,value),stderr:'',value};
       } catch(error) {
+        if(error instanceof SessionDeadlineError)session.poisoned=true;
         return {ok:false,stdout:logs.join('\n').slice(-40000),stderr:'',error:`${error.name}: ${error.message}`};
       }
     });
@@ -666,20 +716,28 @@ 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':return stopAllSessions();case'stop-workspace':{if(typeof req.workspace!=='string'||!req.workspace.trim())throw Error('workspace required');return stopWorkspaceSessions(req.workspace)}case'capacity':return workspaceCapacity(req);case'workspace-create':case'workspace-resize':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 = '';
+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'stop-workspace':{if(typeof req.workspace!=='string'||!req.workspace.trim())throw Error('workspace required');return stopWorkspaceSessions(req.workspace)}case'capacity':return workspaceCapacity(req);case'workspace-create':case'workspace-resize':case'workspace-delete':return workspaceOp(req);case'chatgpt-new-turn-enqueue':return getChatGPTQueue().enqueue(req.config);case'queue-list':return getChatGPTQueue().list();case'queue-cancel':return getChatGPTQueue().cancel(req.queue_id);case'platform-run':return runPlatform(req);default:throw Error(`unknown op: ${req.op}`)}}
+export function serve(conn) {
+  let buffer = '', dispatched = false;
+  conn.on('error',()=>{ /* A disconnected client must not crash the daemon. */ });
   conn.setEncoding('utf8');
   conn.on('data', async (chunk) => {
+    if(dispatched)return;
     buffer += chunk;
+    if(buffer.length>8_000_000){
+      dispatched=true;
+      if(!conn.destroyed)conn.end(JSON.stringify({error:'WebHelm IPC request too large'})+'\n');
+      return;
+    }
     const newline = buffer.indexOf('\n');
-    if (newline < 0) return;
+    if (newline < 0 || dispatched) return;
+    dispatched=true;
     const raw = buffer.slice(0, newline);
     try {
       const reply = await handle(JSON.parse(raw));
-      conn.end(JSON.stringify(reply) + '\n');
+      if(!conn.destroyed)conn.end(JSON.stringify(reply) + '\n');
     } catch (error) {
-      conn.end(JSON.stringify({ error: `${error.name}: ${error.message}` }) + '\n');
+      if(!conn.destroyed)conn.end(JSON.stringify({ error: `${error.name}: ${error.message}` }) + '\n');
     }
   });
 }
@@ -688,7 +746,47 @@ async function main(){fs.mkdirSync(RUNTIME,{recursive:true,mode:0o700});let lock
   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)})}
+// IPC duration is independent of the daemon's JS/Action execution timeout.
+// A wedged daemon can no longer strand CLI processes indefinitely.
+export function ipcTimeoutMs(op) {
+  const override=Number(process.env.WEBHELM_IPC_TIMEOUT_MS);
+  if(Number.isFinite(override) && override>0)
+    return Math.max(50,Math.min(300000,override));
+  return ({ping:5000,heartbeat:15000,list:15000,capacity:30000,
+    stop:90000,'stop-all':120000,'stop-workspace':120000,
+    exec:45000,'platform-run':240000,start:90000}[op] || 60000);
+}
+async function request(payload,ensure=true){
+  if(ensure)await ensureDaemon();
+  return new Promise((resolve,reject)=>{
+    const conn=net.createConnection(SOCKET);
+    const op=payload?.op||'unknown';
+    let data='',settled=false,deadlineTimer;
+    const finish=(error,result)=>{
+      if(settled)return;
+      settled=true;
+      clearTimeout(deadlineTimer);
+      conn.destroy();
+      if(error)reject(error);
+      else resolve(result);
+    };
+    conn.setEncoding('utf8');
+    deadlineTimer=setTimeout(()=>finish(Error('WebHelm IPC '+op+' timed out')),ipcTimeoutMs(op));
+    conn.on('connect',()=>conn.write(JSON.stringify(payload)+'\n'));
+    conn.on('data',chunk=>{
+      data+=chunk;
+      if(data.length>8_000_000)return finish(Error('WebHelm IPC response too large'));
+      const newline=data.indexOf('\n');
+      if(newline<0)return;
+      try{
+        const result=JSON.parse(data.slice(0,newline));
+        result.error?finish(Error(String(result.error))):finish(null,result);
+      }catch(error){finish(error)}
+    });
+    conn.on('end',()=>{if(!settled)finish(Error('WebHelm IPC '+op+' closed without response'))});
+    conn.on('error',error=>finish(error));
+  });
+}
 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)});
 export {request,SOCKET,RUNTIME};

package/runtime/session-lifecycle.mjs

@@ -1,9 +1,32 @@
 // A Session is live only while its owner performs operations or renews its heartbeat.
 export const SESSION_IDLE_MS = 5 * 60 * 1000;
 
+export class SessionDeadlineError extends Error {
+  constructor(operation, milliseconds) {
+    super(operation + ' exceeded ' + milliseconds + 'ms deadline');
+    this.name = 'SessionDeadlineError';
+  }
+}
+
+// A VM timeout cannot terminate an unresolved async Promise.
+// Callers must revoke Session helpers when a deadline expires.
+export async function withinDeadline(promise, milliseconds, operation) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new SessionDeadlineError(operation, milliseconds)), milliseconds);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export function staleSession(session, now = Date.now(), ttl = SESSION_IDLE_MS) {
-  return !session.closing && !(session.inFlight > 0) &&
-    now - session.last_used_at >= ttl;
+  return !session.closing && !(session.inFlight > 0) && !(session.pendingEffects > 0) &&
+    (session.poisoned === true || now - session.last_used_at >= ttl);
 }
 
 export function idleUrlFromIdentity(identityUrl) {