webhelm 1.0.18 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webhelm",
-  "version": "1.0.18",
+  "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

@@ -621,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;
@@ -638,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');
       }
@@ -647,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 {
@@ -684,11 +686,6 @@ async function runPlatform(req) {
       if(session.poisoned||session.closing)throw Error('Session expired while waiting for platform action');
       const logs=[];
       const helpers=makeHelpers(session);
-      helpers.enqueueChatGPTTurn=request=>{
-        if(session.poisoned||session.closing)throw Error('Session execution expired or closing');
-        return getChatGPTQueue().enqueue(request);
-      };
-      helpers.chatgptQueue={enqueue:helpers.enqueueChatGPTTurn};
       try {
         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,{
@@ -719,7 +716,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':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}`)}}
+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. */ });