@dassi_ai/cli 0.5.0 → 0.7.0

package/dassi-daemon.mjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import { CLI_PROTOCOL_VERSION } from './dassi-shared.mjs';
 /**
  * Dassi CLI Daemon
  *
@@ -13,6 +15,7 @@
  */
 
 import * as net from 'net';
+import { setTimeout as sleep } from 'node:timers/promises';
 import * as fs from 'fs';
 import { pathToFileURL } from 'url';
 import {
@@ -22,10 +25,9 @@ import {
   getPidFile,
   validateSession,
   cleanupDaemonFiles,
-  buildReadyPayload,
-  createCommandQueue,
   createConnectionRegistry,
   getDaemonBridgePort,
+  unknownToolOutcome,
 } from './dassi-shared.mjs';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -33,8 +35,6 @@ import {
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const IDLE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
 
-// Reason: a registry of connected extensions keyed by profile label replaces
-// the old single-socket model so multiple Chrome profiles can connect at once.
 const registry = createConnectionRegistry();
 
 // ─── WebSocket loader helper ──────────────────────────────────────────────────
@@ -72,7 +72,7 @@ function setupResponseRouter(entry) {
     if (!pending) return;
     entry.pending.delete(String(resp.id));
     if (resp.error) {
-      pending.reject(new Error(resp.error.message ?? String(resp.error)));
+      pending.reject(Object.assign(new Error(resp.error.message ?? String(resp.error)), { taskId: resp.error.taskId, existingTaskId: resp.error.existingTaskId }));
     } else {
       pending.resolve(resp.result);
     }
@@ -85,7 +85,7 @@ function setupResponseRouter(entry) {
  */
 function drainPendingResponses(entry) {
   for (const [id, pending] of entry.pending) {
-    pending.reject(new Error('Extension disconnected'));
+    pending.reject(Object.assign(new Error('Extension disconnected'), { outcome: 'unknown' }));
     entry.pending.delete(id);
   }
 }
@@ -113,45 +113,12 @@ function acceptExtensionSocket(ws, identity, port) {
   return entry;
 }
 
-/**
- * Handles a registration message from a newly connected extension WebSocket.
- * On first registration, resolves the startup promise with auth status.
- * On subsequent registrations (reconnects), logs and continues silently.
- * @param {import('ws').WebSocket} ws - The connected WebSocket.
- * @param {Buffer} data - Raw message data.
- * @param {{ resolved: boolean; timeout: ReturnType<typeof setTimeout> }} ctx - Shared state.
- * @param {(value: unknown) => void} resolve - Promise resolve callback.
- * @param {(reason: Error) => void} reject - Promise reject callback.
- * @param {number} port - The port the WS server is bound to.
- */
-async function handleRegistration(ws, data, ctx, resolve, reject, port) {
+function handleRegistration(ws, data, port) {
   let msg;
-  try { msg = JSON.parse(data.toString()); } catch { return; }
-  if (msg.type !== 'register' || msg.client !== 'dassi-extension') return;
-
-  const entry = acceptExtensionSocket(
-    ws,
-    { label: typeof msg.label === 'string' ? msg.label : null, installId: String(msg.installId ?? '') },
-    port,
-  );
-
-  if (!ctx.resolved) {
-    clearTimeout(ctx.timeout);
-    try {
-      // Reason: route the startup status check to the connection that just registered.
-      const status = await dispatchToExtension({ id: 'init', action: 'status', target: entry.label });
-      ctx.resolved = true;
-      resolve(status);
-    } catch (err) {
-      // Reason: leave ctx.resolved false so a reconnecting extension can retry
-      // the startup status check rather than failing the daemon permanently.
-      console.error('[dassi-daemon] Initial status check failed:', err.message);
-      reject(err);
-    }
-  } else {
-    // Reason: daemon already started — this is a reconnect or an additional profile.
-    console.log('[dassi-daemon] Extension registered (daemon already started)');
-  }
+  try { msg = JSON.parse(data.toString()); } catch { ws.close(); return; }
+  if (msg.type !== 'register' || msg.client !== 'dassi-extension') { ws.close(); return; }
+  acceptExtensionSocket(ws, { label: typeof msg.label === 'string' ? msg.label : null,
+    installId: String(msg.installId ?? '') }, port);
 }
 
 // Reason: Port is configurable via DASSI_BRIDGE_PORT (single source of truth in
@@ -161,35 +128,15 @@ async function handleRegistration(ws, data, ctx, resolve, reject, port) {
 // silently accept and bind to a random ephemeral port.
 const BRIDGE_PORT = getDaemonBridgePort();
 
-/**
- * Starts a WebSocket server on the configured bridge port (default 18790).
- * Stays alive for the daemon's lifetime. Waits for the first extension
- * connection, then resolves with the auth status. Subsequent reconnections
- * are handled transparently.
- * @returns {Promise<{ authenticated: boolean; email: string | null; optionsUrl: string }>}
- */
+/** Listen independently of whether Chrome is connected or signed in. */
 async function startExtensionServer() {
   const { WSServer } = await loadWebSocket();
-
   return new Promise((resolve, reject) => {
     const wss = new WSServer({ host: '127.0.0.1', port: BRIDGE_PORT });
-    const ctx = { resolved: false, timeout: null };
-
-    ctx.timeout = setTimeout(() => {
-      wss.close();
-      reject(new Error('extension_not_installed'));
-    }, 30_000);
-
-    wss.on('error', (err) => {
-      if (!ctx.resolved) {
-        clearTimeout(ctx.timeout);
-        // Reason: EADDRINUSE means another daemon instance already owns the port
-        reject(err.code === 'EADDRINUSE' ? new Error('port_in_use') : new Error('extension_not_installed'));
-      }
-    });
-
+    wss.once('listening', () => resolve(wss));
+    wss.on('error', reject);
     wss.on('connection', (ws) => {
-      ws.once('message', (data) => handleRegistration(ws, data, ctx, resolve, reject, BRIDGE_PORT));
+      ws.once('message', (data) => handleRegistration(ws, data, BRIDGE_PORT));
     });
   });
 }
@@ -203,76 +150,94 @@ async function startExtensionServer() {
  * @param {Record<string, unknown>} cmd - Command object with {id, action, target?, ...params}
  * @returns {Promise<unknown>} The extension's result value (not wrapped in success/data).
  */
-async function dispatchToExtension(cmd) {
+export async function dispatchToExtension(cmd, reg = registry) {
   const { id, action, target = null, ...params } = cmd;
-  const entry = registry.resolve(target); // throws with a helpful message if ambiguous/unknown/none
+  const entry = reg.resolve(target); // throws with a helpful message if ambiguous/unknown/none
   if (!entry.ws || entry.ws.readyState !== 1 /* OPEN */) {
     throw new Error('Extension not connected');
   }
 
   // Reason: the extension expects JSON-RPC {id, method, params}; `target` is a
   // daemon-only routing field and must not leak into the extension params.
-  const message = { id, method: action ?? String(id), params };
-  entry.ws.send(JSON.stringify(message));
-
-  const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs + 10_000 : 65_000;
+  const correlationId = randomUUID();
+  const message = { id: correlationId, method: action ?? String(id), params };
+  // The canonical tool controls execution deadlines, including for dynamic plugins.
+  const timeoutMs = action === 'tool_exec' ? null : action === 'status' ? 10_000 : action === 'run' ? 65_000
+    : Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? Math.min(params.timeoutMs + 10_000, 2147483647) : 65_000;
 
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      entry.pending.delete(String(id));
+    const timer = timeoutMs == null ? null : setTimeout(() => {
+      entry.pending.delete(correlationId);
       reject(new Error(`Extension timeout after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    entry.pending.set(String(id), {
+    entry.pending.set(correlationId, {
       resolve: (result) => { clearTimeout(timer); resolve(result); },
       reject: (err) => { clearTimeout(timer); reject(err); },
     });
+    try { entry.ws.send(JSON.stringify(message)); } catch (error) {
+      entry.pending.delete(correlationId); clearTimeout(timer); reject(error);
+    }
   });
 }
 
-/**
- * Handle commands the daemon answers itself (no extension round-trip).
- * Returns a response object, or null if the command should be dispatched to
- * an extension instead.
- * @param {Record<string, unknown>} cmd
- * @param {ReturnType<typeof createConnectionRegistry>} reg
- * @returns {object | null}
- */
-export function handleDaemonLocalCommand(cmd, reg) {
-  if (cmd?.action === 'list_profiles') {
-    return { id: String(cmd.id ?? 'unknown'), success: true, data: reg.list() };
-  }
-  return null;
-}
-
-/**
- * Refresh the ready file when the latest dispatched command was a `status` query.
- *
- * Reason: The daemon previously wrote the ready file exactly once on startup.
- * When the user wasn't signed in at that moment, the file stayed `needs_login`
- * even after waitForLogin's polling confirmed authentication via socket — so
- * every subsequent CLI invocation re-read the stale file and re-triggered the
- * login flow. Refreshing on every `status` response — which waitForLogin's
- * poll loop drives naturally — converges the file to the truth without needing
- * a separate signal channel.
- *
- * @param {string} readyFile - Absolute path to the daemon's ready file.
- * @param {{ action?: string }} cmd - The command that was dispatched.
- * @param {unknown} result - The dispatch result (extension's status payload).
- * @returns {void}
- */
-export function refreshReadyFileFromStatusResult(readyFile, cmd, result) {
-  if (cmd?.action !== 'status') return;
-  if (!result || typeof result !== 'object') return;
+/** Discovery is independent of authentication and in-flight agent work. */
+export async function routeCommand(cmd, reg = registry, dispatch = dispatchToExtension) {
+  let resolvedProfile;
+  const call = (command) => dispatch(command, reg);
   try {
-    fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(result)), { mode: 0o600 });
-    // Reason: writeFileSync's `mode` is ignored when the file already exists.
-    // chmod explicitly so installs with a pre-hardening 0o644 ready file get
-    // tightened. The file contains the signed-in email — owner-only.
-    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
-  } catch {
-    // Reason: best-effort sync; don't fail the command if the FS write itself
-    // races (e.g. file permission flake). The next status query will retry.
+    if (['run', 'task_status', 'task_stop'].includes(cmd.action) && cmd.protocolVersion !== CLI_PROTOCOL_VERSION) throw new Error('Incompatible CLI. Update Dassi CLI and restart its daemon.');
+    let target = cmd.target ?? null;
+    let localTaskId = cmd.taskId;
+    if (cmd.action === 'task_status' || cmd.action === 'task_stop' || (cmd.action === 'run' && cmd.taskId)) {
+      const split = typeof cmd.taskId === 'string' ? cmd.taskId.indexOf('~') : -1;
+      if (split < 1) throw new Error('Invalid task ID. Copy the ID returned by dassi run.');
+      const taskProfile = cmd.taskId.slice(0, split);
+      if (target && reg.resolve(target).id !== taskProfile) throw new Error('Task belongs to another profile.');
+      target = taskProfile;
+      localTaskId = cmd.taskId.slice(split + 1);
+    }
+    const discovery = ['list_profiles', 'list_tabs', 'list_groups', 'status'].includes(cmd.action);
+    if (discovery) {
+      const profiles = target ? [reg.resolve(target)] : reg.list();
+      const profileOnly = cmd.action === 'list_profiles' || cmd.action === 'status';
+      const snapshots = await Promise.all(profiles.map(async (profile) => {
+        const [status, listing] = await Promise.allSettled([
+          call({ id: `${cmd.id}-${profile.id}-status`, action: 'status', target: profile.id }),
+          profileOnly ? Promise.resolve([]) : call({ ...cmd, id: `${cmd.id}-${profile.id}`, target: profile.id }),
+        ]);
+        const info = { id: profile.id, label: profile.label,
+          ...(status.status === 'fulfilled' ? status.value
+            : { [profileOnly ? 'error' : 'authError']: status.reason.message }),
+          ...(listing.status === 'rejected' ? { error: listing.reason.message } : {}),
+        };
+        const items = listing.status === 'fulfilled' ? listing.value : [];
+        return { profile: info, items: items.map(item => ({ ...item, profileId: profile.id, profile: profile.label,
+          target: `${profile.id}:${cmd.action === 'list_tabs' ? item.tabId : item.id}` })) };
+      }));
+      return { id: cmd.id, success: true,
+        data: cmd.action === 'list_profiles' || cmd.action === 'status' ? snapshots.map(s => s.profile) : snapshots.flatMap(s => s.items),
+        profiles: snapshots.map(s => s.profile) };
+    }
+    const profile = reg.resolve(target);
+    resolvedProfile = profile;
+    if (cmd.action === 'run') {
+      const status = await call({ id: `${cmd.id}-auth`, action: 'status', target: profile.id });
+      if (status.cliProtocolVersion !== CLI_PROTOCOL_VERSION) throw new Error(`Update Dassi in profile "${profile.label}" to use task commands.`);
+      if (!status.authenticated) throw new Error(`Sign in to Dassi in profile "${profile.label}" (${profile.id}), then retry.`);
+    }
+    const data = await call({ ...cmd, target: profile.id, ...(localTaskId ? { taskId: localTaskId } : {}) });
+    return { id: cmd.id, success: true, data: data?.taskId
+      ? { ...data, taskId: `${profile.id}~${data.taskId}`, profileId: profile.id, profile: profile.label } : data };
+  } catch (error) {
+    if (cmd.action === 'tool_exec' && error.outcome === 'unknown') {
+      const uncertain = unknownToolOutcome(error);
+      return { id: cmd.id, success: false, error: uncertain.message, outcome: uncertain.outcome };
+    }
+    const taskId = error.taskId && resolvedProfile ? `${resolvedProfile.id}~${error.taskId}` : undefined;
+    const existingTaskId = error.existingTaskId && resolvedProfile ? `${resolvedProfile.id}~${error.existingTaskId}` : undefined;
+    const checkId = taskId ?? existingTaskId;
+    return { id: cmd.id, success: false, ...(taskId ? { taskId } : {}), ...(existingTaskId ? { existingTaskId } : {}), error: `${error.message}${checkId ? ` Check: dassi status '${checkId}'` : ''}` };
   }
 }
 
@@ -298,7 +263,6 @@ function initDaemonProcess(session) {
   cleanupDaemonFiles(session);
   const pidFile = getPidFile(session);
   fs.writeFileSync(pidFile, String(process.pid), { mode: 0o600 });
-  // Reason: see refreshReadyFileFromStatusResult — chmod normalizes pre-existing files.
   try { fs.chmodSync(pidFile, 0o600); } catch { /* best-effort */ }
 
   const shutdown = () => {
@@ -312,12 +276,12 @@ function initDaemonProcess(session) {
 }
 
 /**
- * Creates and starts a Unix socket server that dispatches NDJSON commands to the queue.
- * @param {{ enqueue: (cmd: Record<string, unknown>) => Promise<unknown> }} queue
+ * Creates a Unix socket server that dispatches independent NDJSON commands.
+ * @param {(cmd: Record<string, unknown>) => Promise<unknown>} dispatch
  * @param {string} socketPath
  * @returns {net.Server}
  */
-function createSocketServer(queue, socketPath) {
+function createSocketServer(dispatch, socketPath) {
   const server = net.createServer((socket) => {
     let buffer = '';
 
@@ -337,11 +301,11 @@ function createSocketServer(queue, socketPath) {
           continue;
         }
 
-        queue.enqueue(cmd)
+        dispatch(cmd)
           .then((response) => {
             if (!socket.destroyed) socket.write(JSON.stringify(response) + '\n');
           })
-          .catch((err) => console.error('[dassi-daemon] enqueue error:', err));
+          .catch((err) => console.error('[dassi-daemon] dispatch error:', err));
       }
     });
 
@@ -379,49 +343,35 @@ function startIdleShutdown(server, session, getLastCommandAt) {
 // ─── Daemon entry point ───────────────────────────────────────────────────────
 
 /**
- * Main daemon entry point. Starts the extension WebSocket server, waits for
- * the extension to register, runs onboarding checks, starts the Unix socket
- * server for CLI commands, and sets up idle shutdown.
+ * Starts the two local transports and idle shutdown. Browser tasks outlive this process.
  * @returns {Promise<void>}
  */
 export async function startDaemon() {
   const session = validateSession(process.env.DASSI_SESSION ?? 'default');
   const { socketPath, readyFile } = initDaemonProcess(session);
 
-  let statusData;
   try {
-    statusData = await startExtensionServer();
-  } catch {
-    // Reason: write the ready file even on failure so the CLI can read the error state,
-    // then exit so the WSS doesn't keep the process alive as a zombie.
-    fs.writeFileSync(readyFile, JSON.stringify({ status: 'extension_not_installed' }), { mode: 0o600 });
-    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
+    await startExtensionServer();
+  } catch (error) {
+    fs.writeFileSync(readyFile, JSON.stringify({ status: 'error', error: error.code === 'EADDRINUSE'
+      ? `Bridge port ${BRIDGE_PORT} is already in use. Use the existing daemon; --session does not select a browser.` : error.message }), { mode: 0o600 });
     process.exit(1);
   }
-
   let lastCommandAt = Date.now();
-  const queue = createCommandQueue(async (cmd) => {
-    lastCommandAt = Date.now();
-    // Reason: daemon-local commands (e.g. list_profiles) are answered from the
-    // registry and intentionally skip extension dispatch + ready-file refresh.
-    const local = handleDaemonLocalCommand(cmd, registry);
-    if (local) return local;
+  let inFlight = 0;
+  const server = createSocketServer(async (cmd) => {
+    inFlight++;
     try {
-      const result = await dispatchToExtension(cmd);
-      refreshReadyFileFromStatusResult(readyFile, cmd, result);
-      return { id: String(cmd.id ?? 'unknown'), success: true, data: result };
-    } catch (err) {
-      return { id: String(cmd.id ?? 'unknown'), success: false, error: err.message };
+      // Chrome reconnects every five seconds after an idle daemon exits.
+      const connectDeadline = Date.now() + 6000;
+      while (!registry.size() && Date.now() < connectDeadline) await sleep(100);
+      return await routeCommand(cmd);
     }
-  });
-
-  // Reason: start the socket server before writing the ready file so the CLI
-  // can connect immediately (e.g. for needs_login polling).
-  const server = createSocketServer(queue, socketPath);
-  fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(statusData)), { mode: 0o600 });
-  try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
-
-  startIdleShutdown(server, session, () => lastCommandAt);
+    finally { inFlight--; lastCommandAt = Date.now(); }
+  }, socketPath);
+  await new Promise(resolve => server.listening ? resolve() : server.once('listening', resolve));
+  fs.writeFileSync(readyFile, JSON.stringify({ status: 'ok', protocolVersion: CLI_PROTOCOL_VERSION }), { mode: 0o600 });
+  startIdleShutdown(server, session, () => inFlight ? Date.now() : lastCommandAt);
 }
 
 // ── Entry point ───────────────────────────────────────────────────────────────

package/dassi-shared.mjs

@@ -1,10 +1,10 @@
+export const CLI_PROTOCOL_VERSION = 3;
 /**
  * Dassi CLI Shared Utilities
  *
  * Pure helper functions shared between the CLI client (dassi.mjs) and the
  * daemon process (dassi-daemon.mjs). Includes path resolution, session
- * validation, daemon lifecycle helpers, ready-file payload handling, and
- * the serialized command queue.
+ * validation, daemon lifecycle helpers, readiness, and browser identity.
  */
 
 import * as fs from 'fs';
@@ -19,6 +19,7 @@ import * as os from 'os';
  * path — letting `dassi launch` open the extension's options page directly.
  */
 export const DASSI_EXTENSION_ID = 'bjcngahpcjeililljmfegmlanlpgibdi';
+export const CHROME_WEB_STORE_URL = `https://chromewebstore.google.com/detail/dassi-ai-browser-agent-fo/${DASSI_EXTENSION_ID}`;
 
 // ─── Path helpers ─────────────────────────────────────────────────────────────
 
@@ -54,7 +55,7 @@ export function getPidFile(session) {
 
 /**
  * Returns the ready file path for the given session.
- * Written by the daemon once the extension WS is connected and auth is verified.
+ * Written when the local command transport is listening.
  * @param {string} session
  * @returns {string}
  */
@@ -132,205 +133,67 @@ export function isDaemonRunning(session) {
     // Reason: signal 0 checks process existence without delivering a real signal
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error.code === 'EPERM') return true;
     // Process does not exist — clean up stale files
     cleanupDaemonFiles(session);
     return false;
   }
 }
 
-// ─── Onboarding payload helpers ───────────────────────────────────────────────
-
-/**
- * Builds the ready file payload from an extension status response.
- * @param {{ authenticated: boolean; email: string | null; optionsUrl: string }} status
- * @returns {{ status: string; email?: string | null; optionsUrl?: string }}
- */
-export function buildReadyPayload(status) {
-  if (status.authenticated) {
-    return { status: 'ok', email: status.email };
-  }
-  return { status: 'needs_login', optionsUrl: status.optionsUrl };
-}
+// ─── Readiness payload helpers ───────────────────────────────────────────────
 
 /**
  * Parses the ready file content into a status object.
- * Returns extension_not_installed on parse failure as a safe fallback.
+ * Throws for incomplete writes so startup can keep polling.
  * @param {string} raw
  * @returns {{ status: string; [key: string]: unknown }}
  */
 export function parseReadyPayload(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { status: 'extension_not_installed' };
-  }
+  const payload = JSON.parse(raw);
+  if (!payload || typeof payload.status !== 'string') throw new Error('Invalid daemon readiness file');
+  return payload;
 }
 
-// ─── Serialized command queue ─────────────────────────────────────────────────
+// ─── Connected browser installations ──────────────────────────────────────────
 
-/**
- * Creates a serialized command queue.
- * Commands are executed one at a time in FIFO order regardless of how many
- * socket clients are connected simultaneously. This prevents concurrent `run`
- * calls from racing inside the extension.
- *
- * @param {(cmd: Record<string, unknown>) => Promise<{id: string; success: boolean; data?: unknown; error?: string}>} handler
- * @returns {{ enqueue: (cmd: Record<string, unknown>) => Promise<{id: string; success: boolean; data?: unknown; error?: string}> }}
- */
-export function createCommandQueue(handler) {
-  const queue = [];
-  let processing = false;
-
-  async function processNext() {
-    if (processing || queue.length === 0) return;
-    processing = true;
-    const { cmd, resolve } = queue.shift();
-    try {
-      const result = await handler(cmd);
-      resolve(result);
-    } catch (err) {
-      resolve({ id: String(cmd.id ?? 'unknown'), success: false, error: err.message ?? String(err) });
-    } finally {
-      processing = false;
-      // Reason: .catch() prevents unhandled rejection from crashing the daemon
-      // if the recursive call fails before reaching its own try/catch
-      processNext().catch(() => {});
-    }
-  }
-
-  return {
-    /**
-     * Enqueue a command and return a promise that resolves with the response.
-     * The returned Promise always resolves; errors are encoded as { success: false, error } values.
-     * @param {Record<string, unknown>} cmd
-     * @returns {Promise<{id: string; success: boolean; data?: unknown; error?: string}>}
-     */
-    enqueue(cmd) {
-      return new Promise((resolve) => {
-        queue.push({ cmd, resolve });
-        processNext().catch(() => {});
-      });
-    },
-  };
+/** A lost transport is not evidence that a browser action failed or stopped. */
+export function unknownToolOutcome(error) {
+  return Object.assign(new Error(`${error.message} Tool outcome unknown; it may still be running. Inspect the browser before retrying.`), { outcome: 'unknown' });
 }
 
-// ─── Connection registry ──────────────────────────────────────────────────────
-
-/**
- * Creates a registry of connected extension sockets, keyed by a unique label.
- * Replaces the daemon's old single-socket model so multiple Chrome profiles can
- * connect at once and commands can be routed to a chosen one by label.
- *
- * @returns {{
- *   add: (conn: { ws: any; label: string | null; installId: string; port: number }) => string;
- *   remove: (ws: any) => ({ label: string; installId: string } | null);
- *   getByWs: (ws: any) => (object | null);
- *   resolve: (target: string | null) => object;
- *   list: () => Array<{ label: string; port: number }>;
- *   size: () => number;
- * }}
- */
 export function createConnectionRegistry() {
-  /** @type {Map<string, { ws: any; label: string; installId: string; port: number; pending: Map<string, any> }>} */
   const conns = new Map();
-
-  // Reason: label is the routing key; if two profiles share a label, suffix the
-  // installId so a connection never silently fails to register (suffix > reject).
-  function uniqueKey(label) {
-    if (!conns.has(label)) return label;
-    let i = 2;
-    while (conns.has(`${label}#${i}`)) i++;
-    return `${label}#${i}`;
-  }
-
-  function labels() {
-    return [...conns.values()].map((c) => c.label);
-  }
-
   return {
-    /**
-     * Register a new extension connection. Returns the unique key (label) assigned.
-     * Duplicate labels are disambiguated by appending a numeric suffix.
-     * @param {{ ws: any; label: string | null; installId: string; port: number }} conn
-     * @returns {string}
-     */
     add({ ws, label, installId, port }) {
-      // Reason: on reconnect (port/label change) the new TCP connection can register
-      // before the daemon observes the old socket's close. Evict any stale entry for
-      // the same install first, so we don't end up with phantom duplicates (dev +
-      // dev#2) that make resolve(null) wrongly report "multiple profiles".
-      if (installId) {
-        for (const [k, c] of conns) {
-          if (c.installId === installId) { conns.delete(k); break; }
-        }
+      const id = installId || `legacy-${port}`;
+      const old = conns.get(id);
+      if (old) {
+        for (const pending of old.pending.values()) pending.reject(Object.assign(new Error('Extension reconnected; check the existing task before retrying.'), { outcome: 'unknown' }));
+        old.ws.close();
       }
-      // Reason: identity fallback chain — label, then installId, then port — so a
-      // connection is always addressable even if a legacy build reports neither.
-      const base =
-        (label && String(label).trim()) || (installId && String(installId).trim()) || String(port);
-      const key = uniqueKey(base);
-      conns.set(key, { ws, label: key, installId, port, pending: new Map() });
-      return key;
+      conns.set(id, { id, installId, label: label?.trim() || id, port, ws, pending: new Map() });
+      return id;
     },
-
-    /**
-     * Remove the connection associated with the given WebSocket.
-     * @param {any} ws
-     * @returns {{ label: string; installId: string } | null}
-     */
     remove(ws) {
-      for (const [key, c] of conns) {
-        if (c.ws === ws) {
-          conns.delete(key);
-          return { label: c.label, installId: c.installId };
-        }
-      }
-      return null;
-    },
-
-    /**
-     * Look up the registry entry for a given WebSocket (includes its pending map).
-     * @param {any} ws
-     * @returns {object | null}
-     */
-    getByWs(ws) {
-      for (const c of conns.values()) if (c.ws === ws) return c;
-      return null;
+      const entry = this.getByWs(ws);
+      if (entry) conns.delete(entry.id);
+      return entry ?? null;
     },
-
-    /**
-     * Resolve a target label to its registry entry.
-     * Passing null auto-resolves when exactly one connection is registered.
-     * Throws descriptive errors for no connections, ambiguity, or unknown label.
-     * @param {string | null} target
-     * @returns {object}
-     */
+    getByWs(ws) { return [...conns.values()].find((entry) => entry.ws === ws) ?? null; },
     resolve(target) {
-      if (conns.size === 0) throw new Error('No extension connected');
+      if (!conns.size) throw new Error('No extension connected. Open Dassi in Chrome, then retry.');
       if (target == null) {
         if (conns.size === 1) return [...conns.values()][0];
-        throw new Error(`Multiple profiles connected (${labels().join(', ')}). Specify --profile <label>.`);
+        throw new Error(`Multiple profiles connected (${[...conns.values()].map(e => e.label).join(', ')}). Copy a target from dassi list-tabs or use --profile <id>.`);
       }
-      const entry = conns.get(String(target));
-      if (!entry) throw new Error(`Unknown profile "${target}". Connected: ${labels().join(', ')}`);
-      return entry;
-    },
-
-    /**
-     * Returns a shallow list of all connected profiles (label + port only).
-     * @returns {Array<{ label: string; port: number }>}
-     */
-    list() {
-      return [...conns.values()].map((c) => ({ label: c.label, port: c.port }));
-    },
-
-    /**
-     * Returns the number of currently connected profiles.
-     * @returns {number}
-     */
-    size() {
-      return conns.size;
+      if (conns.has(String(target))) return conns.get(String(target));
+      const matches = [...conns.values()].filter(entry => entry.label === target);
+      if (matches.length === 1) return matches[0];
+      if (matches.length > 1) throw new Error(`Profile name "${target}" is ambiguous. Use a profile ID from dassi list-profiles.`);
+      throw new Error(`Unknown profile "${target}". Connected: ${[...conns.values()].map(e => `${e.label} (${e.id})`).join(', ')}`);
     },
+    list() { return [...conns.values()].map(({ id, label, port }) => ({ id, label, port })); },
+    size() { return conns.size; },
   };
 }