vg-coder-cli 2.0.45 → 2.0.47

package/src/server/task-queue.js

@@ -0,0 +1,705 @@
+const { exec } = require('child_process');
+const chalk = require('chalk');
+const store = require('./task-store');
+const webhook = require('./task-webhook');
+
+const ALLOWED_DOMAIN = 'aistudio.google.com';
+const AUTO_LAUNCH_URL = 'https://aistudio.google.com';
+const AUTO_LAUNCH_DEBOUNCE_MS = 30_000;
+const INTER_TASK_GAP_MS = 2_500;
+const RATE_LIMIT_COOLDOWN_MS = 30 * 60_000;
+const COOLDOWN_TICK_MS = 60_000;
+const MAX_TASK_ATTEMPTS = 3;
+const RL_CODES = new Set(['rate_limit_exceeded', 'quota_exceeded', 'generation_failed']);
+
+class TaskQueue {
+  constructor() {
+    this.io = null;
+    this.workers = new Map();    // socketId → WorkerReg
+    this.launchers = new Map();  // socketId → LauncherReg { socket, id, chromeId, email, lastSeen }
+    this.chromeIdToEmail = new Map(); // chromeId → email (learned from worker:register)
+    this.pending = [];           // [{ id, workingDir }]
+    this.cache = new Map();      // taskId → task
+    this.launchedAt = 0;
+    this._cooldownTimer = null;
+  }
+
+  attachIO(io) {
+    this.io = io;
+    if (!this._cooldownTimer) {
+      this._cooldownTimer = setInterval(() => this._tickCooldowns(), COOLDOWN_TICK_MS);
+      if (this._cooldownTimer.unref) this._cooldownTimer.unref();
+    }
+  }
+
+  // ---------- Worker registry helpers ----------
+
+  /**
+   * Resolve a worker by socketId or workerLabel (email). If neither given,
+   * pick the first idle worker. Returns null if nothing matches.
+   */
+  _resolveWorker({ socketId, workerLabel } = {}) {
+    if (socketId) return this.workers.get(socketId) || null;
+    if (workerLabel) {
+      const lc = workerLabel.toLowerCase();
+      for (const w of this.workers.values()) {
+        if ((w.email || '').toLowerCase() === lc) return w;
+      }
+      return null;
+    }
+    for (const w of this.workers.values()) {
+      if (w.status === 'idle') return w;
+    }
+    // Fallback to any worker (e.g. for status checks)
+    return this.workers.values().next().value || null;
+  }
+
+  /**
+   * Send a request to a specific worker (or first idle if not specified) and
+   * await its ack reply.
+   * opts: { socketId?, workerLabel? }
+   */
+  requestWorker(event, payload = {}, opts = {}, timeoutMs = 10_000) {
+    // Allow legacy form: requestWorker(event, payload, timeoutMs)
+    if (typeof opts === 'number') { timeoutMs = opts; opts = {}; }
+    return new Promise((resolve, reject) => {
+      const worker = this._resolveWorker(opts);
+      if (!worker) return reject(new Error('no_worker_connected'));
+      const sock = worker.socket;
+      let done = false;
+      const timer = setTimeout(() => {
+        if (done) return;
+        done = true;
+        reject(new Error('worker_timeout'));
+      }, timeoutMs);
+      try {
+        sock.emit(event, payload, (response) => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          resolve(response);
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        done = true;
+        reject(err);
+      }
+    });
+  }
+
+  listWorkers() {
+    const out = [];
+    for (const w of this.workers.values()) {
+      out.push({
+        id: w.id,
+        email: w.email,
+        status: w.status,
+        currentTaskId: w.currentTaskId,
+        cooldownUntil: w.cooldownUntil || 0,
+        lastSeen: w.lastSeen,
+        meta: { domain: w.meta?.domain, chatId: w.meta?.chatId, registeredAt: w.meta?.registeredAt }
+      });
+    }
+    out.sort((a, b) => (a.email || '').localeCompare(b.email || ''));
+    return out;
+  }
+
+  workerStatus(label) {
+    if (!this.workers.size) return { connected: false };
+    if (!label) {
+      // Back-compat: pick first idle, else first any
+      const w = this._resolveWorker();
+      return w ? { connected: true, socketId: w.id, email: w.email, meta: w.meta || {}, status: w.status, currentTaskId: w.currentTaskId } : { connected: false };
+    }
+    const w = this._resolveWorker({ workerLabel: label });
+    if (!w) return { connected: false, label };
+    return { connected: true, socketId: w.id, email: w.email, meta: w.meta || {}, status: w.status, currentTaskId: w.currentTaskId };
+  }
+
+  // ---------- Worker lifecycle ----------
+
+  setWorker(socket, meta) {
+    if (meta?.domain && meta.domain !== ALLOWED_DOMAIN) {
+      socket.emit('worker:rejected', { reason: 'unsupported_domain', expected: ALLOWED_DOMAIN });
+      return false;
+    }
+    const email = (meta?.email && /[\w.+-]+@[\w-]+\.[\w-]+/.test(meta.email))
+      ? String(meta.email).toLowerCase()
+      : `unknown:${socket.id}`;
+
+    const reg = {
+      socket,
+      id: socket.id,
+      email,
+      meta: { ...(meta || {}), registeredAt: Date.now() },
+      status: 'idle',
+      currentTaskId: null,
+      cooldownUntil: 0,
+      lastSeen: Date.now()
+    };
+    this.workers.set(socket.id, reg);
+    // Link launcher in same Chrome profile to this email so future pin-targeted
+    // auto-launches go to the right profile.
+    if (meta?.chromeId && email && !email.startsWith('unknown:')) {
+      this._bindChromeIdToEmail(meta.chromeId, email);
+    }
+    console.log(chalk.green(`[TaskQueue] Worker registered: ${socket.id} (${email})`));
+    setImmediate(() => this._drain());
+    return true;
+  }
+
+  // ---------- Launcher (per-profile background SW) ----------
+
+  setLauncher(socket, meta) {
+    const chromeId = String(meta?.chromeId || '').trim();
+    if (!chromeId) {
+      console.log(chalk.yellow('[TaskQueue] Launcher rejected: missing chromeId'));
+      return false;
+    }
+    // Drop any existing launcher with same chromeId (reconnect case).
+    for (const [sid, l] of this.launchers) {
+      if (l.chromeId === chromeId && sid !== socket.id) {
+        try { l.socket.disconnect(true); } catch (_) {}
+        this.launchers.delete(sid);
+      }
+    }
+    const reg = {
+      socket,
+      id: socket.id,
+      chromeId,
+      email: this.chromeIdToEmail.get(chromeId) || null,
+      meta: { ...(meta || {}), registeredAt: Date.now() },
+      lastSeen: Date.now()
+    };
+    this.launchers.set(socket.id, reg);
+    console.log(chalk.green(`[TaskQueue] Launcher registered: ${socket.id} (chromeId=${chromeId.slice(0, 8)}…, email=${reg.email || 'unknown'})`));
+    return true;
+  }
+
+  clearLauncher(socket) {
+    const l = this.launchers.get(socket.id);
+    if (!l) return;
+    this.launchers.delete(socket.id);
+    console.log(chalk.yellow(`[TaskQueue] Launcher disconnected: ${socket.id} (${l.email || 'unknown'})`));
+  }
+
+  _bindChromeIdToEmail(chromeId, email) {
+    if (!chromeId || !email) return;
+    const prev = this.chromeIdToEmail.get(chromeId);
+    if (prev === email) return;
+    this.chromeIdToEmail.set(chromeId, email);
+    // Update any connected launcher with this chromeId.
+    for (const l of this.launchers.values()) {
+      if (l.chromeId === chromeId) l.email = email;
+    }
+  }
+
+  /**
+   * Pick a connected launcher matching the task's pin (or any launcher if no
+   * pin). Returns null if none.
+   */
+  _pickLauncher(task) {
+    if (!this.launchers.size) return null;
+    const pin = task?.workerLabel ? task.workerLabel.toLowerCase() : null;
+    if (pin) {
+      for (const l of this.launchers.values()) {
+        if ((l.email || '').toLowerCase() === pin) return l;
+      }
+      return null;  // pin set but no launcher knows that email yet
+    }
+    // No pin → first launcher (insertion order; round-robin not worth it for rare auto-launch)
+    return this.launchers.values().next().value || null;
+  }
+
+  listLaunchers() {
+    return [...this.launchers.values()].map(l => ({
+      id: l.id,
+      chromeId: l.chromeId,
+      email: l.email,
+      lastSeen: l.lastSeen
+    }));
+  }
+
+  /**
+   * 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.
+   */
+  requestLauncher(event, payload = {}, opts = {}, timeoutMs = 5_000) {
+    if (opts.all) {
+      const launchers = [...this.launchers.values()];
+      if (!launchers.length) return Promise.reject(new Error('no_launcher_connected'));
+      return Promise.all(launchers.map(l => new Promise((resolve) => {
+        let done = false;
+        const timer = setTimeout(() => { if (!done) { done = true; resolve({ launcher: { email: l.email, chromeId: l.chromeId }, ok: false, error: 'launcher_timeout' }); } }, timeoutMs);
+        try {
+          l.socket.emit(event, payload, (response) => {
+            if (done) return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ launcher: { email: l.email, chromeId: l.chromeId }, ...(response || { ok: false, error: 'no_response' }) });
+          });
+        } catch (err) {
+          clearTimeout(timer);
+          done = true;
+          resolve({ launcher: { email: l.email, chromeId: l.chromeId }, ok: false, error: err.message });
+        }
+      })));
+    }
+    return new Promise((resolve, reject) => {
+      const launcher = this._pickLauncher({ workerLabel: opts.workerLabel || null });
+      if (!launcher) return reject(new Error('no_launcher_connected'));
+      let done = false;
+      const timer = setTimeout(() => {
+        if (done) return;
+        done = true;
+        reject(new Error('launcher_timeout'));
+      }, timeoutMs);
+      try {
+        launcher.socket.emit(event, payload, (response) => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          resolve(response);
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        done = true;
+        reject(err);
+      }
+    });
+  }
+
+  clearWorker(socket) {
+    const worker = this.workers.get(socket.id);
+    if (!worker) return;
+    this.workers.delete(socket.id);
+    console.log(chalk.yellow(`[TaskQueue] Worker disconnected: ${socket.id} (${worker.email})`));
+
+    // If a task was running on this worker, fail it (with possible failover).
+    if (worker.currentTaskId) {
+      const task = this.cache.get(worker.currentTaskId);
+      if (task && task.status === 'running') {
+        this._failOrRequeue(task, worker, { code: 'worker_disconnected', message: 'Worker disconnected during execution' });
+      }
+    }
+  }
+
+  // ---------- Public queue API ----------
+
+  async enqueue(task) {
+    task.status = 'queued';
+    task.timing = task.timing || {};
+    task.timing.createdAt = task.timing.createdAt || Date.now();
+    task.timing.queuedAt = Date.now();
+    task.attempts = task.attempts || [];
+    task.workerLabel = task.workerLabel || null;
+    await store.saveTask(task);
+    this.cache.set(task.id, task);
+    this.pending.push({ id: task.id, workingDir: task.workingDir });
+
+    // Auto-launch if no worker matches the task's pin (or no workers at all).
+    if (!this._anyWorkerCouldMatch(task)) this._autoLaunchBrowser(task);
+
+    setImmediate(() => this._drain());
+    return { taskId: task.id, status: task.status, position: this.pending.length };
+  }
+
+  async cancel(taskId, workingDir) {
+    const task = this.cache.get(taskId) || await store.loadTask(workingDir, taskId);
+    if (!task) return { ok: false, code: 404 };
+    if (task.status === 'done' || task.status === 'failed' || task.status === 'canceled') {
+      return { ok: false, code: 409, status: task.status };
+    }
+    task.cancelRequestedAt = Date.now();
+
+    if (task.status === 'queued') {
+      this.pending = this.pending.filter(p => p.id !== taskId);
+      task.status = 'canceled';
+      task.timing.finishedAt = Date.now();
+      await store.saveTask(task);
+      this.cache.set(taskId, task);
+      return { ok: true, status: 'canceled' };
+    }
+
+    // running → best-effort: ask the worker to stop, mark canceled
+    const worker = this._workerByCurrentTask(taskId);
+    if (worker) {
+      try { worker.socket.emit('task:cancel', { taskId }); } catch (_) {}
+      worker.currentTaskId = null;
+      worker.status = 'idle';
+    }
+    task.status = 'canceled';
+    task.timing.finishedAt = Date.now();
+    task.timing.durationMs = task.timing.finishedAt - (task.timing.startedAt || task.timing.createdAt);
+    await store.saveTask(task);
+    this.cache.set(taskId, task);
+    setImmediate(() => this._drain());
+    webhook.deliver(task).catch(() => {});
+    return { ok: true, status: 'canceled' };
+  }
+
+  async get(taskId, workingDir) {
+    if (this.cache.has(taskId)) return this.cache.get(taskId);
+    return store.loadTask(workingDir, taskId);
+  }
+
+  async list(workingDir, filter) {
+    return store.listTasks(workingDir, filter);
+  }
+
+  // ---------- Worker callbacks ----------
+
+  async onWorkerComplete(taskId, payload, socketId) {
+    const worker = socketId ? this.workers.get(socketId) : this._workerByCurrentTask(taskId);
+    const task = this.cache.get(taskId);
+    if (!task || !worker || worker.currentTaskId !== taskId) {
+      console.log(chalk.yellow(`[TaskQueue] Stale complete for ${taskId} from ${socketId || '?'}`));
+      return;
+    }
+    const workerEmail = worker.email;
+    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);
+      setImmediate(() => this._drain());
+      return;
+    }
+    task.status = 'done';
+    task.result = { chatId: payload?.chatId || null };
+    task.timing.finishedAt = Date.now();
+    task.timing.durationMs = task.timing.finishedAt - (task.timing.startedAt || task.timing.createdAt);
+    await store.writeResult(task.workingDir, task.id, payload?.markdown || '');
+    await store.saveTask(task);
+    this.cache.set(task.id, task);
+    console.log(chalk.green(`[TaskQueue] Completed ${task.id} on ${workerEmail} in ${task.timing.durationMs}ms`));
+    webhook.deliver(task).catch(() => {});
+
+    // Recycle the worker's tab so the next task gets a fresh chat with the
+    // 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);
+    // Drain right away so other idle workers pick up queued tasks while
+    // this worker's tab is being recycled (~5s).
+    setImmediate(() => this._drain());
+  }
+
+  async onWorkerFailed(taskId, error, socketId) {
+    const worker = socketId ? this.workers.get(socketId) : this._workerByCurrentTask(taskId);
+    const task = this.cache.get(taskId);
+    if (!task || !worker || worker.currentTaskId !== taskId) {
+      console.log(chalk.yellow(`[TaskQueue] Stale failure for ${taskId} from ${socketId || '?'}`));
+      return;
+    }
+    const workerEmail = worker.email;
+    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);
+    } else {
+      setTimeout(() => this._drain(), INTER_TASK_GAP_MS);
+    }
+  }
+
+  /**
+   * Ask the launcher in the given profile to close all AI Studio tabs and
+   * open a fresh one. The browser-side close fires worker:disconnect →
+   * 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.
+   */
+  _recycleWorkerTab(workerEmail) {
+    if (!workerEmail || workerEmail.startsWith('unknown:')) return;
+    // 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.
+    for (const w of this.workers.values()) {
+      if (w.email === workerEmail && w.status === 'idle') w.status = 'recycling';
+    }
+    setImmediate(async () => {
+      try {
+        await this.requestLauncher('launcher:close_tab', {}, { workerLabel: workerEmail }, 5_000);
+        await new Promise(r => setTimeout(r, 400));
+        await this.requestLauncher('launcher:open_tab', {}, { workerLabel: workerEmail }, 8_000);
+        console.log(chalk.cyan(`[TaskQueue] Recycled tab for ${workerEmail}`));
+      } catch (err) {
+        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';
+        }
+        setImmediate(() => this._drain());
+      }
+    });
+  }
+
+  // ---------- Internal ----------
+
+  _workerByCurrentTask(taskId) {
+    for (const w of this.workers.values()) if (w.currentTaskId === taskId) return w;
+    return null;
+  }
+
+  _hasOtherUsableWorker(task, excludeSocketId) {
+    for (const w of this.workers.values()) {
+      if (w.id === excludeSocketId) continue;
+      if (w.status === 'rate_limited') continue;
+      if (task.workerLabel && w.email !== task.workerLabel.toLowerCase()) continue;
+      return true;
+    }
+    return false;
+  }
+
+  _anyWorkerCouldMatch(task) {
+    if (!this.workers.size) 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;
+    return false;
+  }
+
+  /**
+   * Decide whether a failed task should be requeued onto another worker
+   * (rate-limit failover) or finalized as failed.
+   */
+  async _failOrRequeue(task, worker, error) {
+    const code = error?.code || 'unknown';
+    const message = error?.message || String(error);
+
+    task.attempts = task.attempts || [];
+    task.attempts.push({ workerEmail: worker.email, code, message: message.slice(0, 300), at: Date.now() });
+
+    // Mark worker as rate-limited if applicable
+    if (RL_CODES.has(code)) {
+      worker.status = 'rate_limited';
+      worker.cooldownUntil = Date.now() + RATE_LIMIT_COOLDOWN_MS;
+      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.currentTaskId = null;
+      worker.status = 'idle';
+    }
+
+    const canFailover = RL_CODES.has(code)
+      && task.attempts.length < MAX_TASK_ATTEMPTS
+      && this._hasOtherUsableWorker(task, worker.id);
+
+    if (canFailover) {
+      // Re-queue at head; don't fire webhook
+      task.status = 'queued';
+      task.timing.queuedAt = Date.now();
+      delete task.timing.startedAt;
+      delete task.timing.finishedAt;
+      delete task.timing.durationMs;
+      task.error = null;
+      this.pending.unshift({ id: task.id, workingDir: task.workingDir });
+      await store.saveTask(task);
+      this.cache.set(task.id, task);
+      console.log(chalk.cyan(`[TaskQueue] Failover ${task.id}: requeued (attempt ${task.attempts.length}/${MAX_TASK_ATTEMPTS})`));
+      return;
+    }
+
+    // Finalize as failed
+    task.status = 'failed';
+    task.error = { code, message };
+    task.timing.finishedAt = Date.now();
+    task.timing.durationMs = task.timing.finishedAt - (task.timing.startedAt || task.timing.createdAt);
+    await store.saveTask(task);
+    this.cache.set(task.id, task);
+    console.log(chalk.red(`[TaskQueue] Failed ${task.id} on ${worker.email}: ${code}`));
+    webhook.deliver(task).catch(() => {});
+  }
+
+  /**
+   * Dispatch as many queued tasks as there are matching idle workers.
+   */
+  async _drain() {
+    if (!this.workers.size) {
+      if (this.pending.length) {
+        const head = this.cache.get(this.pending[0].id);
+        this._autoLaunchBrowser(head);
+      }
+      return;
+    }
+
+    // Snapshot workers with status idle
+    let idleWorkers = [...this.workers.values()].filter(w => w.status === 'idle');
+    if (!idleWorkers.length && this.pending.length) {
+      // No idle workers — nothing to dispatch right now.
+      return;
+    }
+
+    // Walk pending; for each task, find a matching idle worker
+    const dispatched = new Set();
+    let i = 0;
+    while (i < this.pending.length && idleWorkers.length) {
+      const entry = this.pending[i];
+      const task = this.cache.get(entry.id) || await store.loadTask(entry.workingDir, entry.id);
+      if (!task || task.status !== 'queued') {
+        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()
+      );
+      if (wIdx === -1) {
+        if (!this._anyWorkerCouldMatch(task)) this._autoLaunchBrowser(task);
+        i++;
+        continue;
+      }
+      const worker = idleWorkers[wIdx];
+      idleWorkers.splice(wIdx, 1);
+      this.pending.splice(i, 1);
+      dispatched.add(task.id);
+      await this._dispatch(task, worker);
+    }
+  }
+
+  async _dispatch(task, worker) {
+    task.status = 'running';
+    task.timing.startedAt = Date.now();
+    task.worker = { socketId: worker.id, email: worker.email, ...(worker.meta || {}) };
+    await store.saveTask(task);
+    this.cache.set(task.id, task);
+    worker.currentTaskId = task.id;
+    worker.status = 'busy';
+
+    const port = this.io?.httpServer?.address?.()?.port || 6868;
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const filesPayload = (task.files || []).map(f => ({
+      idx: f.idx,
+      name: f.name,
+      mime: f.mime,
+      size: f.size,
+      url: `${baseUrl}/api/tasks/${task.id}/files/${f.idx}`
+    }));
+
+    try {
+      worker.socket.emit('task:execute', {
+        taskId: task.id,
+        prompt: task.prompt,
+        files: filesPayload,
+        meta: task.meta || null,
+        timeoutMs: task.timeoutMs || 5 * 60_000
+      });
+      console.log(chalk.cyan(`[TaskQueue] Dispatched ${task.id} → ${worker.email} (${worker.id})`));
+    } catch (err) {
+      worker.currentTaskId = null;
+      worker.status = 'idle';
+      await this._failOrRequeue(task, worker, { code: 'dispatch_failed', message: err.message });
+    }
+  }
+
+  _tickCooldowns() {
+    const now = Date.now();
+    let revived = 0;
+    for (const w of this.workers.values()) {
+      if (w.status === 'rate_limited' && w.cooldownUntil && now >= w.cooldownUntil) {
+        w.status = 'idle';
+        w.cooldownUntil = 0;
+        revived++;
+        console.log(chalk.green(`[TaskQueue] Worker ${w.email} cooldown ended`));
+      }
+    }
+    if (revived) setImmediate(() => this._drain());
+  }
+
+  _autoLaunchBrowser(task = null) {
+    const now = Date.now();
+    if (now - this.launchedAt < AUTO_LAUNCH_DEBOUNCE_MS) return;
+    this.launchedAt = now;
+
+    // Prefer asking a connected launcher (extension background SW in the right
+    // Chrome profile) to open / focus the AI Studio tab. Falls back to OS
+    // `open` if no launcher matches the pin or none are connected.
+    const launcher = this._pickLauncher(task);
+    if (launcher) {
+      const tag = launcher.email || `chromeId=${launcher.chromeId.slice(0, 8)}…`;
+      console.log(chalk.cyan(`[TaskQueue] No matching worker — asking launcher ${tag} to open AI Studio`));
+      try {
+        launcher.socket.emit('launcher:open_aistudio', {
+          taskId: task?.id || null,
+          workerLabel: task?.workerLabel || null
+        }, (ack) => {
+          if (ack?.ok) {
+            console.log(chalk.green(`[TaskQueue] Launcher ${tag} ${ack.action} tab ${ack.tabId}`));
+          } else {
+            console.log(chalk.yellow(`[TaskQueue] Launcher ${tag} failed: ${ack?.error || 'no ack'}`));
+          }
+        });
+        return;
+      } catch (err) {
+        console.log(chalk.yellow(`[TaskQueue] Launcher emit failed: ${err.message}`));
+        // fall through to OS open
+      }
+    }
+
+    let cmd;
+    switch (process.platform) {
+      case 'darwin': cmd = `open "${AUTO_LAUNCH_URL}"`; break;
+      case 'win32':  cmd = `start "" "${AUTO_LAUNCH_URL}"`; break;
+      default:       cmd = `xdg-open "${AUTO_LAUNCH_URL}"`; break;
+    }
+    console.log(chalk.cyan(`[TaskQueue] No matching worker / launcher — falling back to OS open ${AUTO_LAUNCH_URL}`));
+    exec(cmd, (err) => {
+      if (err) console.log(chalk.yellow(`[TaskQueue] OS auto-launch failed: ${err.message}`));
+    });
+  }
+
+  // ---------- Boot rehydration ----------
+
+  async rehydrateFromProjects(projectManager) {
+    const projects = projectManager?.getAllProjects?.() || [];
+    const dirs = new Set();
+    if (projectManager?.getActiveProject?.()) dirs.add(projectManager.getActiveProject().workingDir);
+    for (const p of projects) if (p.workingDir) dirs.add(p.workingDir);
+    if (!dirs.size) dirs.add(process.cwd());
+
+    let queued = 0, restarted = 0;
+    for (const dir of dirs) {
+      const tasks = await store.rehydrate(dir);
+      for (const task of tasks) {
+        task.workingDir = task.workingDir || dir;
+        task.attempts = task.attempts || [];
+        task.workerLabel = task.workerLabel || null;
+        if (task.status === 'running') {
+          task.status = 'failed';
+          task.error = { code: 'server_restart', message: 'Server restarted while task was running' };
+          task.timing = task.timing || {};
+          task.timing.finishedAt = Date.now();
+          task.timing.durationMs = task.timing.finishedAt - (task.timing.startedAt || task.timing.createdAt);
+          await store.saveTask(task);
+          this.cache.set(task.id, task);
+          webhook.deliver(task).catch(() => {});
+          restarted++;
+        } else if (task.status === 'queued') {
+          this.cache.set(task.id, task);
+          this.pending.push({ id: task.id, workingDir: task.workingDir });
+          queued++;
+        } else {
+          this.cache.set(task.id, task);
+        }
+      }
+    }
+    this.pending.sort((a, b) => {
+      const ta = (this.cache.get(a.id)?.timing?.createdAt) || 0;
+      const tb = (this.cache.get(b.id)?.timing?.createdAt) || 0;
+      return ta - tb;
+    });
+    if (queued || restarted) {
+      console.log(chalk.cyan(`[TaskQueue] Rehydrated: ${queued} queued, ${restarted} marked failed (server_restart)`));
+    }
+  }
+}
+
+module.exports = new TaskQueue();