vg-coder-cli 2.0.62 → 2.0.64

package/INTEGRATION.md

@@ -105,6 +105,7 @@ ssh ... "docker exec chrome-mcp-vgcoder supervisorctl restart chromium"
 | `webhookUrl` | no | URL nhận callback khi task xong |
 | `meta` | no | JSON string, đính kèm metadata tùy ý (forward nguyên về webhook) |
 | `workerLabel` | no | Email worker để pin task vào tài khoản cụ thể (vd `alice@gmail.com`) |
+| `chromeId` | no | UUID Chrome profile để pin task vào **exact profile** (precedence > `workerLabel`). Dùng khi cần Best-of-N parallel runs hoặc khi 2 profile share cùng email. Nếu `chromeId` không match launcher/worker đang kết nối → **404 `launcher_not_found`** (không silent fallback). |
 
 **Response 202**
 
@@ -133,6 +134,7 @@ ssh ... "docker exec chrome-mcp-vgcoder supervisorctl restart chromium"
   "webhook": { "attempts": [{ "at": 0, "status": 200 }], "deliveredAt": 0 },
   "worker": { "socketId": "...", "email": "alice@gmail.com", "chatId": "..." },
   "workerLabel": null,
+  "chromeId": null,
   "attempts": [
     { "workerEmail": "alice@gmail.com", "code": "rate_limit_exceeded", "at": 0 }
   ],
@@ -170,6 +172,7 @@ Worker dùng để fetch file đã upload. Caller thường không gọi.
     {
       "id": "abc...",
       "email": "alice@gmail.com",
+      "chromeId": "75cd593d-a861-4a6f-89a0-386e1e9e61c5",
       "status": "idle|busy|rate_limited",
       "currentTaskId": null,
       "cooldownUntil": 1778252081156,
@@ -211,15 +214,29 @@ Server có thể chủ động list / đóng / mở tab AI Studio trong từng p
 
 | Method | Path | Body / Query | Mô tả |
 |---|---|---|---|
-| `GET` | `/api/launcher/tabs` | `?label=<email>` (optional) | List tabs trong profile (hoặc all profiles nếu bỏ label) |
-| `POST` | `/api/launcher/close-tab` | `{ workerLabel?, tabId? }` | Đóng tab cụ thể, hoặc tất cả tab AI Studio nếu bỏ `tabId` |
-| `POST` | `/api/launcher/open-tab` | `{ workerLabel?, model?, url?, active? }` | Mở tab mới. `model` mặc định `gemini-3-flash-preview`. Response v2.0.52+ kèm `requested_model` / `actual_model` / `fallback_occurred` (URL-based, **không reliable** với AI Studio versions mới — xem note) |
+| `GET` | `/api/launcher/tabs` | `?chromeId=<uuid>` \| `?label=<email>` (optional) | List tabs trong profile (hoặc all profiles nếu bỏ pin) |
+| `POST` | `/api/launcher/close-tab` | `{ chromeId? \| workerLabel?, tabId?, all? }` | Đóng tab cụ thể, hoặc tất cả tab AI Studio nếu bỏ `tabId` |
+| `POST` | `/api/launcher/open-tab` | `{ chromeId? \| workerLabel?, model?, url?, active? }` | Mở tab mới. `model` mặc định `gemini-3-flash-preview`. Response v2.0.52+ kèm `requested_model` / `actual_model` / `fallback_occurred` (URL-based, **không reliable** với AI Studio versions mới — xem note) |
+
+**Pin precedence**: `chromeId` > `workerLabel` > default. `chromeId` chỉ exact-match một
+launcher cụ thể — dùng để address **profile chưa bind email** (mới cài extension,
+chưa mở AI Studio lần nào → `email: null` trong `/api/launchers`). Sau khi `open-tab`
+load AI Studio, DOM scraper bind email tự động và lần sau có thể dùng `workerLabel`.
+
+**Error contract** (v2.0.64+): explicit pin không match → HTTP **404
+`launcher_not_found`**. Không có launcher nào kết nối → HTTP **503
+`no_launcher_connected`**. Trước v2.0.64, mọi miss đều silent fallback sang
+launcher khác — phá invariant pin của orchestrator.
 
 ```bash
 # List tab tất cả profile
 curl -s http://127.0.0.1:6868/api/launcher/tabs | jq
 
-# Reset tab profile alice về model multimodal
+# Bootstrap profile mới (chưa có email) — open AI Studio bằng chromeId
+curl -X POST -d '{"chromeId":"81b9b30c-f9de-4920-899c-9ca3782fa3d7","model":"gemini-3.1-pro-preview"}' \
+  -H 'Content-Type: application/json' http://127.0.0.1:6868/api/launcher/open-tab
+
+# Reset tab profile alice về model multimodal (vẫn route by email — backward compat)
 curl -X POST -d '{"workerLabel":"alice@gmail.com"}' \
   -H 'Content-Type: application/json' http://127.0.0.1:6868/api/launcher/close-tab
 curl -X POST -d '{"workerLabel":"alice@gmail.com","model":"gemini-3-flash-preview"}' \

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.62",
+  "version": "2.0.64",
   "description": "🚀 CLI tool to analyze projects, concatenate source files, count tokens, and export HTML with syntax highlighting and copy functionality",
   "main": "src/index.js",
   "bin": {

package/src/server/api-server.js

@@ -555,6 +555,26 @@ class ApiServer {
             const workerLabel = req.body?.workerLabel
                 ? String(req.body.workerLabel).toLowerCase().trim()
                 : null;
+            // chromeId pin — addresses an exact Chrome profile, independent
+            // of email binding. Precedence over workerLabel during dispatch.
+            // If the chromeId isn't connected (launcher or worker), reject
+            // with 404 — no silent fallback to a different profile.
+            const chromeId = req.body?.chromeId
+                ? String(req.body.chromeId).trim()
+                : null;
+            if (chromeId) {
+                const knownLauncher = [...taskQueue.launchers.values()]
+                    .some(l => l.chromeId === chromeId);
+                const knownWorker = [...taskQueue.workers.values()]
+                    .some(w => w.chromeId === chromeId);
+                if (!knownLauncher && !knownWorker) {
+                    return res.status(404).json({
+                        error: 'launcher_not_found',
+                        chromeId,
+                        message: 'No connected launcher or worker matches chromeId'
+                    });
+                }
+            }
 
             const id = taskStore.newTaskId();
             const finalDir = taskStore.taskDir(req.workingDir, id);
@@ -584,6 +604,7 @@ class ApiServer {
                 webhook: { attempts: [], deliveredAt: null },
                 worker: null,
                 workerLabel,
+                chromeId,
                 attempts: [],
                 result: null,
                 error: null,
@@ -668,47 +689,94 @@ class ApiServer {
         res.json({ workers: taskQueue.listWorkers() });
     });
 
+    // Reset cooldown manually. Useful khi operator chắc chắn AI Studio đã hết
+    // rate-limit (vd quan sát qua noVNC submit prompt được) nhưng server timer
+    // 30 phút chưa expire. Body: { email: "alice@gmail.com" } hoặc {} cho tất cả.
+    this.app.post('/api/workers/reset-cooldown', (req, res) => {
+        const targetEmail = (req.body?.email || '').toString().toLowerCase().trim();
+        const reset = [];
+        for (const w of taskQueue.workers.values()) {
+            if (w.status !== 'rate_limited') continue;
+            if (targetEmail && w.email !== targetEmail) continue;
+            w.status = 'idle';
+            w.cooldownUntil = 0;
+            w.lastFailureCode = null;
+            w.lastFailureMessage = null;
+            reset.push({ id: w.id, email: w.email });
+        }
+        if (reset.length) setImmediate(() => taskQueue._drain());
+        res.json({ ok: true, reset, count: reset.length });
+    });
+
     this.app.get('/api/launchers', (req, res) => {
         res.json({ launchers: taskQueue.listLaunchers() });
     });
 
-    // List AI Studio tabs across all profiles (or 1 if workerLabel given).
+    // Translate task-queue errors to HTTP status. `launcher_not_found` is the
+    // contract for an explicit chromeId/workerLabel pin that doesn't match any
+    // connected launcher — distinct from `no_launcher_connected` (no launchers
+    // at all). Callers rely on 404 to decide retry-vs-give-up.
+    const launcherErr = (e) => {
+        if (e.message === 'launcher_not_found') return 404;
+        if (e.message === 'no_launcher_connected') return 503;
+        return 503;
+    };
+    // Build opts from body/query. chromeId takes precedence over workerLabel
+    // (mirrors task-queue _pickLauncher precedence). `all: true` only honored
+    // when neither pin is provided.
+    const launcherOpts = (body = {}, query = {}) => {
+        const chromeId = (body.chromeId || query.chromeId || '').toString().trim();
+        if (chromeId) return { chromeId };
+        const label = (body.workerLabel || query.workerLabel || query.label || '').toString().trim();
+        if (label) return { workerLabel: label };
+        return null;  // caller decides between {all:true} and {} default
+    };
+
+    // List AI Studio tabs across all profiles (or 1 if pinned).
+    // Query/body: chromeId? | workerLabel?
     this.app.get('/api/launcher/tabs', async (req, res) => {
         try {
-            const label = (req.query?.label || req.query?.workerLabel || '').toString().trim();
-            const opts = label ? { workerLabel: label } : { all: true };
+            const opts = launcherOpts({}, req.query) || { all: true };
             const result = await taskQueue.requestLauncher('launcher:list_tabs', {}, opts, 5_000);
             res.json(result);
-        } catch (e) { res.status(503).json({ error: e.message }); }
+        } catch (e) { res.status(launcherErr(e)).json({ error: e.message }); }
     });
 
-    // Close tab(s). Body: { workerLabel?, tabId? } — omit tabId to close all.
+    // Close tab(s). Body: { chromeId? | workerLabel?, tabId?, all? }
+    // Omit tabId to close all tabs in the matched profile.
     this.app.post('/api/launcher/close-tab', async (req, res) => {
         try {
             const body = req.body || {};
-            const opts = body.workerLabel ? { workerLabel: body.workerLabel } : (body.all ? { all: true } : {});
+            const opts = launcherOpts(body) || (body.all ? { all: true } : {});
             const payload = body.tabId != null ? { tabId: body.tabId } : {};
             const result = await taskQueue.requestLauncher('launcher:close_tab', payload, opts, 5_000);
             res.json(result);
-        } catch (e) { res.status(503).json({ error: e.message }); }
+        } catch (e) { res.status(launcherErr(e)).json({ error: e.message }); }
     });
 
-    // Open new AI Studio tab. Body: { workerLabel?, model?, url?, active? }
+    // Open new AI Studio tab.
+    // Body: { chromeId? | workerLabel?, model?, url?, active? }
+    // chromeId is the only way to address an unbound launcher (email still
+    // null because the extension hasn't scraped AI Studio yet) — opening a
+    // tab via chromeId triggers the DOM scrape which binds the email.
     this.app.post('/api/launcher/open-tab', async (req, res) => {
         try {
             const body = req.body || {};
-            const opts = body.workerLabel ? { workerLabel: body.workerLabel } : {};
+            const opts = launcherOpts(body) || {};
             const payload = { url: body.url, model: body.model, active: body.active };
-            // Pin model cho worker (theo email) — _recycleWorkerTab sau task done
-            // sẽ reopen tab với cùng model, giữ lock qua nhiều task. Nếu caller
-            // không truyền workerLabel, pin cho TẤT CẢ launcher email hiện tại
-            // (single-tenant case phổ biến: 1 container = 1 worker).
+            // Pin model so _recycleWorkerTab reopens with the same model.
+            // Key precedence: chromeId (exact profile) > workerLabel (email).
+            // No pin field → broadcast: pin every connected launcher under
+            // both its chromeId and email (single-tenant ergonomics).
             if (body.model) {
-                if (body.workerLabel) {
-                    taskQueue._pinnedModelByEmail.set(body.workerLabel, body.model);
+                if (opts.chromeId) {
+                    taskQueue._pinnedModelByLauncher.set(opts.chromeId, body.model);
+                } else if (opts.workerLabel) {
+                    taskQueue._pinnedModelByLauncher.set(opts.workerLabel, body.model);
                 } else {
                     for (const l of taskQueue.launchers.values()) {
-                        if (l.email) taskQueue._pinnedModelByEmail.set(l.email, body.model);
+                        if (l.chromeId) taskQueue._pinnedModelByLauncher.set(l.chromeId, body.model);
+                        if (l.email) taskQueue._pinnedModelByLauncher.set(l.email, body.model);
                     }
                 }
             }
@@ -717,7 +785,7 @@ class ApiServer {
             // phải lớn hơn để có response thay vì error.
             const result = await taskQueue.requestLauncher('launcher:open_tab', payload, opts, 15_000);
             res.json(result);
-        } catch (e) { res.status(503).json({ error: e.message }); }
+        } catch (e) { res.status(launcherErr(e)).json({ error: e.message }); }
     });
 
     this.app.get('/api/worker/status', (req, res) => {

package/src/server/task-queue.js

@@ -38,10 +38,11 @@ class TaskQueue {
     // AI Studio tab (free CPU). Cancelled when a new task arrives or a worker
     // recycles for that email.
     this._idleCloseTimers = new Map();
-    // workerEmail → model string. Set qua /api/launcher/open-tab body.model;
-    // recycle dùng để reopen tab với cùng model (giữ pin qua nhiều task).
-    // Default null → recycle dùng AISTUDIO_DEFAULT_MODEL của extension.
-    this._pinnedModelByEmail = new Map();
+    // launcher key (chromeId hoặc email fallback) → model string. Set qua
+    // /api/launcher/open-tab body.model; recycle dùng để reopen tab với cùng
+    // model (giữ pin qua nhiều task). Default null → recycle dùng
+    // AISTUDIO_DEFAULT_MODEL của extension.
+    this._pinnedModelByLauncher = new Map();
   }
 
   attachIO(io) {
@@ -109,13 +110,22 @@ class TaskQueue {
 
   listWorkers() {
     const out = [];
+    const now = Date.now();
     for (const w of this.workers.values()) {
+      const cd = w.cooldownUntil || 0;
+      const remainingMs = cd > now ? cd - now : 0;
       out.push({
         id: w.id,
         email: w.email,
+        chromeId: w.chromeId || null,
         status: w.status,
         currentTaskId: w.currentTaskId,
-        cooldownUntil: w.cooldownUntil || 0,
+        cooldownUntil: cd,
+        cooldownUntilISO: cd ? new Date(cd).toISOString() : null,
+        cooldownRemainingMs: remainingMs,
+        cooldownRemainingMinutes: Math.ceil(remainingMs / 60_000),
+        lastFailureCode: w.lastFailureCode || null,
+        lastFailureMessage: w.lastFailureMessage || null,
         lastSeen: w.lastSeen,
         meta: { domain: w.meta?.domain, chatId: w.meta?.chatId, registeredAt: w.meta?.registeredAt }
       });
@@ -160,14 +170,17 @@ class TaskQueue {
       if (meta?.chromeId && email && !email.startsWith('unknown:')) {
         this._bindChromeIdToEmail(meta.chromeId, email);
       }
+      // Phase 1: chromeId comes from worker meta if extension passes it,
+      // else reverse-lookup from chromeIdToEmail. Phase 2 will require it.
+      existing.chromeId = meta?.chromeId || this._emailToChromeId(email) || existing.chromeId || null;
       if (wasUnknown && email !== existing.email) {
         // shouldn't happen — kept for clarity (email already assigned above)
       }
       // Re-establish pin từ URL hiện tại của tab worker. Khắc phục race khi
-      // open-tab handler set _pinnedModelByEmail nhưng launcher email lúc đó
+      // open-tab handler set _pinnedModelByLauncher nhưng launcher email lúc đó
       // null (chưa scrape) → pin bị mất → recycle reopen với default.
       if (meta?.pinnedModel && !email.startsWith('unknown:')) {
-        this._pinnedModelByEmail.set(email, meta.pinnedModel);
+        this._pinnedModelByLauncher.set(email, meta.pinnedModel);
       }
       console.log(chalk.green(`[TaskQueue] Worker re-register: ${socket.id} (${email})${meta?.pinnedModel ? ` pinned=${meta.pinnedModel}` : ''}`));
       setImmediate(() => this._drain());
@@ -178,6 +191,10 @@ class TaskQueue {
       socket,
       id: socket.id,
       email,
+      // Phase 1: chromeId may be absent until extension bundle propagates it.
+      // Reverse-lookup from chromeIdToEmail fills the gap for already-bound
+      // profiles. Recycle/dispatch paths prefer chromeId when present.
+      chromeId: meta?.chromeId || this._emailToChromeId(email) || null,
       meta: { ...(meta || {}), registeredAt: Date.now() },
       status: 'idle',
       currentTaskId: null,
@@ -192,7 +209,7 @@ class TaskQueue {
     }
     // Re-establish pin từ URL hiện tại (xem comment ở re-register branch).
     if (meta?.pinnedModel && !email.startsWith('unknown:')) {
-      this._pinnedModelByEmail.set(email, meta.pinnedModel);
+      this._pinnedModelByLauncher.set(email, meta.pinnedModel);
     }
     console.log(chalk.green(`[TaskQueue] Worker registered: ${socket.id} (${email})${meta?.pinnedModel ? ` pinned=${meta.pinnedModel}` : ''}`));
     setImmediate(() => this._drain());
@@ -243,14 +260,44 @@ class TaskQueue {
     for (const l of this.launchers.values()) {
       if (l.chromeId === chromeId) l.email = email;
     }
+    // Backfill worker.chromeId for already-connected workers in this profile
+    // (Phase 1 reverse-lookup: workers register before launcher binds email).
+    for (const w of this.workers.values()) {
+      if (!w.chromeId && (w.email || '').toLowerCase() === email.toLowerCase()) {
+        w.chromeId = chromeId;
+      }
+    }
+  }
+
+  // Reverse lookup: find chromeId bound to email. Returns the first match —
+  // if two launchers login the same email (test vs prod), this is ambiguous
+  // and the caller should prefer explicit chromeId routing instead.
+  _emailToChromeId(email) {
+    if (!email || email.startsWith('unknown:')) return null;
+    const lc = email.toLowerCase();
+    for (const [cid, em] of this.chromeIdToEmail) {
+      if (em && em.toLowerCase() === lc) return cid;
+    }
+    return null;
   }
 
   /**
-   * Pick a connected launcher matching the task's pin (or any launcher if no
-   * pin). Returns null if none.
+   * Pick a connected launcher. Precedence: explicit chromeId from opts/task,
+   * then workerLabel (email), then any launcher. Returns null if the explicit
+   * pin doesn't match a connected launcher — callers MUST treat this as a
+   * hard miss (404), not silently dispatch elsewhere.
+   *
+   * Accepts either a task ({ chromeId?, workerLabel? }) or raw opts object.
    */
   _pickLauncher(task) {
     if (!this.launchers.size) return null;
+    const chromeId = task?.chromeId ? String(task.chromeId).trim() : null;
+    if (chromeId) {
+      for (const l of this.launchers.values()) {
+        if (l.chromeId === chromeId) return l;
+      }
+      return null;  // explicit chromeId pin — no silent fallback
+    }
     const pin = task?.workerLabel ? task.workerLabel.toLowerCase() : null;
     if (pin) {
       for (const l of this.launchers.values()) {
@@ -273,8 +320,13 @@ class TaskQueue {
 
   /**
    * Send a request to one or all connected launchers and await their ack.
-   * opts: { workerLabel?, all? } — pin to a specific profile by email,
-   * or `all: true` to broadcast and aggregate replies from every launcher.
+   * opts: { chromeId?, workerLabel?, all? } — chromeId pins to an exact
+   * Chrome profile (precedence over workerLabel), workerLabel pins by email,
+   * `all: true` broadcasts and aggregates replies from every launcher.
+   *
+   * Rejects with `launcher_not_found` (not `no_launcher_connected`) when an
+   * explicit pin fails to match — callers can map that to HTTP 404 instead of
+   * silently falling back to a different profile.
    */
   requestLauncher(event, payload = {}, opts = {}, timeoutMs = 5_000) {
     if (opts.all) {
@@ -298,8 +350,15 @@ class TaskQueue {
       })));
     }
     return new Promise((resolve, reject) => {
-      const launcher = this._pickLauncher({ workerLabel: opts.workerLabel || null });
-      if (!launcher) return reject(new Error('no_launcher_connected'));
+      const hasExplicitPin = !!(opts.chromeId || opts.workerLabel);
+      const launcher = this._pickLauncher({
+        chromeId: opts.chromeId || null,
+        workerLabel: opts.workerLabel || null,
+      });
+      if (!launcher) {
+        if (hasExplicitPin) return reject(new Error('launcher_not_found'));
+        return reject(new Error('no_launcher_connected'));
+      }
       let done = false;
       const timer = setTimeout(() => {
         if (done) return;
@@ -351,6 +410,7 @@ class TaskQueue {
     task.timing.queuedAt = Date.now();
     task.attempts = task.attempts || [];
     task.workerLabel = task.workerLabel || null;
+    task.chromeId = task.chromeId || null;
     await store.saveTask(task);
     this.cache.set(task.id, task);
     this.pending.push({ id: task.id, workingDir: task.workingDir });
@@ -418,13 +478,14 @@ class TaskQueue {
       return;
     }
     const workerEmail = worker.email;
+    const workerChromeId = worker.chromeId || null;
     worker.currentTaskId = null;
     worker.status = 'idle';
     worker.lastSeen = Date.now();
 
     if (task.cancelRequestedAt) {
       // discard result; still recycle the tab so next task gets a clean slate
-      this._recycleWorkerTab(workerEmail);
+      this._recycleWorkerTab(workerEmail, workerChromeId);
       setImmediate(() => this._drain());
       return;
     }
@@ -445,7 +506,7 @@ class TaskQueue {
     // model URL pinned. AI Studio's "+ New chat" link drops the ?model=
     // query and Angular routerLink ignores href hijack — close+reopen via
     // launcher is the only deterministic way to lock the model per task.
-    this._recycleWorkerTab(workerEmail);
+    this._recycleWorkerTab(workerEmail, workerChromeId);
     // Drain right away so other idle workers pick up queued tasks while
     // this worker's tab is being recycled (~5s).
     setImmediate(() => this._drain());
@@ -459,13 +520,14 @@ class TaskQueue {
       return;
     }
     const workerEmail = worker.email;
+    const workerChromeId = worker.chromeId || null;
     await this._failOrRequeue(task, worker, error);
     // Only recycle if the worker isn't in cooldown (rate-limited workers
     // have their tab still open intentionally — recycling won't unfreeze
     // the quota and just wastes a tab cycle).
     const w = this.workers.get(socketId);
     if (!w || w.status !== 'rate_limited') {
-      this._recycleWorkerTab(workerEmail);
+      this._recycleWorkerTab(workerEmail, workerChromeId);
     } else {
       setTimeout(() => this._drain(), INTER_TASK_GAP_MS);
     }
@@ -477,34 +539,44 @@ class TaskQueue {
    * clearWorker; the open creates a new tab whose worker registers ~3-5s
    * later. _drain runs naturally on register so any queued task picks up
    * the fresh worker. Fire-and-forget — errors are logged but don't bubble.
+   *
+   * Prefers chromeId routing when provided (exact profile) — falls back to
+   * workerEmail when chromeId is unknown (e.g. extension hasn't propagated
+   * chromeId yet in Phase 1).
    */
-  _recycleWorkerTab(workerEmail) {
+  _recycleWorkerTab(workerEmail, chromeId = null) {
     if (!workerEmail || workerEmail.startsWith('unknown:')) return;
     // Cancel any pending idle-close — we're about to recycle, no need to close
     // separately. (This handles the race where a task lands during the idle
     // window: drain triggers recycle, idle timer becomes redundant.)
     this._cancelIdleClose(workerEmail);
-    // Mark every worker matching this email as 'recycling' so _drain skips
-    // them while the close+open is in flight. Without this, a queued task
-    // can race in and get dispatched to a worker whose tab is about to
-    // close, leading to a stuck "running" task that never completes.
+    // Mark workers in this profile as 'recycling' so _drain skips them. Match
+    // by chromeId when present (exact profile), else by email (covers the
+    // chromeId-unknown path).
     for (const w of this.workers.values()) {
-      if (w.email === workerEmail && w.status === 'idle') w.status = 'recycling';
-    }
+      const matches = chromeId
+        ? w.chromeId === chromeId
+        : w.email === workerEmail;
+      if (matches && w.status === 'idle') w.status = 'recycling';
+    }
+    // Route launcher calls by chromeId when known, email otherwise.
+    const routeOpts = chromeId ? { chromeId } : { workerLabel: workerEmail };
+    const pinKey = chromeId || workerEmail;
     // If WORKER_IDLE_TTL_MS === 1, treat post-task recycle as close-only:
     // skip reopen; let _autoLaunchBrowser open a fresh tab when next task lands.
     const closeOnly = WORKER_IDLE_TTL_MS === 1;
     setImmediate(async () => {
       try {
-        await this.requestLauncher('launcher:close_tab', {}, { workerLabel: workerEmail }, 5_000);
+        await this.requestLauncher('launcher:close_tab', {}, routeOpts, 5_000);
         if (closeOnly) {
           console.log(chalk.cyan(`[TaskQueue] Closed tab for ${workerEmail} (VG_WORKER_IDLE_TTL_MS=1)`));
           return;
         }
         await new Promise(r => setTimeout(r, 400));
-        const pinned = this._pinnedModelByEmail.get(workerEmail);
+        const pinned = this._pinnedModelByLauncher.get(pinKey)
+                    || this._pinnedModelByLauncher.get(workerEmail);
         const openPayload = pinned ? { model: pinned } : {};
-        await this.requestLauncher('launcher:open_tab', openPayload, { workerLabel: workerEmail }, 8_000);
+        await this.requestLauncher('launcher:open_tab', openPayload, routeOpts, 8_000);
         console.log(chalk.cyan(`[TaskQueue] Recycled tab for ${workerEmail}${pinned ? ` (model=${pinned})` : ''}`));
         // Schedule idle close. If new task arrives before TTL, enqueue() will
         // cancel this timer.
@@ -513,7 +585,8 @@ class TaskQueue {
         console.log(chalk.yellow(`[TaskQueue] Recycle ${workerEmail} failed: ${err.message}`));
         // Restore status if recycle failed and worker still in registry.
         for (const w of this.workers.values()) {
-          if (w.email === workerEmail && w.status === 'recycling') w.status = 'idle';
+          const matches = chromeId ? w.chromeId === chromeId : w.email === workerEmail;
+          if (matches && w.status === 'recycling') w.status = 'idle';
         }
         setImmediate(() => this._drain());
       }
@@ -535,12 +608,23 @@ class TaskQueue {
     this._cancelIdleClose(workerEmail);
     const t = setTimeout(() => {
       this._idleCloseTimers.delete(workerEmail);
+      // Collect chromeIds bound to this email so we can spot chromeId-pinned
+      // tasks targeting the same profile.
+      const myChromeIds = new Set();
+      for (const w of this.workers.values()) {
+        if (w.email === workerEmail && w.chromeId) myChromeIds.add(w.chromeId);
+      }
+      for (const [cid, em] of this.chromeIdToEmail) {
+        if (em === workerEmail) myChromeIds.add(cid);
+      }
       // Skip if a task is already queued for this worker (or workerless).
       const hasPendingForEmail = this.pending.some(p => {
         const task = this.cache.get(p.id);
         if (!task) return false;
-        if (!task.workerLabel) return true;
-        return task.workerLabel.toLowerCase() === workerEmail;
+        if (task.chromeId && myChromeIds.has(task.chromeId)) return true;
+        if (!task.workerLabel && !task.chromeId) return true;
+        if (task.workerLabel && task.workerLabel.toLowerCase() === workerEmail) return true;
+        return false;
       });
       if (hasPendingForEmail) return;
       // Skip if any worker for this email is busy/recycling (in-flight work).
@@ -567,6 +651,22 @@ class TaskQueue {
     // When a task is enqueued, cancel any idle-close timers that could
     // otherwise close a tab we're about to dispatch to.
     if (!task) return;
+    if (task.chromeId) {
+      // chromeId pin → resolve to email via connected worker (or chromeIdToEmail
+      // map) and cancel that email's timer. Idle timers are still keyed by
+      // email since the close-tab socket message routes per-launcher anyway.
+      let email = this.chromeIdToEmail.get(task.chromeId);
+      if (!email) {
+        for (const w of this.workers.values()) {
+          if (w.chromeId === task.chromeId && w.email && !w.email.startsWith('unknown:')) {
+            email = w.email;
+            break;
+          }
+        }
+      }
+      if (email) this._cancelIdleClose(email);
+      return;
+    }
     if (task.workerLabel) {
       this._cancelIdleClose(task.workerLabel.toLowerCase());
     } else {
@@ -587,6 +687,7 @@ class TaskQueue {
     for (const w of this.workers.values()) {
       if (w.id === excludeSocketId) continue;
       if (w.status === 'rate_limited') continue;
+      if (task.chromeId && w.chromeId !== task.chromeId) continue;
       if (task.workerLabel && w.email !== task.workerLabel.toLowerCase()) continue;
       return true;
     }
@@ -595,6 +696,10 @@ class TaskQueue {
 
   _anyWorkerCouldMatch(task) {
     if (!this.workers.size) return false;
+    if (task.chromeId) {
+      for (const w of this.workers.values()) if (w.chromeId === task.chromeId) return true;
+      return false;
+    }
     if (!task.workerLabel) return true;
     const lc = task.workerLabel.toLowerCase();
     for (const w of this.workers.values()) if (w.email === lc) return true;
@@ -616,10 +721,14 @@ class TaskQueue {
     if (RL_CODES.has(code)) {
       worker.status = 'rate_limited';
       worker.cooldownUntil = Date.now() + RATE_LIMIT_COOLDOWN_MS;
+      worker.lastFailureCode = code;
+      worker.lastFailureMessage = message.slice(0, 300);
       worker.currentTaskId = null;
       console.log(chalk.yellow(`[TaskQueue] Worker ${worker.email} rate-limited until ${new Date(worker.cooldownUntil).toLocaleTimeString()}`));
     } else {
       // Plain failure — worker becomes idle again
+      worker.lastFailureCode = code;
+      worker.lastFailureMessage = message.slice(0, 300);
       worker.currentTaskId = null;
       worker.status = 'idle';
     }
@@ -688,10 +797,13 @@ class TaskQueue {
         this.pending.splice(i, 1);
         continue;
       }
-      // Pick first idle worker that matches the pin
-      const wIdx = idleWorkers.findIndex(w =>
-        !task.workerLabel || w.email === task.workerLabel.toLowerCase()
-      );
+      // Pick first idle worker that matches the pin. chromeId takes
+      // precedence over workerLabel — explicit profile pin is authoritative.
+      const wIdx = idleWorkers.findIndex(w => {
+        if (task.chromeId) return w.chromeId === task.chromeId;
+        if (task.workerLabel) return w.email === task.workerLabel.toLowerCase();
+        return true;
+      });
       if (wIdx === -1) {
         if (!this._anyWorkerCouldMatch(task)) this._autoLaunchBrowser(task);
         i++;
@@ -769,7 +881,8 @@ class TaskQueue {
       try {
         launcher.socket.emit('launcher:open_aistudio', {
           taskId: task?.id || null,
-          workerLabel: task?.workerLabel || null
+          workerLabel: task?.workerLabel || null,
+          chromeId: task?.chromeId || null
         }, (ack) => {
           if (ack?.ok) {
             console.log(chalk.green(`[TaskQueue] Launcher ${tag} ${ack.action} tab ${ack.tabId}`));