@remits/remits-cli 0.1.108 → 0.1.109

package/index.js

@@ -23,13 +23,12 @@ const SESSION_DIR = path.join(os.homedir(), '.remits-cli');
 const SESSIONS_FILE = path.join(SESSION_DIR, 'sessions.json');
 const CONFIG_FILE = path.join(SESSION_DIR, 'config.json');
 const LISTENER_PID_FILE = path.join(SESSION_DIR, 'listener.pid');
-const TMUX_ACTIVITY_LOG_FILE = path.join(SESSION_DIR, 'tmux-activity.log');
+const ACTIVITY_LOG_FILE = path.join(SESSION_DIR, 'activity.log');
 const SKILL_SOURCE_FILE = path.join(__dirname, 'skills', 'remits-cli', 'SKILL.md');
 const ACCOUNT_REPO_INDEX_FILE = path.join(SESSION_DIR, 'account-repos.json');
 const SERVICE_STATE_FILE = path.join(SESSION_DIR, 'service-state.json');
 const ISSUES_DIR = path.join(SESSION_DIR, 'issues');
 const WEBSOCKET_STATE_FILE = path.join(SESSION_DIR, 'websocket-state.json');
-const LISTENER_REGISTRATION_STATE_FILE = path.join(SESSION_DIR, 'listener-registration-state.json');
 const AUTO_UPDATE_LOCK_DIR = path.join(SESSION_DIR, 'auto-update.lock');
 const AUTO_UPDATE_DISABLED_VALUES = new Set(['0', 'false', 'no', 'off']);
 const REMITS_CLI_PACKAGE_NAME = '@remits/remits-cli';
@@ -48,8 +47,6 @@ const WEBSOCKET_CONNECTION_TIMEOUT_MS = Number(process.env.REMITS_CLI_WEBSOCKET_
 const WEBSOCKET_WATCHDOG_GRACE_MS = Number(process.env.REMITS_CLI_WEBSOCKET_WATCHDOG_GRACE_MS || 30000);
 const SUPPORT_TICKET_DASHBOARD_REFRESH_MS = Number(process.env.REMITS_CLI_SUPPORT_TICKET_REFRESH_MS || 30000);
 const SUPPORT_TICKET_DASHBOARD_LIMIT = Number(process.env.REMITS_CLI_SUPPORT_TICKET_LIMIT || 20);
-const LISTENER_REGISTRATION_INTERVAL_MS = Number(process.env.REMITS_CLI_REGISTRATION_INTERVAL_MS || 5 * 60 * 1000);
-const LISTENER_REGISTRATION_MIN_INTERVAL_MS = Number(process.env.REMITS_CLI_REGISTRATION_MIN_INTERVAL_MS || 5 * 60 * 1000);
 const ACCOUNT_SCAN_EXCLUDE_DIRS = new Set([
   '.git',
   '.gradle',
@@ -624,8 +621,8 @@ function appendGlobalActivityLog(scope, event, meta = {}, level = 'info') {
   const safeMeta = sanitizeForLog(meta);
   const payload = Object.keys(safeMeta || {}).length ? ' ' + JSON.stringify(safeMeta) : '';
   const line = new Date().toISOString() + ' [' + level + '] [' + scope + '] ' + event + payload + '\n';
-  fs.appendFileSync(TMUX_ACTIVITY_LOG_FILE, line);
-  return TMUX_ACTIVITY_LOG_FILE;
+  fs.appendFileSync(ACTIVITY_LOG_FILE, line);
+  return ACTIVITY_LOG_FILE;
 }
 
 function writeToolResponseFile(cwd, callId, responsePayload) {
@@ -1278,204 +1275,6 @@ function discoverAccountRepos() {
   };
 }
 
-function listenerRegistrationRepoAccounts() {
-  return listAccountRepoEntries(readAccountRepoIndex())
-    .sort((a, b) => Number(a.accountId) - Number(b.accountId))
-    .map((entry) => ({
-      accountId: Number(entry.accountId),
-      name: entry.name || null,
-      type: entry.type || null,
-      platformAccountId: entry.platformAccountId || null,
-      routingScope: ['PLATFORM', 'PRODUCT'].includes(String(entry.type || '').toUpperCase())
-        ? 'self_and_descendants'
-        : 'self',
-      source: entry.source || null,
-      updatedAt: entry.updatedAt || null
-    }));
-}
-
-function readListenerRegistrationState() {
-  if (!fs.existsSync(LISTENER_REGISTRATION_STATE_FILE)) {
-    return {};
-  }
-  try {
-    const data = JSON.parse(fs.readFileSync(LISTENER_REGISTRATION_STATE_FILE, 'utf8'));
-    return data && typeof data === 'object' ? data : {};
-  } catch (_) {
-    return {};
-  }
-}
-
-function writeListenerRegistrationState(data) {
-  ensureSessionDir();
-  atomicWriteFile(LISTENER_REGISTRATION_STATE_FILE, JSON.stringify(data || {}, null, 2));
-}
-
-function listenerRegistrationStateKey(session) {
-  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
-  const userId = session.user && session.user.id ? session.user.id : 'unknown';
-  return baseUrl + '|' + String(userId);
-}
-
-function serviceRegistrationState() {
-  const state = readServiceState();
-  return {
-    running: isListenerRunning(),
-    pid: state && state.pid ? state.pid : (fs.existsSync(LISTENER_PID_FILE) ? fs.readFileSync(LISTENER_PID_FILE, 'utf8').trim() : null),
-    startedAt: state && state.startedAt ? state.startedAt : runtimeState.service.startedAt,
-    dashboardUrl: state && state.dashboardUrl ? state.dashboardUrl : runtimeState.service.dashboardUrl
-  };
-}
-
-function listenerRegistrationPayload(session, options = {}) {
-  const service = serviceRegistrationState();
-  const groupedSessions = Array.isArray(options.groupedSessions)
-    ? options.groupedSessions.filter((entry) => entry && entry.token)
-    : [];
-  const sessionDataModes = Array.from(new Set(
-    (groupedSessions.length ? groupedSessions : [session])
-      .map((entry) => normalizeDataMode(entry && entry.dataMode))
-      .filter(Boolean)
-  )).sort();
-  const sessionAccountIds = Array.from(new Set(
-    (groupedSessions.length ? groupedSessions : [session])
-      .map((entry) => Number(entry && entry.accountId))
-      .filter((accountId) => Number.isFinite(accountId) && accountId > 0)
-  )).sort((a, b) => a - b);
-  return {
-    client: 'remits-cli',
-    reason: options.reason || 'heartbeat',
-    baseUrl: normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL),
-    accountId: Number(session.accountId),
-    dataMode: normalizeDataMode(session.dataMode),
-    dataModes: sessionDataModes,
-    sessionAccountIds,
-    registrationSessionCount: groupedSessions.length || 1,
-    websocketTopic: session.websocketTopic || (session.user && session.user.uuid ? String(session.user.uuid).replace(/-/g, '') : null),
-    dashboardUrl: service.dashboardUrl || null,
-    agent: getPreferredAgent(),
-    service,
-    repoAccounts: listenerRegistrationRepoAccounts()
-  };
-}
-
-function listenerRegistrationSignature(payload) {
-  return sha256(stableStringify({
-    baseUrl: payload.baseUrl,
-    accountId: payload.accountId,
-    dataMode: payload.dataMode,
-    dataModes: payload.dataModes || [],
-    sessionAccountIds: payload.sessionAccountIds || [],
-    websocketTopic: payload.websocketTopic,
-    dashboardUrl: payload.dashboardUrl,
-    agent: payload.agent,
-    serviceRunning: payload.service && payload.service.running,
-    repoAccounts: (payload.repoAccounts || []).map((entry) => ({
-      accountId: entry.accountId,
-      type: entry.type,
-      routingScope: entry.routingScope,
-      updatedAt: entry.updatedAt
-    }))
-  }));
-}
-
-function shouldRegisterCliListener(session, payload, options = {}) {
-  if (options.force === true) {
-    return true;
-  }
-  const state = readListenerRegistrationState();
-  const key = listenerRegistrationStateKey(session);
-  const existing = state[key];
-  if (!existing) {
-    return true;
-  }
-  const lastRegisteredAtMs = Number(existing.lastRegisteredAtMs || 0);
-  if (!lastRegisteredAtMs || Date.now() - lastRegisteredAtMs >= LISTENER_REGISTRATION_MIN_INTERVAL_MS) {
-    return true;
-  }
-  return existing.signature !== listenerRegistrationSignature(payload);
-}
-
-function rememberCliListenerRegistration(session, payload) {
-  const state = readListenerRegistrationState();
-  const key = listenerRegistrationStateKey(session);
-  state[key] = {
-    baseUrl: payload.baseUrl,
-    userId: session.user && session.user.id ? session.user.id : null,
-    signature: listenerRegistrationSignature(payload),
-    accountCount: Array.isArray(payload.repoAccounts) ? payload.repoAccounts.length : 0,
-    sessionAccountIds: payload.sessionAccountIds || [],
-    dataModes: payload.dataModes || [],
-    registrationSessionCount: payload.registrationSessionCount || 1,
-    lastRegisteredAt: new Date().toISOString(),
-    lastRegisteredAtMs: Date.now()
-  };
-  writeListenerRegistrationState(state);
-}
-
-async function registerCliListenerSession(session, options = {}) {
-  if (!session || !session.token) {
-    return null;
-  }
-  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
-  const payload = listenerRegistrationPayload(session, options);
-  if (!shouldRegisterCliListener(session, payload, options)) {
-    return { success: true, skipped: true, reason: 'recently_registered' };
-  }
-  const api = buildAxios(baseUrl, session.token, parsePositiveInt(options.timeoutMs, 5000));
-  const response = await api.post('/cli/register', payload);
-  rememberCliListenerRegistration(session, payload);
-  return response.data;
-}
-
-async function bestEffortRegisterCliListeners(options = {}) {
-  const sessions = listSessionsFromStore(readAllSessions()).filter((session) => session && session.token);
-  if (!sessions.length) {
-    return [];
-  }
-  const groupedSessions = [];
-  for (const session of sessions) {
-    const key = listenerRegistrationStateKey(session);
-    let group = groupedSessions.find((entry) => entry.key === key);
-    if (!group) {
-      group = { key, session, sessions: [] };
-      groupedSessions.push(group);
-    }
-    group.sessions.push(session);
-  }
-
-  const results = await Promise.all(groupedSessions.map(async (group) => {
-    try {
-      const data = await registerCliListenerSession(group.session, {
-        ...options,
-        groupedSessions: group.sessions
-      });
-      return {
-        success: true,
-        accountId: group.session.accountId,
-        baseUrl: group.session.baseUrl,
-        groupedAccountIds: group.sessions.map((session) => session.accountId),
-        data
-      };
-    } catch (err) {
-      appendGlobalActivityLog('listener', 'registration.failed', {
-        accountId: group.session.accountId,
-        baseUrl: normalizeBaseUrl(group.session.baseUrl || DEFAULT_BASE_URL),
-        groupedAccountIds: group.sessions.map((session) => session.accountId),
-        error: describeError(err)
-      }, 'error');
-      return {
-        success: false,
-        accountId: group.session.accountId,
-        baseUrl: group.session.baseUrl,
-        groupedAccountIds: group.sessions.map((session) => session.accountId),
-        error: describeError(err)
-      };
-    }
-  }));
-  return results;
-}
-
 function resolvePreferredAccountId(cwd, flags, session) {
   // Explicit --account-id wins over the repo's account-info.json so users can
   // target a child account (e.g. a customer) from a parent-account repo.
@@ -1839,7 +1638,16 @@ function describeError(err) {
     if (responseData.message) {
       parts.push(String(responseData.message));
     } else if (typeof responseData === 'string') {
-      parts.push(responseData);
+      // A server that answers an unknown route with an HTML error page would otherwise put a whole
+      // document into a log line or a dashboard panel. The status is the useful part; the page is not.
+      const looksLikeHtml = /^\s*(<!doctype|<html)/i.test(responseData);
+      if (looksLikeHtml) {
+        const status = err.response.status ? 'HTTP ' + err.response.status : 'HTTP error';
+        const title = (responseData.match(/<title[^>]*>([^<]{0,120})<\/title>/i) || [])[1];
+        parts.push(status + (title ? ' - ' + title.trim() : ' (HTML error page)'));
+      } else {
+        parts.push(responseData.length > 500 ? responseData.slice(0, 500) + '...' : responseData);
+      }
     }
   }
   if (err.message) {
@@ -1890,7 +1698,7 @@ function isLikelySandboxNetworkError(err) {
 function sandboxNetworkHint(err) {
   if (!isLikelySandboxNetworkError(err)) return '';
   const baseUrl = err && err.config && err.config.baseURL ? err.config.baseURL : DEFAULT_BASE_URL;
-  return ' Network access to ' + baseUrl + ' appears unavailable from the current sandbox. If remits-cli is being run by a local AI agent (for example Codex in tmux), retry the command with escalated permissions or outside the sandbox.';
+  return ' Network access to ' + baseUrl + ' appears unavailable from the current sandbox. If remits-cli is being run by a local AI agent (for example Codex or Claude Code), retry the command with escalated permissions or outside the sandbox.';
 }
 
 function saveToolsSnapshot(cwd, data) {
@@ -2190,10 +1998,6 @@ async function authCommand(flags) {
   });
   console.log('Authenticated as user', session.user ? session.user.id : 'unknown', 'for account', session.accountId);
   console.log('Data mode:', session.dataMode);
-  try {
-    await bestEffortRegisterCliListeners({ cwd, reason: 'auth' });
-  } catch (_) { /* best-effort */ }
-
   try {
     const branchName = currentBranch(cwd);
     const toolsData = await loggedPost(api, cwd, '/cli/tools', {
@@ -4237,6 +4041,10 @@ let supportTicketSnapshotCache = {
   fetchedAtMs: 0,
   value: null
 };
+let agentSnapshotCache = {
+  fetchedAtMs: 0,
+  value: null
+};
 
 function listenerSessionEntriesFromStore(store) {
   return listSessionsFromStore(store).filter((session) => session && session.token && session.websocketTopic);
@@ -4469,18 +4277,18 @@ function slugify(value) {
 
 function detectIssueSignals(repoEntries, globalFiles) {
   const issues = [];
-  const tmuxLog = (globalFiles || []).find((file) => file.label === 'tmux-activity.log (tail)');
-  if (tmuxLog && tmuxLog.content) {
-    const errorLines = tmuxLog.content
+  const activityLog = (globalFiles || []).find((file) => file.label === 'activity.log (tail)');
+  if (activityLog && activityLog.content) {
+    const errorLines = activityLog.content
       .split('\n')
       .filter((line) => /\[error\]/i.test(line))
       .slice(-8);
     if (errorLines.length) {
       issues.push({
-        id: 'tmux-activity-errors',
+        id: 'activity-errors',
         severity: 'warn',
         scope: 'global',
-        title: 'Recent service or tmux errors detected',
+        title: 'Recent service errors detected',
         summary: 'The global remits-cli activity log contains recent error-level events.',
         evidence: errorLines,
         recommendation: 'Review the activity tail and export an escalation bundle if this reflects unexpected platform or dispatch behavior.'
@@ -4604,11 +4412,10 @@ function exportIssueBundle(snapshot) {
     service: snapshot.service,
     discovery: snapshot.discovery,
     issueCount: (snapshot.issues || []).length,
-    tmux: {
-      available: snapshot.tmux && snapshot.tmux.available,
-      sessionExists: snapshot.tmux && snapshot.tmux.sessionExists,
-      sessionName: snapshot.tmux && snapshot.tmux.sessionName,
-      livePaneCount: snapshot.tmux && snapshot.tmux.livePanes ? snapshot.tmux.livePanes.length : 0
+    agents: {
+      localCount: snapshot.agents && snapshot.agents.local ? snapshot.agents.local.length : 0,
+      registeredCount: snapshot.agents && snapshot.agents.registered ? snapshot.agents.registered.length : 0,
+      errors: (snapshot.agents && snapshot.agents.errors) || []
     },
     repos: (snapshot.repos || []).map((repo) => ({
       accountId: repo.accountId,
@@ -4624,10 +4431,9 @@ function exportIssueBundle(snapshot) {
   copyFileIfExists(SESSIONS_FILE, path.join(globalDir, 'sessions.json'));
   copyFileIfExists(CONFIG_FILE, path.join(globalDir, 'config.json'));
   copyFileIfExists(SERVICE_STATE_FILE, path.join(globalDir, 'service-state.json'));
-  copyFileIfExists(LISTENER_REGISTRATION_STATE_FILE, path.join(globalDir, 'listener-registration-state.json'));
+  copyFileIfExists(AGENT_STATE_FILE, path.join(globalDir, 'agents.json'));
   copyFileIfExists(ACCOUNT_REPO_INDEX_FILE, path.join(globalDir, 'account-repos.json'));
-  copyFileIfExists(DISPATCH_STATE_FILE, path.join(globalDir, 'dispatch-panes.json'));
-  copyFileIfExists(TMUX_ACTIVITY_LOG_FILE, path.join(globalDir, 'tmux-activity.log'));
+  copyFileIfExists(ACTIVITY_LOG_FILE, path.join(globalDir, 'activity.log'));
 
   const reposDir = path.join(bundleDir, 'repos');
   ensureDir(reposDir);
@@ -4666,10 +4472,9 @@ function buildGlobalFileSnapshot() {
     { label: 'config.json', path: CONFIG_FILE, mode: 'json' },
     { label: 'service-state.json', path: SERVICE_STATE_FILE, mode: 'json' },
     { label: 'websocket-state.json', path: WEBSOCKET_STATE_FILE, mode: 'json' },
-    { label: 'listener-registration-state.json', path: LISTENER_REGISTRATION_STATE_FILE, mode: 'json' },
-    { label: 'dispatch-panes.json', path: DISPATCH_STATE_FILE, mode: 'json' },
+    { label: 'agents.json', path: AGENT_STATE_FILE, mode: 'json' },
     { label: 'account-repos.json', path: ACCOUNT_REPO_INDEX_FILE, mode: 'json' },
-    { label: 'tmux-activity.log (tail)', path: TMUX_ACTIVITY_LOG_FILE, mode: 'tail' }
+    { label: 'activity.log (tail)', path: ACTIVITY_LOG_FILE, mode: 'tail' }
   ];
 
   return files.map((file) => {
@@ -4737,6 +4542,9 @@ function compactSupportTicketRow(row) {
     type: row.type || null,
     source: row.source || null,
     assignedTo: row.assignedTo || null,
+    routedAgentId: row.routedAgentId || null,
+    routedAgentLabel: row.routedAgentLabel || null,
+    routedAt: row.routedAt || null,
     implementationAccountId: row.implementationAccountId || null,
     implementationAccountName: row.implementationAccountName || null,
     affectedComponent: row.affectedComponent || null,
@@ -4746,48 +4554,126 @@ function compactSupportTicketRow(row) {
   };
 }
 
-function supportTicketQueueInput(session) {
-  return {
-    action: 'list',
+/**
+ * The support-ticket queue for one authenticated session.
+ *
+ * Reads the PLATFORM's generic queue endpoint, deliberately not a front-stage tool. remits-cli has
+ * to show the same ticket surface on every Remits platform, whatever helpdesk that platform
+ * integrates with and whatever workflow it layers on top; product-specific views belong in that
+ * product's own Embeddables.
+ */
+async function fetchSupportTicketQueueForSession(session) {
+  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const api = buildAxios(baseUrl, session.token, 15000);
+  const result = await api.post('/cli/tickets', {
     accountId: Number(session.accountId),
     includeChildren: true,
-    includeRoot: true,
     sortBy: 'triage',
     limit: Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100)
-  };
-}
-
-async function fetchSupportTicketQueueForSession(session) {
-  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
-  const api = buildAxios(baseUrl, session.token, 12000);
-  const response = await api.post('/cli/tool', {
-    token: session.token,
-    accountId: Number(session.accountId),
-    branchName: '',
-    dataMode: 'prod',
-    name: 'mcp_support_ticket_queue',
-    callId: 'dashboard-support-ticket-queue-' + crypto.randomUUID(),
-    input: supportTicketQueueInput(session)
   }).then((r) => r.data);
 
-  const result = response && response.result ? response.result : {};
-  const tickets = Array.isArray(result.tickets)
+  const tickets = Array.isArray(result && result.tickets)
     ? result.tickets.map(compactSupportTicketRow).filter(Boolean)
     : [];
   return {
-    success: response && response.success !== false && response.toolSuccess !== false && result.success !== false,
+    success: !!(result && result.success !== false),
     baseUrl,
     accountId: Number(session.accountId),
     userId: session.user && session.user.id ? session.user.id : null,
-    dataMode: result.dataMode || response.dataMode || 'prod',
-    totalCount: result.totalCount || tickets.length,
-    count: result.count || tickets.length,
-    counts: result.counts || {},
-    recommendedTicket: compactSupportTicketRow(result.recommendedTicket),
+    dataMode: (result && result.dataMode) || session.dataMode || 'prod',
+    totalCount: (result && result.totalCount) || tickets.length,
+    count: (result && result.count) || tickets.length,
+    counts: (result && result.counts) || {},
+    recommendedTicket: compactSupportTicketRow(result && result.recommended),
     tickets,
-    searchedAccounts: result.searchedAccounts || [],
-    message: response.toolMessage || result.message || null
+    searchedAccounts: (result && result.accounts) || [],
+    message: (result && result.message) || null
+  };
+}
+
+/**
+ * Who is available to work tickets, from the platform's point of view plus this machine's.
+ *
+ * `registered` is authoritative (it is what routing sees); `local` is the sessions this machine
+ * believes it started. Showing both is the point: a local session missing from `registered` is
+ * exactly the "my agent is not getting tickets" symptom, and the two lists side by side name it.
+ */
+/**
+ * Route a ticket at an agent from the dashboard, or clear its routing when agentId is empty.
+ *
+ * Goes through the same platform endpoint an operator Embeddable would use, so "route this ticket"
+ * has ONE implementation and one access check whichever surface asked for it.
+ */
+async function routeTicketFromDashboard({ ticketId, accountId, agentId }) {
+  const numericAccountId = Number(accountId);
+  if (!ticketId || !Number.isFinite(numericAccountId)) {
+    throw new Error('Routing needs a ticketId and an accountId.');
+  }
+  const session = listSessionsFromStore(readAllSessions())
+    .find((entry) => entry && entry.token && Number(entry.accountId) === numericAccountId) ||
+    listSessionsFromStore(readAllSessions()).find((entry) => entry && entry.token);
+  if (!session) {
+    throw new Error('No authenticated session is available. Run: remits-cli auth');
+  }
+  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const result = await buildAxios(baseUrl, session.token, 15000)
+    .post('/cli/ticketRoute', {
+      ticketId: String(ticketId),
+      accountId: numericAccountId,
+      agentId: agentId || null,
+      dataMode: session.dataMode
+    }).then((r) => r.data);
+  appendGlobalActivityLog('ticket', 'routed', {
+    ticketId, accountId: numericAccountId, agentId: agentId || null, success: result && result.success
+  });
+  if (result && result.success === false) {
+    throw new Error(result.message || 'Routing was refused.');
+  }
+  return result;
+}
+
+async function collectAgentSnapshot() {
+  const nowMs = Date.now();
+  if (agentSnapshotCache.value && nowMs - agentSnapshotCache.fetchedAtMs < SUPPORT_TICKET_DASHBOARD_REFRESH_MS) {
+    return agentSnapshotCache.value;
+  }
+
+  const sessions = listSessionsFromStore(readAllSessions())
+    .filter((session) => session && session.token && session.accountId);
+  const seen = new Set();
+  const lookups = sessions.filter((session) => {
+    const key = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL) + '|' + String(session.accountId);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, 12);
+
+  const byAgentId = {};
+  const errors = [];
+  await Promise.all(lookups.map(async (session) => {
+    const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+    try {
+      const result = await buildAxios(baseUrl, session.token, 12000)
+        .post('/cli/agents', { accountId: Number(session.accountId), dataMode: session.dataMode })
+        .then((r) => r.data);
+      for (const agent of (result && result.agents) || []) {
+        if (agent && agent.agentId) byAgentId[agent.agentId] = agent;
+      }
+    } catch (err) {
+      errors.push({ baseUrl, accountId: Number(session.accountId), message: describeError(err) });
+    }
+  }));
+
+  const value = {
+    fetchedAt: new Date(nowMs).toISOString(),
+    refreshMs: SUPPORT_TICKET_DASHBOARD_REFRESH_MS,
+    registered: Object.values(byAgentId)
+      .sort((a, b) => Number(b.lastSeenAtMs || 0) - Number(a.lastSeenAtMs || 0)),
+    local: listLocalAgents(),
+    errors
   };
+  agentSnapshotCache = { fetchedAtMs: nowMs, value };
+  return value;
 }
 
 async function collectSupportTicketSnapshot() {
@@ -4845,6 +4731,13 @@ async function collectSupportTicketSnapshot() {
     refreshMs: SUPPORT_TICKET_DASHBOARD_REFRESH_MS,
     queueCount: queues.length,
     totalCount: queues.reduce((sum, queue) => sum + Number(queue.totalCount || 0), 0),
+    counts: queues.reduce((totals, queue) => {
+      const counts = queue.counts || {};
+      totals.routed = Number(totals.routed || 0) + Number(counts.routed || 0);
+      totals.unrouted = Number(totals.unrouted || 0) + Number(counts.unrouted || 0);
+      totals.assigned = Number(totals.assigned || 0) + Number(counts.assigned || 0);
+      return totals;
+    }, {}),
     tickets: Object.values(ticketsById).slice(0, Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100)),
     queues,
     errors
@@ -4865,29 +4758,6 @@ async function collectDashboardSnapshot() {
   const globalFiles = buildGlobalFileSnapshot();
   const issues = detectIssueSignals(repoEntries, globalFiles);
 
-  const paneState = fs.existsSync(DISPATCH_STATE_FILE) ? readJsonFilePretty(DISPATCH_STATE_FILE) : null;
-  const livePanes = [];
-  try {
-    if (isTmuxAvailable() && tmuxSessionExists()) {
-      const output = execSync(
-        'tmux list-panes -t ' + shellQuote(TMUX_SESSION_NAME) + ' -F ' + shellQuote('#{session_name}\t#{window_name}\t#{pane_id}\t#{pane_current_path}\t#{pane_dead}'),
-        { stdio: ['ignore', 'pipe', 'ignore'] }
-      ).toString();
-      for (const line of output.split('\n').map((value) => value.trim()).filter(Boolean)) {
-        const parts = line.split('\t');
-        livePanes.push({
-          session: parts[0] || null,
-          window: parts[1] || null,
-          paneId: parts[2] || null,
-          currentPath: parts[3] || null,
-          dead: parts[4] === '1'
-        });
-      }
-    }
-  } catch (_) {
-    // Dashboard should remain readable even if tmux inspection fails.
-  }
-
   return {
     generatedAt: new Date().toISOString(),
     service: {
@@ -4899,14 +4769,7 @@ async function collectDashboardSnapshot() {
     websocket: {
       connections: runtimeState.websocket
     },
-    tmux: {
-      available: isTmuxAvailable(),
-      terminalLaunchSupported: canLaunchTerminalForTmux(),
-      sessionName: TMUX_SESSION_NAME,
-      sessionExists: tmuxSessionExists(),
-      trackedPanes: paneState,
-      livePanes
-    },
+    agents: await collectAgentSnapshot(),
     discovery: runtimeState.discovery,
     globalFiles,
     repos: repoEntries,
@@ -4952,9 +4815,7 @@ function renderDashboardHtml(snapshot) {
           '<button class="action-btn" data-action="export-issues">Export Issue Bundle</button>' +
           '<button class="action-btn" data-action="rescan-repos">Rescan Account Repos</button>' +
           '<button class="action-btn" data-action="reconnect-websockets">Reconnect Websockets</button>' +
-          '<button class="action-btn" data-action="open-tmux">Open Tmux Terminal</button>' +
-          '<button class="action-btn" data-action="start-tmux">Ensure Tmux Session</button>' +
-          '<button class="action-btn" data-action="stop-tmux">Kill Tmux Session</button>' +
+          '<button class="action-btn" data-action="refresh-agents">Refresh Agents</button>' +
         '</div>' +
       '</section>' +
       '<div class="section-grid">' +
@@ -4967,6 +4828,9 @@ function renderDashboardHtml(snapshot) {
           '<div id="last-action" class="empty">No dashboard actions have been triggered yet.</div>' +
         '</section>' +
       '</div>' +
+      '<div class="section-grid">' +
+        '<section class="panel"><h2>Available Agents</h2><div id="agent-section" class="accordion"></div></section>' +
+      '</div>' +
       '<div class="section-grid">' +
         '<section class="panel"><h2>Support Tickets</h2><div id="support-ticket-section" class="accordion"></div></section>' +
       '</div>' +
@@ -4975,7 +4839,7 @@ function renderDashboardHtml(snapshot) {
       '</div>' +
       '<div class="section-grid">' +
         '<section class="panel"><h2>Websocket Connections</h2><div id="websocket-section" class="accordion"></div></section>' +
-        '<section class="panel"><h2>Tmux</h2><div id="tmux-section" class="accordion"></div></section>' +
+        '<section class="panel"><h2>Activity Log</h2><div id="activity-section" class="accordion"></div></section>' +
       '</div>' +
       '<div class="section-grid">' +
         '<section class="panel"><h2>Global Files</h2><div id="global-files" class="accordion"></div></section>' +
@@ -5000,36 +4864,39 @@ function renderDashboardHtml(snapshot) {
         'function summaryItem(key,value){return \'<div class="summary-item"><span class="k">\'+escapeHtml(key)+\'</span><span class="v">\'+escapeHtml(value)+\'</span></div>\';}' +
         'function codeBlock(key,content,extraClass){return \'<pre class="code-block \'+(extraClass||"")+\'" data-scroll-key="\'+escapeHtml(key)+\'">\'+escapeHtml(content||"[missing]")+\'</pre>\';}' +
         'function detailsBlock(key,title,meta,bodyHtml,openByDefault){return \'<details class="item" data-key="\'+escapeHtml(key)+\'"\'+(openByDefault?" open":"")+\'><summary><div class="summary-main"><div class="summary-text"><span class="summary-title">\'+escapeHtml(title)+\'</span><span class="summary-meta">\'+meta+\'</span></div></div><span class="summary-caret">›</span></summary><div class="item-body">\'+bodyHtml+\'</div></details>\';}' +
-        'function renderStatusCards(state){const wsValues=Object.values((state.websocket&&state.websocket.connections)||{});const connectedCount=wsValues.filter(function(entry){return entry.status==="connected";}).length;const warnCount=wsValues.filter(function(entry){return entry.status==="connecting";}).length;const errorCount=wsValues.filter(function(entry){return entry.status==="error"||entry.status==="disconnected";}).length;const repoCount=(state.repos||[]).length;const issueCount=(state.issues||[]).length;const criticalIssueCount=(state.issues||[]).filter(function(issue){return issue.severity==="bad";}).length;const ticketState=state.supportTickets||{};const ticketErrors=(ticketState.errors||[]).length;const ticketTotal=ticketState.totalCount||0;const tmuxHealthy=state.tmux&&state.tmux.available&&state.tmux.sessionExists;const cards=[' +
+        'function renderStatusCards(state){const wsValues=Object.values((state.websocket&&state.websocket.connections)||{});const connectedCount=wsValues.filter(function(entry){return entry.status==="connected";}).length;const warnCount=wsValues.filter(function(entry){return entry.status==="connecting";}).length;const errorCount=wsValues.filter(function(entry){return entry.status==="error"||entry.status==="disconnected";}).length;const repoCount=(state.repos||[]).length;const issueCount=(state.issues||[]).length;const criticalIssueCount=(state.issues||[]).filter(function(issue){return issue.severity==="bad";}).length;const ticketState=state.supportTickets||{};const ticketErrors=(ticketState.errors||[]).length;const ticketTotal=ticketState.totalCount||0;const agentState=state.agents||{};const agentList=agentState.registered||[];const idleAgents=agentList.filter(function(a){return (a.state||"idle")==="idle";}).length;const cards=[' +
           '{title:"Service",value:state.service&&state.service.running?"Running":"Stopped",label:"Daemon status",tone:statusTone(state.service&&state.service.running),sub:(state.service&&state.service.dashboardUrl?state.service.dashboardUrl:"No dashboard URL yet")},' +
           '{title:"Websockets",value:String(connectedCount)+"/"+String(wsValues.length||0),label:"Connected topics groups",tone:errorCount? "bad" : (warnCount? "warn" : "ok"),sub: errorCount? String(errorCount)+" unhealthy connection(s)" : (warnCount? String(warnCount)+" connecting" : "All connections healthy")},' +
           '{title:"Tickets",value:String(ticketTotal),label:"Open support queue",tone:ticketErrors?"warn":"ok",sub:ticketErrors?String(ticketErrors)+" queue fetch error(s)":"Fetched "+String(ticketState.queueCount||0)+" queue(s)"},' +
-          '{title:"Tmux",value:tmuxHealthy?"Ready":"Attention",label:"Dispatch workspace",tone:tmuxHealthy?"ok":(state.tmux&&state.tmux.available?"warn":"bad"),sub:state.tmux&&state.tmux.available?(state.tmux.sessionExists?String((state.tmux.livePanes||[]).length)+" live pane(s)":"tmux installed, session missing"):"tmux not installed"},' +
+          '{title:"Agents",value:String(agentList.length),label:"Registered local sessions",tone:agentList.length?"ok":"warn",sub:agentList.length?String(idleAgents)+" idle, "+String(agentList.length-idleAgents)+" working":"No terminal has run: remits-cli agent register"},' +
           '{title:"Issues",value:String(issueCount),label:"Detected escalation signals",tone:criticalIssueCount?"bad":(issueCount?"warn":"ok"),sub:issueCount?(criticalIssueCount?String(criticalIssueCount)+" critical signal(s)":"Review before continuing"):"No issue signals detected"},' +
           '{title:"Repos",value:String(repoCount),label:"Indexed account repos",tone:repoCount?"ok":"warn",sub:"Last scan: "+formatTime(state.discovery&&state.discovery.scannedAt)}' +
         '];document.getElementById("status-grid").innerHTML=cards.map(function(card){return \'<section class="status-card \'+card.tone+\'"><div class="status-head"><span class="status-dot"></span><div><div class="status-label">\'+escapeHtml(card.title)+\'</div><div class="status-value">\'+escapeHtml(card.value)+\'</div></div></div><div class="status-sub"><strong>\'+escapeHtml(card.label)+\':</strong> \'+escapeHtml(card.sub)+\'</div></section>\';}).join("");}' +
-        'function renderSummary(state){const ws=Object.values((state.websocket&&state.websocket.connections)||{});const topics=ws.reduce(function(sum,entry){return sum+Object.keys(entry.topics||{}).length;},0);const tracked=state.tmux&&state.tmux.trackedPanes?Object.keys(JSON.parse(state.tmux.trackedPanes||"{}")).length:0;document.getElementById("summary-grid").innerHTML=[' +
+        'function renderSummary(state){const ws=Object.values((state.websocket&&state.websocket.connections)||{});const topics=ws.reduce(function(sum,entry){return sum+Object.keys(entry.topics||{}).length;},0);const agentList=(state.agents||{}).registered||[];const ticketCounts=(state.supportTickets||{}).counts||{};document.getElementById("summary-grid").innerHTML=[' +
           'summaryItem("PID",state.service&&state.service.pid||"n/a"),' +
           'summaryItem("Dashboard",state.service&&state.service.dashboardUrl||"n/a"),' +
           'summaryItem("Repo Matches",String(state.discovery&&state.discovery.matches||0)),' +
           'summaryItem("Connections",String(ws.length)),' +
           'summaryItem("Topics",String(topics)),' +
           'summaryItem("Open Tickets",String(state.supportTickets&&state.supportTickets.totalCount||0)),' +
-          'summaryItem("Tracked Panes",String(tracked))' +
+          'summaryItem("Available Agents",String(agentList.length)),' +
+          'summaryItem("Routed Tickets",String(ticketCounts.routed||0))' +
         '].join("");}' +
         'function renderLastAction(state){const target=document.getElementById("last-action");if(!state.lastAction){target.className="empty";target.textContent="No dashboard actions have been triggered yet.";return;}target.className="summary-item";target.innerHTML=\'<span class="k">Last Action</span><span class="v">\'+escapeHtml(state.lastAction.action||"unknown")+\'</span><div class="muted" style="margin-top:8px;">\'+escapeHtml(formatTime(state.lastAction.at))+\'</div>\'+(state.lastAction.bundlePath?\'<div class="muted" style="margin-top:8px;word-break:break-word;"><strong>Bundle:</strong> \'+escapeHtml(state.lastAction.bundlePath)+\'</div>\':"");}' +
         'function renderIssues(state){const target=document.getElementById("issues-section");const issues=state.issues||[];if(!issues.length){target.innerHTML=\'<div class="empty">No automatic issue signals are currently detected. If something still feels wrong, you can still click "Export Issue Bundle" to prepare a package for a Remits system admin.</div>\';return;}target.innerHTML=issues.map(function(issue,index){const tone=issue.severity==="bad"?"bad":"warn";const meta=badge(issue.severity==="bad"?"critical":"warning",tone)+\' <span class="muted">\'+escapeHtml(issue.scope+(issue.repoAccountId?(" account "+issue.repoAccountId):""))+\'</span>\';const evidence=(issue.evidence||[]).map(function(line){return "<li>"+escapeHtml(line)+"</li>";}).join("");const body=\'<div class="stack"><div class="muted">\'+escapeHtml(issue.summary||"")+\'</div><div class="mini-card"><strong>Recommendation</strong>\'+escapeHtml(issue.recommendation||"") + \'</div><div><strong style="display:block;margin-bottom:8px;">Evidence</strong><ul style="margin:0;padding-left:18px;display:grid;gap:8px;">\'+(evidence||"<li>No evidence lines captured.</li>")+\'</ul></div></div>\';return detailsBlock("issue:"+issue.id,(index+1)+". "+issue.title,meta,body,index===0);}).join("");}' +
-        'function renderSupportTickets(state){const target=document.getElementById("support-ticket-section");const support=state.supportTickets||{};const tickets=support.tickets||[];const queues=support.queues||[];const errors=support.errors||[];let html=\'<div class="mini-grid"><div class="mini-card"><strong>Total Open</strong>\'+escapeHtml(String(support.totalCount||0))+\'</div><div class="mini-card"><strong>Queues</strong>\'+escapeHtml(String(support.queueCount||0))+\'</div><div class="mini-card"><strong>Fetched</strong>\'+escapeHtml(formatTime(support.fetchedAt))+\'</div></div>\';if(errors.length){html+=detailsBlock("support:errors","Queue fetch errors",badge(String(errors.length)+" error(s)","warn"),codeBlock("support-errors",JSON.stringify(errors,null,2),"log"),false);}if(!queues.length&&!errors.length){target.innerHTML=html+\'<div class="empty">No authenticated support-ticket queue is available yet.</div>\';return;}const recs=queues.map(function(queue){return queue.recommendedTicket?Object.assign({queueAccountId:queue.accountId,baseUrl:queue.baseUrl},queue.recommendedTicket):null;}).filter(Boolean);if(recs.length){const recBody=recs.map(function(ticket,index){return supportTicketDetails(ticket,"support-rec:"+index);}).join("");html+=detailsBlock("support:recommended","Recommended next tickets",badge(String(recs.length)+" queue(s)","ok"),recBody,true);}if(tickets.length){html+=tickets.map(function(ticket,index){const meta=badge(ticket.priority||"priority","warn")+\' \'+badge(ticket.status||"status",ticket.status==="open"?"ok":"warn")+\' <span class="muted">\'+escapeHtml(ticket.accountName||ticket.accountId||"unknown account")+\'</span>\';return detailsBlock("support-ticket:"+ticket.ticketId,String(ticket.ticketId||"ticket")+" "+(ticket.subject||""),meta,supportTicketDetails(ticket,"support-ticket:"+index),index===0&&!recs.length);}).join("");}else{html+=\'<div class="empty">No open support tickets were returned by the current queues.</div>\';}target.innerHTML=html;}' +
-        'function supportTicketDetails(ticket,key){const command="remits-cli tool --name mcp_support_ticket --input "+JSON.stringify(JSON.stringify({action:"read",ticketId:String(ticket.ticketId||"")}))+" --data-mode prod";return \'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Ticket</strong>\'+escapeHtml(ticket.ticketId||"n/a")+\'</div><div class="mini-card"><strong>Account</strong>\'+escapeHtml((ticket.accountName||"n/a")+" ("+(ticket.accountId||"n/a")+")")+\'</div><div class="mini-card"><strong>Type</strong>\'+escapeHtml(ticket.type||"n/a")+\'</div><div class="mini-card"><strong>Assigned</strong>\'+escapeHtml(ticket.assignedTo||"unassigned")+\'</div><div class="mini-card"><strong>Implementation</strong>\'+escapeHtml((ticket.implementationAccountName||"n/a")+" ("+(ticket.implementationAccountId||"n/a")+")")+\'</div><div class="mini-card"><strong>Activity</strong>\'+escapeHtml(ticket.activityLabel||formatTime(ticket.activityAt||ticket.updatedAt))+\'</div></div><div class="muted">\'+escapeHtml(ticket.affectedComponent||"No affected component recorded.")+\'</div>\'+codeBlock(key+":cmd",command)+\'</div>\';}' +
+        'function renderSupportTickets(state){const target=document.getElementById("support-ticket-section");const support=state.supportTickets||{};const tickets=support.tickets||[];const queues=support.queues||[];const errors=support.errors||[];const counts=support.counts||{};let html=\'<div class="mini-grid"><div class="mini-card"><strong>Open</strong>\'+escapeHtml(String(support.totalCount||0))+\'</div><div class="mini-card"><strong>Routed To An Agent</strong>\'+escapeHtml(String(counts.routed||0))+\'</div><div class="mini-card"><strong>Waiting</strong>\'+escapeHtml(String(counts.unrouted==null?Math.max(0,(support.totalCount||0)-(counts.routed||0)):counts.unrouted))+\'</div><div class="mini-card"><strong>Fetched</strong>\'+escapeHtml(formatTime(support.fetchedAt))+\'</div></div>\';if(errors.length){html+=detailsBlock("support:errors","Queue fetch errors",badge(String(errors.length)+" error(s)","warn"),codeBlock("support-errors",JSON.stringify(errors,null,2),"log"),false);}if(!queues.length&&!errors.length){target.innerHTML=html+\'<div class="empty">No authenticated support-ticket queue is available yet.</div>\';return;}if(tickets.length){html+=tickets.map(function(ticket,index){const routed=!!ticket.routedAgentId;const meta=badge(ticket.priority||"priority",ticket.priority==="critical"||ticket.priority==="high"?"bad":"warn")+\' \'+badge(ticket.status||"status",ticket.status==="open"?"ok":"warn")+\' \'+badge(routed?("routed: "+(ticket.routedAgentLabel||ticket.routedAgentId)):"unrouted",routed?"ok":"warn")+\' <span class="muted">\'+escapeHtml(ticket.accountName||ticket.accountId||"unknown account")+\'</span>\';return detailsBlock("support-ticket:"+ticket.ticketId,String(ticket.ticketId||"ticket")+" "+(ticket.subject||""),meta,supportTicketDetails(state,ticket,"support-ticket:"+index),index===0);}).join("");}else{html+=\'<div class="empty">No open support tickets were returned.</div>\';}target.innerHTML=html;}' +
+        'function supportTicketDetails(state,ticket,key){const agents=((state.agents||{}).registered)||[];const ticketAccountId=String(ticket.accountId||"");const eligible=agents.filter(function(a){return (a.accounts||[]).some(function(acc){return String(acc.accountId)===ticketAccountId||acc.routingScope==="self_and_descendants";});});const options=[\'<option value="">- unrouted -</option>\'].concat(eligible.map(function(a){const sel=a.agentId===ticket.routedAgentId?" selected":"";return \'<option value="\'+escapeHtml(a.agentId)+\'"\'+sel+\'>\'+escapeHtml((a.label||a.userName||a.agentId)+" - "+(a.state||"idle")+(a.activity?" ("+a.activity+")":""))+\'</option>\';})).join("");const routeControl=eligible.length?(\'<div class="mini-card"><strong>Route To Agent</strong><div style="display:flex;gap:8px;margin-top:6px;"><select data-route-ticket="\'+escapeHtml(String(ticket.ticketId||""))+\'" data-route-account="\'+escapeHtml(ticketAccountId)+\'" style="flex:1;min-width:0;">\'+options+\'</select><button class="action-btn" data-action="route-ticket" data-ticket="\'+escapeHtml(String(ticket.ticketId||""))+\'">Route</button></div></div>\'):\'<div class="mini-card"><strong>Route To Agent</strong>No registered agent covers this account.</div>\';const command="remits-cli tool --name mcp_support_ticket --input "+JSON.stringify(JSON.stringify({action:"read",ticketId:String(ticket.ticketId||"")}))+" --data-mode prod";return \'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Ticket</strong>\'+escapeHtml(ticket.ticketId||"n/a")+\'</div><div class="mini-card"><strong>Account</strong>\'+escapeHtml((ticket.accountName||"n/a")+" ("+(ticket.accountId||"n/a")+")")+\'</div><div class="mini-card"><strong>Type</strong>\'+escapeHtml(ticket.type||"n/a")+\'</div><div class="mini-card"><strong>Owned By</strong>\'+escapeHtml(ticket.assignedTo||"unassigned")+\'</div><div class="mini-card"><strong>Routed To</strong>\'+escapeHtml(ticket.routedAgentLabel||ticket.routedAgentId||"nobody")+\'</div><div class="mini-card"><strong>Implementation</strong>\'+escapeHtml((ticket.implementationAccountName||"n/a")+" ("+(ticket.implementationAccountId||"n/a")+")")+\'</div></div>\'+routeControl+\'<div class="muted">\'+escapeHtml(ticket.affectedComponent||"No affected component recorded.")+\'</div>\'+codeBlock(key+":cmd",command)+\'</div>\';}' +
         'function renderWebsockets(state){const entries=Object.entries((state.websocket&&state.websocket.connections)||{});const target=document.getElementById("websocket-section");if(!entries.length){target.innerHTML=\'<div class="empty">No websocket connections are registered yet.</div>\';return;}target.innerHTML=entries.map(function(pair){const baseUrl=pair[0];const info=pair[1]||{};const topicEntries=Object.entries(info.topics||{});const recentMessages=Array.isArray(info.recentMessages)?info.recentMessages:[];const tone=info.status==="connected"?"ok":(info.status==="connecting"?"warn":"bad");const summaryMeta=badge(info.status||"unknown",tone)+\' <span class="muted">\' + escapeHtml(String(topicEntries.length)) + \' topic(s)</span>\' + \' <span class="muted">\' + escapeHtml(String(recentMessages.length)) + \' recent message(s)</span>\';const topicBody=topicEntries.length?topicEntries.map(function(topicPair){const topic=topicPair[0];const topicInfo=topicPair[1]||{};const mini=\'<div class="mini-grid"><div class="mini-card"><strong>Accounts</strong>\'+escapeHtml((topicInfo.accountIds||[]).join(", ")||"n/a")+\'</div><div class="mini-card"><strong>Subscribed</strong>\'+escapeHtml(formatTime(topicInfo.subscribedAt))+\'</div><div class="mini-card"><strong>Last Message</strong>\'+escapeHtml(formatTime(topicInfo.lastMessageAt))+\'</div></div>\';return detailsBlock("ws-topic:"+baseUrl+":"+topic,topic,"topic subscription",mini,false);}).join(""):\'<div class="empty">No topic subscriptions recorded.</div>\';const messageBody=recentMessages.length?recentMessages.map(function(message,index){const messageMeta=badge(message.duplicate?"duplicate":"handled",message.duplicate?"warn":"ok")+\' <span class="muted">\'+escapeHtml(message.source||"live")+\'</span>\' + \' <span class="muted">\'+escapeHtml(message.type||"unknown-type")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Message ID</strong>\'+escapeHtml(message.messageId||"n/a")+\'</div><div class="mini-card"><strong>Timestamp</strong>\'+escapeHtml(message.timestamp?String(message.timestamp):"n/a")+\'</div><div class="mini-card"><strong>Received</strong>\'+escapeHtml(formatTime(message.receivedAt))+\'</div><div class="mini-card"><strong>Accounts</strong>\'+escapeHtml((message.accountIds||[]).join(", ")||"n/a")+\'</div></div>\'+codeBlock("ws-msg:"+baseUrl+":"+(message.messageId||index),JSON.stringify(message.payload||{},null,2)) + \'</div>\';return detailsBlock("ws-message:"+baseUrl+":"+(message.messageId||index),(message.type||"message")+" "+(message.messageId||""),messageMeta,body,false);}).join(""):\'<div class="empty">No recent websocket messages have been recorded yet.</div>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Status</strong>\'+escapeHtml(info.status||"unknown")+\'</div><div class="mini-card"><strong>Connected</strong>\'+escapeHtml(formatTime(info.connectedAt))+\'</div><div class="mini-card"><strong>Last Message</strong>\'+escapeHtml(formatTime(info.lastMessageAt))+\'</div><div class="mini-card"><strong>Last Error</strong>\'+escapeHtml(info.lastError||"none")+\'</div></div><div class="stack">\'+detailsBlock("ws-recent:"+baseUrl,"Recent messages","latest live and missed-message traffic",messageBody,false)+topicBody+\'</div></div>\';return detailsBlock("ws:"+baseUrl,baseUrl,summaryMeta,body,entries.length===1);}).join("");}' +
-        'function renderTmux(state){const target=document.getElementById("tmux-section");const panes=state.tmux&&state.tmux.livePanes||[];const trackedText=state.tmux&&state.tmux.trackedPanes?state.tmux.trackedPanes:"{}";const launchSupported=state.tmux&&state.tmux.terminalLaunchSupported;const attachCommand="tmux attach -t "+(state.tmux&&state.tmux.sessionName||"remits-listener");const health=\'<div class="mini-grid"><div class="mini-card"><strong>tmux Installed</strong>\'+escapeHtml(String(state.tmux&&state.tmux.available))+\'</div><div class="mini-card"><strong>Session Exists</strong>\'+escapeHtml(String(state.tmux&&state.tmux.sessionExists))+\'</div><div class="mini-card"><strong>Session Name</strong>\'+escapeHtml(state.tmux&&state.tmux.sessionName||"n/a")+\'</div><div class="mini-card"><strong>Live Panes</strong>\'+escapeHtml(String(panes.length))+\'</div><div class="mini-card"><strong>Open from Dashboard</strong>\'+escapeHtml(launchSupported?"supported":"not supported")+\'</div></div><div class="muted" style="margin-bottom:14px;">\'+escapeHtml(launchSupported?"Use the Open Tmux Terminal button to bring Terminal forward and attach automatically.":"Dashboard-to-terminal launch is not supported on this platform. Run the attach command manually.")+\'</div>\';const quickAttach=detailsBlock("tmux:attach","Quick attach command","manual fallback",codeBlock("tmux-attach-cmd",attachCommand),false);const paneSection=detailsBlock("tmux:panes","Live panes",escapeHtml(String(panes.length))+" pane(s)",codeBlock("tmux-live-panes",JSON.stringify(panes,null,2),"log"),false);const trackedSection=detailsBlock("tmux:tracked","Tracked pane routing","ticket/task to pane mapping",codeBlock("tmux-tracked",trackedText),false);const logFile=(state.globalFiles||[]).find(function(file){return file.label==="tmux-activity.log (tail)";});const logSection=detailsBlock("tmux:activity","Activity tail","stream of tmux and websocket events",codeBlock("tmux-log",logFile&&logFile.content||"[missing]","log"),true);target.innerHTML=health+quickAttach+paneSection+trackedSection+logSection;const openButton=document.querySelector(\'[data-action="open-tmux"]\');if(openButton){openButton.disabled=!launchSupported||!(state.tmux&&state.tmux.available);}}' +
-        'function renderGlobalFiles(state){const target=document.getElementById("global-files");const files=(state.globalFiles||[]).filter(function(file){return file.label!=="tmux-activity.log (tail)";});if(!files.length){target.innerHTML=\'<div class="empty">No global files found.</div>\';return;}target.innerHTML=files.map(function(file){const tone=file.exists?"ok":"warn";const meta=badge(file.exists?"present":"missing",tone)+\' <span class="muted">\'+escapeHtml(file.updatedAt?formatTime(file.updatedAt):"not found")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Path</strong>\'+escapeHtml(file.path||"")+\'</div><div class="mini-card"><strong>Size</strong>\'+escapeHtml(String(file.size||0))+\' bytes</div><div class="mini-card"><strong>Updated</strong>\'+escapeHtml(formatTime(file.updatedAt))+\'</div></div>\'+codeBlock("global:"+file.label,file.content)+(file.label==="service-state.json"?\'<div class="muted">Use this file to discover the dashboard URL and runtime websocket summary.</div>\':"")+\'</div>\';return detailsBlock("global:"+file.label,file.label,meta,body,false);}).join("");}' +
+        'function agentTone(agent){if(!agent||agent.online===false)return "bad";const s=agent.state||"idle";return s==="paused"?"warn":"ok";}' +
+        'function renderAgents(state){const target=document.getElementById("agent-section");const info=state.agents||{};const agents=info.registered||[];const local=info.local||[];const errors=info.errors||[];let html=\'<div class="mini-grid"><div class="mini-card"><strong>Registered</strong>\'+escapeHtml(String(agents.length))+\'</div><div class="mini-card"><strong>On This Machine</strong>\'+escapeHtml(String(local.length))+\'</div><div class="mini-card"><strong>Fetched</strong>\'+escapeHtml(formatTime(info.fetchedAt))+\'</div></div>\';if(errors.length){html+=detailsBlock("agents:errors","Agent lookup errors",badge(String(errors.length)+" error(s)","warn"),codeBlock("agents-errors",JSON.stringify(errors,null,2),"log"),false);}if(!agents.length){target.innerHTML=html+\'<div class="empty">No local agent sessions are registered. In each terminal tab that should work tickets, run <strong>remits-cli agent register</strong>. Each tab becomes its own routable agent and stops receiving work when the tab closes.</div>\';return;}html+=agents.map(function(agent,index){const tone=agentTone(agent);const meta=badge(agent.state||"idle",tone)+\' \'+badge((agent.dataMode||"prod")+" lane",agent.dataMode==="test"?"warn":"ok")+\' <span class="muted">seen \'+escapeHtml(agent.secondsSinceSeen==null?"?":agent.secondsSinceSeen+"s ago")+\'</span>\';const accounts=(agent.accounts||[]).map(function(a){return (a.name||a.accountId)+" ("+a.accountId+(a.routingScope==="self_and_descendants"?", +descendants":"")+")";}).join(", ");const history=(agent.history||[]).map(function(h){return \'<li><span class="muted">\'+escapeHtml(formatTime(h.at))+\'</span> \'+escapeHtml((h.state||"")+(h.ticketId?" ticket "+h.ticketId:"")+(h.activity?" - "+h.activity:""))+\'</li>\';}).join("");const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Doing Now</strong>\'+escapeHtml(agent.activity||"nothing reported")+\'</div><div class="mini-card"><strong>Ticket</strong>\'+escapeHtml(agent.ticketId||"none")+\'</div><div class="mini-card"><strong>Step</strong>\'+escapeHtml(agent.step||"n/a")+\'</div><div class="mini-card"><strong>User</strong>\'+escapeHtml(agent.userEmail||agent.userName||"n/a")+\'</div><div class="mini-card"><strong>Where</strong>\'+escapeHtml((agent.host||"?")+":"+(agent.cwd||"?"))+\'</div><div class="mini-card"><strong>Tickets Routed</strong>\'+escapeHtml(String(agent.ticketsAssigned||0))+\'</div></div><div class="mini-card"><strong>Covers</strong>\'+escapeHtml(accounts||"none")+\'</div><div><strong style="display:block;margin:12px 0 8px 0;">Recent activity</strong><ul style="margin:0;padding-left:18px;display:grid;gap:6px;">\'+(history||"<li>Nothing recorded yet.</li>")+\'</ul></div></div>\';return detailsBlock("agent:"+agent.agentId,(agent.label||agent.userName||agent.agentId),meta,body,index===0);}).join("");target.innerHTML=html;}' +
+        'function renderActivity(state){const target=document.getElementById("activity-section");const logFile=(state.globalFiles||[]).find(function(file){return file.label==="activity.log (tail)";});target.innerHTML=detailsBlock("activity:log","Activity tail","service lifecycle, websocket, and agent events",codeBlock("activity-log",logFile&&logFile.content||"[missing]","log"),true);}' +
+        'function renderGlobalFiles(state){const target=document.getElementById("global-files");const files=(state.globalFiles||[]).filter(function(file){return file.label!=="activity.log (tail)";});if(!files.length){target.innerHTML=\'<div class="empty">No global files found.</div>\';return;}target.innerHTML=files.map(function(file){const tone=file.exists?"ok":"warn";const meta=badge(file.exists?"present":"missing",tone)+\' <span class="muted">\'+escapeHtml(file.updatedAt?formatTime(file.updatedAt):"not found")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Path</strong>\'+escapeHtml(file.path||"")+\'</div><div class="mini-card"><strong>Size</strong>\'+escapeHtml(String(file.size||0))+\' bytes</div><div class="mini-card"><strong>Updated</strong>\'+escapeHtml(formatTime(file.updatedAt))+\'</div></div>\'+codeBlock("global:"+file.label,file.content)+(file.label==="service-state.json"?\'<div class="muted">Use this file to discover the dashboard URL and runtime websocket summary.</div>\':"")+\'</div>\';return detailsBlock("global:"+file.label,file.label,meta,body,false);}).join("");}' +
         'function renderRepos(state){const target=document.getElementById("repo-section");const repos=state.repos||[];if(!repos.length){target.innerHTML=\'<div class="empty">No indexed account repos were found. Use "Rescan Account Repos" to rebuild the index.</div>\';return;}target.innerHTML=repos.map(function(repo){const tone=repo.exists?"ok":"warn";const meta=badge(repo.exists?"available":"missing",tone)+\' <span class="muted">type: \'+escapeHtml(repo.type||"n/a")+\'</span>\';const files=(repo.files||[]).map(function(file){const fileMeta=badge(file.exists?"present":"missing",file.exists?"ok":"warn")+\' <span class="muted">\'+escapeHtml(file.updatedAt?formatTime(file.updatedAt):"not found")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Path</strong>\'+escapeHtml(file.path||"")+\'</div><div class="mini-card"><strong>Size</strong>\'+escapeHtml(String(file.size||0))+\' bytes</div><div class="mini-card"><strong>Updated</strong>\'+escapeHtml(formatTime(file.updatedAt))+\'</div></div>\'+codeBlock("repo:"+repo.accountId+":"+file.label,file.content,file.label.indexOf("session log")>=0?"log":"")+\'</div>\';return detailsBlock("repo-file:"+repo.accountId+":"+file.label,file.label,fileMeta,body,false);}).join("");const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Directory</strong>\'+escapeHtml(repo.directory||"")+\'</div><div class="mini-card"><strong>Source</strong>\'+escapeHtml(repo.source||"n/a")+\'</div><div class="mini-card"><strong>Platform Account</strong>\'+escapeHtml(String(repo.platformAccountId||"n/a"))+\'</div></div><div class="repo-files">\'+files+\'</div></div>\';return detailsBlock("repo:"+repo.accountId,(repo.name||"Unknown")+" ("+repo.accountId+")",meta,body,false);}).join("");}' +
-        'function renderAll(state){const detailState=saveDetailsState();const scrollState=saveScrollState();dashboardState=state;document.getElementById("generated-at").textContent=formatTime(state.generatedAt);renderStatusCards(state);renderSummary(state);renderLastAction(state);renderSupportTickets(state);renderIssues(state);renderWebsockets(state);renderTmux(state);renderGlobalFiles(state);renderRepos(state);restoreDetailsState(detailState);restoreScrollState(scrollState);}' +
+        'function renderAll(state){const detailState=saveDetailsState();const scrollState=saveScrollState();dashboardState=state;document.getElementById("generated-at").textContent=formatTime(state.generatedAt);renderStatusCards(state);renderSummary(state);renderLastAction(state);renderSupportTickets(state);renderIssues(state);renderWebsockets(state);renderAgents(state);renderActivity(state);renderGlobalFiles(state);renderRepos(state);restoreDetailsState(detailState);restoreScrollState(scrollState);}' +
         'async function fetchState(){const res=await fetch("/api/state",{cache:"no-store"});if(!res.ok)throw new Error("State refresh failed with "+res.status);return res.json();}' +
         'function showToast(message){const toast=document.getElementById("toast");toast.textContent=message;toast.classList.add("show");clearTimeout(showToast._timer);showToast._timer=setTimeout(function(){toast.classList.remove("show");},2400);}' +
-        'async function triggerAction(action,button){if(actionInFlight)return;actionInFlight=true;button.disabled=true;try{const res=await fetch("/action",{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded","Accept":"application/json"},body:"action="+encodeURIComponent(action)});if(!res.ok)throw new Error("Action failed with "+res.status);const payload=await res.json();renderAll(payload.state);if(payload.result&&payload.result.bundlePath){showToast("Issue bundle prepared at "+payload.result.bundlePath);}else{showToast(action.replace(/-/g," ")+" complete");}}catch(err){showToast(err.message||String(err));}finally{actionInFlight=false;button.disabled=false;}}' +
-        'document.querySelectorAll("[data-action]").forEach(function(button){button.addEventListener("click",function(){triggerAction(button.getAttribute("data-action"),button);});});' +
+        'async function triggerAction(action,button,extra){if(actionInFlight)return;actionInFlight=true;button.disabled=true;try{let body="action="+encodeURIComponent(action);Object.keys(extra||{}).forEach(function(k){body+="&"+encodeURIComponent(k)+"="+encodeURIComponent(extra[k]==null?"":extra[k]);});const res=await fetch("/action",{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded","Accept":"application/json"},body:body});if(!res.ok)throw new Error("Action failed with "+res.status);const payload=await res.json();renderAll(payload.state);if(payload.result&&payload.result.bundlePath){showToast("Issue bundle prepared at "+payload.result.bundlePath);}else{showToast(action.replace(/-/g," ")+" complete");}}catch(err){showToast(err.message||String(err));}finally{actionInFlight=false;button.disabled=false;}}' +
+        'document.addEventListener("click",function(event){const button=event.target.closest?event.target.closest("[data-action]"):null;if(!button)return;const action=button.getAttribute("data-action");let extra=null;if(action==="route-ticket"){const ticketId=button.getAttribute("data-ticket");const select=document.querySelector(\'[data-route-ticket="\'+ticketId+\'"]\');if(!select){showToast("No agent selector for that ticket.");return;}extra={ticketId:ticketId,accountId:select.getAttribute("data-route-account"),agentId:select.value};}triggerAction(action,button,extra);});' +
         'renderAll(dashboardState);' +
         'setInterval(function(){fetchState().then(renderAll).catch(function(err){showToast(err.message||String(err));});},refreshMs);' +
       '})();' +
@@ -5116,15 +4983,19 @@ function startDashboardServer(preferredPort) {
             } else if (action === 'rescan-repos') {
               recordDiscoverySummary(discoverAccountRepos());
               supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
-              await bestEffortRegisterCliListeners({ reason: 'dashboard.rescan' });
-            } else if (action === 'open-tmux') {
-              openTmuxSessionForUser();
-            } else if (action === 'start-tmux') {
-              ensureTmuxSession(os.homedir());
-            } else if (action === 'stop-tmux') {
-              killTmuxSession();
+            } else if (action === 'refresh-agents') {
+              agentSnapshotCache = { fetchedAtMs: 0, value: null };
+              supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
             } else if (action === 'reconnect-websockets') {
               await reconnectManagedWebsockets();
+            } else if (action === 'route-ticket') {
+              actionResult = await routeTicketFromDashboard({
+                ticketId: params.get('ticketId'),
+                accountId: params.get('accountId'),
+                agentId: params.get('agentId')
+              });
+              supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
+              agentSnapshotCache = { fetchedAtMs: 0, value: null };
             }
             if (wantsJson) {
               res.statusCode = 200;
@@ -5186,518 +5057,110 @@ function startDashboardServer(preferredPort) {
   });
 }
 
-// --- Agent CLI dispatch via tmux ---
-const TMUX_SESSION_NAME = 'remits-listener';
-const DISPATCH_STATE_FILE = path.join(SESSION_DIR, 'dispatch-panes.json');
-
-// In-memory map of support-ticket routing key -> tmux pane ID (persisted for crash recovery)
-let paneMap = {};
-
-function dispatchTicketId(message) {
-  if (!message || typeof message !== 'object') return null;
-  if (message.ticketId !== undefined && message.ticketId !== null && String(message.ticketId).trim()) {
-    return String(message.ticketId).trim();
+function publishMissedMessageRequest(client, baseUrl, userId) {
+  if (!userId) {
+    return;
   }
-  return null;
+  const since = lastMessageTimestampForScope(baseUrl, userId);
+  client.publish({
+    destination: '/app/missed-messages',
+    body: JSON.stringify({
+      userId: String(userId),
+      since
+    })
+  });
+  appendGlobalActivityLog('listener', 'websocket.missed_messages.requested', {
+    baseUrl,
+    userId,
+    since
+  });
 }
 
-function dispatchRoutingKey(message) {
-  const ticketId = dispatchTicketId(message);
-  if (ticketId) return 'ticket:' + ticketId;
-  if (message && message.taskId !== undefined && message.taskId !== null && String(message.taskId).trim()) {
-    return 'task:' + String(message.taskId).trim();
+function acknowledgeWebsocketMessage(client, messageId, userIds = []) {
+  if (!messageId) {
+    return;
   }
-  return null;
+  const primaryUserId = userIds.find(Boolean);
+  const body = primaryUserId
+    ? { messageId, userId: String(primaryUserId) }
+    : { messageId };
+  client.publish({
+    destination: '/app/ack',
+    body: JSON.stringify(body)
+  });
 }
 
-function loadPaneMap() {
-  if (fs.existsSync(DISPATCH_STATE_FILE)) {
-    try {
-      paneMap = JSON.parse(fs.readFileSync(DISPATCH_STATE_FILE, 'utf8'));
-    } catch (_) {
-      paneMap = {};
-    }
+function processInboundWebsocketMessage(client, baseUrl, topic, accountIds, userIds, source, rawMessage) {
+  const data = rawMessage && typeof rawMessage === 'object' ? rawMessage : {};
+  const messageId = data.messageId ? String(data.messageId) : null;
+  const duplicate = messageId ? hasProcessedMessageId(messageId) : false;
+
+  recordWebsocketMessage(baseUrl, topic, data, {
+    source,
+    duplicate,
+    accountIds
+  });
+
+  if (messageId) {
+    acknowledgeWebsocketMessage(client, messageId, userIds);
   }
-}
 
-function savePaneMap() {
-  ensureSessionDir();
-  atomicWriteFile(DISPATCH_STATE_FILE, JSON.stringify(paneMap, null, 2));
-}
+  updateLastMessageTimestamp(baseUrl, userIds, data.timestamp);
+  runtimeState.websocket[baseUrl].lastMessageAt = new Date().toISOString();
+  if (runtimeState.websocket[baseUrl].topics[topic]) {
+    runtimeState.websocket[baseUrl].topics[topic].lastMessageAt = runtimeState.websocket[baseUrl].lastMessageAt;
+  }
 
-function isTmuxAvailable() {
-  try {
-    execSync('which tmux', { stdio: 'ignore' });
-    return true;
-  } catch (_) {
-    return false;
+  if (duplicate) {
+    appendGlobalActivityLog('listener', 'websocket.duplicate_ignored', {
+      baseUrl,
+      topic,
+      messageId,
+      source
+    });
+    updateRuntimeServiceState();
+    return;
   }
-}
 
-function tmuxSessionExists() {
-  try {
-    execSync('tmux has-session -t ' + shellQuote(TMUX_SESSION_NAME), { stdio: 'ignore' });
-    return true;
-  } catch (_) {
-    return false;
+  if (messageId) {
+    rememberProcessedMessageId(messageId);
   }
-}
 
-function tmuxPaneIsAlive(paneId) {
-  try {
-    // Check both that the pane exists AND that it's not dead
-    const output = execSync(
-      'tmux list-panes -a -F ' + shellQuote('#{pane_id} #{pane_dead}'),
-      { stdio: ['ignore', 'pipe', 'ignore'] }
-    ).toString();
-    const lines = output.split('\n').map((l) => l.trim()).filter(Boolean);
-    for (const line of lines) {
-      const [id, dead] = line.split(' ');
-      if (id === paneId) {
-        return dead !== '1';
-      }
+  if (data.type === 'TestSuite') {
+    const payload = data.payload || {};
+    const payloadTaskId = payload.taskId || null;
+    const currentTestTaskId = runtimeState.currentTestTaskId || null;
+    if (payloadTaskId && currentTestTaskId && payloadTaskId !== currentTestTaskId) {
+      updateRuntimeServiceState();
+      return;
     }
-    return false; // pane not found at all
-  } catch (_) {
-    return false;
+    if (payload.tests || payload.name || payload.total != null) {
+      const acctId = payload.accountId || accountIds[0];
+      console.log('[ws][TestSuite][account:' + acctId + ']', JSON.stringify(payload));
+    }
+  } else if (data.type === 'remits-cli' || data.type === 'cli_listener' || data.type === 'listener') {
+    // A ticket nudge. The hand-off itself is durable on the ticket and is collected by whichever
+    // agent session it was routed to, so nothing is dispatched from here: this only refreshes what
+    // the dashboard shows a human, and records the event for triage.
+    const payload = data.payload || data;
+    const nudgeAccountId = Number(payload.accountId || accountIds[0]) || accountIds[0];
+    console.log('[ws][ticket][account:' + nudgeAccountId + ']', JSON.stringify(payload));
+    appendGlobalActivityLog('ticket', 'nudge.received', {
+      baseUrl,
+      topic,
+      accountId: nudgeAccountId,
+      ticketId: payload.ticketId || null,
+      agentId: payload.agentId || null,
+      messageType: data.type,
+      source,
+      messageId,
+      message: summarizeDispatchMessage(payload)
+    });
+    supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
+    agentSnapshotCache = { fetchedAtMs: 0, value: null };
   }
-}
-
-function killPane(paneId) {
-  try {
-    execSync('tmux kill-pane -t ' + shellQuote(paneId), { stdio: 'ignore' });
-    appendGlobalActivityLog('tmux', 'pane.killed', { paneId });
-  } catch (_) {}
-}
 
-function killTmuxSession() {
-  if (!tmuxSessionExists()) return;
-  try {
-    execSync('tmux kill-session -t ' + shellQuote(TMUX_SESSION_NAME), { stdio: 'ignore' });
-    appendGlobalActivityLog('tmux', 'session.killed', { sessionName: TMUX_SESSION_NAME });
-  } catch (_) {}
-}
-
-function configureTmuxSession() {
-  const commands = [
-    'tmux set-option -t ' + shellQuote(TMUX_SESSION_NAME) + ' mouse on',
-    'tmux set-option -t ' + shellQuote(TMUX_SESSION_NAME) + ' history-limit 100000',
-    'tmux set-window-option -t ' + shellQuote(TMUX_SESSION_NAME) + ' remain-on-exit on',
-    'tmux set-window-option -t ' + shellQuote(TMUX_SESSION_NAME) + ' scroll-on-clear on',
-    'tmux set-window-option -t ' + shellQuote(TMUX_SESSION_NAME) + ' automatic-rename off'
-  ];
-  for (const command of commands) {
-    try {
-      execSync(command, { stdio: 'ignore' });
-    } catch (_) {}
-  }
-}
-
-function ensureTmuxSession(accountDir) {
-  if (!isTmuxAvailable()) {
-    appendGlobalActivityLog('tmux', 'session.create_skipped.tmux_unavailable', { accountDir }, 'error');
-    return false;
-  }
-  if (tmuxSessionExists()) return;
-  execSync(
-    'tmux new-session -d -s ' + shellQuote(TMUX_SESSION_NAME) + ' -n ' + shellQuote('listener') + ' -c ' + shellQuote(accountDir),
-    { stdio: 'ignore' }
-  );
-  configureTmuxSession();
-  console.log('[listener] Created tmux session:', TMUX_SESSION_NAME);
-  appendGlobalActivityLog('tmux', 'session.created', {
-    sessionName: TMUX_SESSION_NAME,
-    accountDir
-  });
-  return true;
-}
-
-function canLaunchTerminalForTmux() {
-  return process.platform === 'darwin';
-}
-
-function openTmuxSessionForUser() {
-  if (!isTmuxAvailable()) {
-    throw new Error('tmux is not installed');
-  }
-
-  if (!tmuxSessionExists()) {
-    ensureTmuxSession(os.homedir());
-  }
-
-  const attachCommand = 'tmux attach -t ' + TMUX_SESSION_NAME + ' || tmux new-session -A -s ' + TMUX_SESSION_NAME;
-
-  if (process.platform === 'darwin') {
-    const osaScript = [
-      'tell application "Terminal"',
-      'activate',
-      'do script ' + JSON.stringify(attachCommand),
-      'end tell'
-    ].join('\n');
-    execSync('osascript -e ' + shellQuote(osaScript), { stdio: 'ignore' });
-    appendGlobalActivityLog('tmux', 'terminal.opened', {
-      sessionName: TMUX_SESSION_NAME,
-      command: attachCommand
-    });
-    return {
-      success: true,
-      method: 'terminal',
-      command: attachCommand
-    };
-  }
-
-  throw new Error('Opening a terminal window is not supported on this platform yet. Run `' + attachCommand + '` manually.');
-}
-
-function dispatchWindowName(accountId, routingKey) {
-  const base = routingKey || ('account:' + accountId) || 'dispatch';
-  return base
-    .replace(/[^a-zA-Z0-9:_-]+/g, '-')
-    .slice(0, 40) || 'dispatch';
-}
-
-function resolveAgentCommand(agent, prompt) {
-  const escapedPrompt = prompt.replace(/'/g, "'\"'\"'");
-  // All agents are launched in interactive mode so the user can watch and interact.
-  // claude: positional arg starts interactive session with initial prompt
-  // codex: positional arg starts interactive session with initial prompt
-  // gemini: positional arg starts interactive session with initial prompt
-  switch (agent) {
-    case 'claude':
-      return "claude '" + escapedPrompt + "'";
-    case 'codex':
-      return "codex '" + escapedPrompt + "'";
-    case 'gemini':
-      return "gemini '" + escapedPrompt + "'";
-    default:
-      return "claude '" + escapedPrompt + "'";
-  }
-}
-
-function resolveAccountDir(accountId) {
-  if (!fs.existsSync(ACCOUNT_REPO_INDEX_FILE)) return null;
-  try {
-    const index = JSON.parse(fs.readFileSync(ACCOUNT_REPO_INDEX_FILE, 'utf8'));
-    const entry = index[String(accountId)];
-    if (entry && entry.directory && fs.existsSync(entry.directory)) {
-      return entry.directory;
-    }
-  } catch (_) {}
-  return null;
-}
-
-function normalizeDispatchAccountId(value) {
-  if (value === undefined || value === null) return null;
-  const trimmed = String(value).trim();
-  return trimmed ? trimmed : null;
-}
-
-function resolveDispatchAccountId(message, fallbackAccountId) {
-  const candidates = [
-    normalizeDispatchAccountId(message && message.implementationAccountId),
-    normalizeDispatchAccountId(message && message.accountId),
-    normalizeDispatchAccountId(fallbackAccountId)
-  ].filter(Boolean);
-
-  const uniqueCandidates = [];
-  for (const candidate of candidates) {
-    if (!uniqueCandidates.includes(candidate)) {
-      uniqueCandidates.push(candidate);
-    }
-  }
-
-  for (const candidate of uniqueCandidates) {
-    if (resolveAccountDir(candidate)) {
-      return candidate;
-    }
-  }
-
-  return uniqueCandidates[0] || null;
-}
-
-function sendKeysToPane(paneId, text) {
-  // Paste through a tmux buffer so multiline follow-ups are injected reliably
-  // into interactive agent UIs, then submit them explicitly.
-  const bufferName = 'remits-cli-' + crypto.randomUUID();
-  try {
-    execSync(
-      'tmux load-buffer -b ' + shellQuote(bufferName) + ' -',
-      { input: text, stdio: ['pipe', 'ignore', 'ignore'] }
-    );
-    execSync(
-      'tmux paste-buffer -d -b ' + shellQuote(bufferName) + ' -t ' + shellQuote(paneId),
-      { stdio: 'ignore' }
-    );
-    execSync(
-      'tmux send-keys -t ' + shellQuote(paneId) + ' Enter',
-      { stdio: 'ignore' }
-    );
-  } finally {
-    try {
-      execSync('tmux delete-buffer -b ' + shellQuote(bufferName), { stdio: 'ignore' });
-    } catch (_) {}
-  }
-}
-
-function buildDispatchPrompt(message, options) {
-  const dispatchOptions = options && typeof options === 'object' ? options : {};
-  const textPrompt = message && (message.prompt || message.message);
-  const context = message && typeof message === 'object' ? Object.assign({}, message) : {};
-  delete context.prompt;
-  delete context.message;
-
-  const instructionLines = [
-    'This message was delivered by the remits-cli tool from an inbound platform message.',
-    'When triaging and handling this request, load and use the remits-cli skill.'
-  ];
-
-  if (dispatchOptions.noAccountDir === true) {
-    instructionLines.push('remits-cli dispatch status: no_account_dir.');
-    instructionLines.push('The listener could not resolve an account directory from the ticket payload, but you should still handle the request and work with the user to gather any additional account details if needed.');
-  }
-
-  if (textPrompt) {
-    instructionLines.push('');
-    instructionLines.push('Inbound message:');
-    instructionLines.push(textPrompt);
-  }
-
-  if (Object.keys(context).length) {
-    instructionLines.push('');
-    instructionLines.push('Dispatch context:');
-    instructionLines.push('```json');
-    instructionLines.push(JSON.stringify(context, null, 2));
-    instructionLines.push('```');
-  }
-
-  return instructionLines.join('\n');
-}
-
-function dispatchToAgent(accountId, message) {
-  const accountDir = resolveAccountDir(accountId);
-
-  if (!isTmuxAvailable()) {
-    console.error('[listener] tmux is not installed. Cannot dispatch agent session.');
-    appendGlobalActivityLog('tmux', 'dispatch.skipped.tmux_unavailable', {
-      accountId,
-      accountDir,
-      message: summarizeDispatchMessage(message)
-    }, 'error');
-    return;
-  }
-
-  const ticketId = dispatchTicketId(message);
-  const routingKey = dispatchRoutingKey(message);
-  const prompt = buildDispatchPrompt(message, {
-    noAccountDir: !accountDir
-  });
-
-  if (!accountDir) {
-    console.error('[listener] No known directory for account', accountId, '- dispatching anyway');
-    appendGlobalActivityLog('tmux', 'dispatch.no_account_dir', {
-      accountId,
-      message: summarizeDispatchMessage(message)
-    }, 'error');
-  }
-
-  // If this ticket already has a tracked pane, check its state
-  if (routingKey && paneMap[routingKey]) {
-    const existingPaneId = paneMap[routingKey];
-    if (tmuxPaneIsAlive(existingPaneId)) {
-      // Pane is alive, so deliver the follow-up to the existing ticket workstream
-      console.log('[listener] Delivering follow-up for', routingKey, 'to existing pane', existingPaneId);
-      appendGlobalActivityLog('tmux', 'dispatch.follow_up', {
-        accountId,
-        accountDir,
-        ticketId,
-        routingKey,
-        paneId: existingPaneId,
-        message: summarizeDispatchMessage(message)
-      });
-      try {
-        sendKeysToPane(existingPaneId, prompt);
-        return;
-      } catch (err) {
-        console.error('[listener] Failed to send to pane', existingPaneId, ':', err.message, '- creating new pane');
-        appendGlobalActivityLog('tmux', 'dispatch.follow_up_failed', {
-          accountId,
-          accountDir,
-          ticketId,
-          routingKey,
-          paneId: existingPaneId,
-          error: err.message,
-          message: summarizeDispatchMessage(message)
-        }, 'error');
-      }
-    }
-    // Pane is dead or gone, so replace it for this ticket/task routing key.
-    console.log('[listener] Pane', existingPaneId, 'for', routingKey, 'is dead or gone - replacing');
-    appendGlobalActivityLog('tmux', 'dispatch.pane_replaced', {
-      accountId,
-      accountDir,
-      ticketId,
-      routingKey,
-      paneId: existingPaneId,
-      message: summarizeDispatchMessage(message)
-    });
-    killPane(existingPaneId);
-    delete paneMap[routingKey];
-    savePaneMap();
-  }
-
-  // Create a new pane for this task
-  try {
-    const paneDir = accountDir || os.homedir();
-    ensureTmuxSession(paneDir);
-
-    const agent = getPreferredAgent();
-    const agentCmd = resolveAgentCommand(agent, prompt);
-    const windowName = dispatchWindowName(accountId, routingKey);
-
-    // Wrap in a login shell so the pane inherits the user's full PATH
-    // (the daemonized listener process has a minimal environment)
-    const userShell = process.env.SHELL || '/bin/zsh';
-    const loginCmd = userShell + ' -l -c ' + shellQuote(agentCmd);
-
-    // Create a dedicated window for this workstream so full-screen agent UIs
-    // remain readable and easy to inspect.
-    const paneInfo = execSync(
-      'tmux new-window -t ' + shellQuote(TMUX_SESSION_NAME) +
-      ' -n ' + shellQuote(windowName) +
-      ' -c ' + shellQuote(paneDir) +
-      ' -P -F ' + shellQuote('#{pane_id}') +
-      ' ' + shellQuote(loginCmd),
-      { stdio: ['ignore', 'pipe', 'ignore'] }
-    ).toString().trim();
-
-    console.log('[listener] Dispatched', routingKey || '(untracked message)', 'to', agent, 'in pane', paneInfo, 'at', accountDir);
-    appendGlobalActivityLog('tmux', 'dispatch.created', {
-      accountId,
-      accountDir: paneDir,
-      resolvedAccountDir: accountDir,
-      ticketId,
-      routingKey,
-      paneId: paneInfo,
-      agent,
-      message: summarizeDispatchMessage(message)
-    });
-
-    if (routingKey) {
-      paneMap[routingKey] = paneInfo;
-      savePaneMap();
-    }
-  } catch (err) {
-    console.error('[listener] Failed to create tmux pane:', err.message);
-    appendGlobalActivityLog('tmux', 'dispatch.create_failed', {
-      accountId,
-      accountDir,
-      ticketId,
-      routingKey,
-      error: err.message,
-      agent: getPreferredAgent(),
-      message: summarizeDispatchMessage(message)
-    }, 'error');
-  }
-}
-
-function publishMissedMessageRequest(client, baseUrl, userId) {
-  if (!userId) {
-    return;
-  }
-  const since = lastMessageTimestampForScope(baseUrl, userId);
-  client.publish({
-    destination: '/app/missed-messages',
-    body: JSON.stringify({
-      userId: String(userId),
-      since
-    })
-  });
-  appendGlobalActivityLog('listener', 'websocket.missed_messages.requested', {
-    baseUrl,
-    userId,
-    since
-  });
-}
-
-function acknowledgeWebsocketMessage(client, messageId, userIds = []) {
-  if (!messageId) {
-    return;
-  }
-  const primaryUserId = userIds.find(Boolean);
-  const body = primaryUserId
-    ? { messageId, userId: String(primaryUserId) }
-    : { messageId };
-  client.publish({
-    destination: '/app/ack',
-    body: JSON.stringify(body)
-  });
-}
-
-function processInboundWebsocketMessage(client, baseUrl, topic, accountIds, userIds, source, rawMessage) {
-  const data = rawMessage && typeof rawMessage === 'object' ? rawMessage : {};
-  const messageId = data.messageId ? String(data.messageId) : null;
-  const duplicate = messageId ? hasProcessedMessageId(messageId) : false;
-
-  recordWebsocketMessage(baseUrl, topic, data, {
-    source,
-    duplicate,
-    accountIds
-  });
-
-  if (messageId) {
-    acknowledgeWebsocketMessage(client, messageId, userIds);
-  }
-
-  updateLastMessageTimestamp(baseUrl, userIds, data.timestamp);
-  runtimeState.websocket[baseUrl].lastMessageAt = new Date().toISOString();
-  if (runtimeState.websocket[baseUrl].topics[topic]) {
-    runtimeState.websocket[baseUrl].topics[topic].lastMessageAt = runtimeState.websocket[baseUrl].lastMessageAt;
-  }
-
-  if (duplicate) {
-    appendGlobalActivityLog('listener', 'websocket.duplicate_ignored', {
-      baseUrl,
-      topic,
-      messageId,
-      source
-    });
-    updateRuntimeServiceState();
-    return;
-  }
-
-  if (messageId) {
-    rememberProcessedMessageId(messageId);
-  }
-
-  if (data.type === 'TestSuite') {
-    const payload = data.payload || {};
-    const payloadTaskId = payload.taskId || null;
-    const currentTestTaskId = runtimeState.currentTestTaskId || null;
-    if (payloadTaskId && currentTestTaskId && payloadTaskId !== currentTestTaskId) {
-      updateRuntimeServiceState();
-      return;
-    }
-    if (payload.tests || payload.name || payload.total != null) {
-      const acctId = payload.accountId || accountIds[0];
-      console.log('[ws][TestSuite][account:' + acctId + ']', JSON.stringify(payload));
-    }
-  } else if (data.type === 'remits-cli' || data.type === 'cli_listener' || data.type === 'listener') {
-    const payload = data.payload || data;
-    const dispatchAccountId = resolveDispatchAccountId(payload, accountIds[0]);
-    console.log('[ws][listener][account:' + dispatchAccountId + ']', JSON.stringify(payload));
-    appendGlobalActivityLog('tmux', 'listener_delivery.received', {
-      baseUrl,
-      topic,
-      accountId: dispatchAccountId,
-      messageType: data.type,
-      source,
-      messageId,
-      message: summarizeDispatchMessage(payload)
-    });
-    dispatchToAgent(dispatchAccountId, payload);
-  }
-
-  updateRuntimeServiceState();
+  updateRuntimeServiceState();
 }
 
 function createManagedWebsocketClient(baseUrl, urlSessions) {
@@ -5915,42 +5378,6 @@ async function replaceManagedWebsocketClients(entries, reason) {
   });
 }
 
-function pruneDeadPaneMappings() {
-  const removed = [];
-  for (const [routingKey, paneId] of Object.entries(paneMap)) {
-    if (tmuxPaneIsAlive(paneId)) {
-      continue;
-    }
-    delete paneMap[routingKey];
-    removed.push({ routingKey, paneId });
-  }
-  if (removed.length) {
-    savePaneMap();
-    appendGlobalActivityLog('tmux', 'dispatch_state.pruned', {
-      removed
-    });
-  }
-}
-
-function ensureTmuxSessionHealthy(defaultDir) {
-  if (!isTmuxAvailable()) {
-    return;
-  }
-  if (tmuxSessionExists()) {
-    pruneDeadPaneMappings();
-    return;
-  }
-  const hadPaneMappings = Object.keys(paneMap).length > 0;
-  if (hadPaneMappings) {
-    paneMap = {};
-    savePaneMap();
-    appendGlobalActivityLog('tmux', 'dispatch_state.cleared.missing_session', {
-      sessionName: TMUX_SESSION_NAME
-    }, 'error');
-  }
-  ensureTmuxSession(defaultDir || os.homedir());
-}
-
 async function runManagedWebsocketWatchdog() {
   const now = Date.now();
   for (const managedClient of managedClients) {
@@ -6000,6 +5427,602 @@ async function runManagedWebsocketWatchdog() {
 }
 
 // --- Persistent WebSocket listener ---
+// ---------------------------------------------------------------------------------------------
+// Local agent sessions
+//
+// A "CLI agent" is ONE terminal session — one tab running Claude, Codex, or a person — that has
+// registered itself as available to work support tickets. Three tabs are three agents, each
+// independently routable and each reporting its own activity.
+//
+// Two halves, deliberately separate:
+//   * PRESENCE lives on the platform with a short TTL, refreshed by a heartbeat sidecar that dies
+//     with the tab it belongs to. A closed terminal therefore stops being routable within a couple
+//     of minutes without anyone having to deregister cleanly, and a crash and a quit look the same.
+//   * ASSIGNMENT lives on the ticket. That is why an agent can restart its terminal, or be offline
+//     when work is routed to it, and still find that work waiting.
+//
+// Nothing here pushes work at a terminal. An AI agent mid-task cannot receive a push, so it ASKS:
+// `remits-cli agent work` polls for tickets routed to it. That is the whole delivery mechanism.
+// ---------------------------------------------------------------------------------------------
+
+const AGENT_STATE_FILE = path.join(SESSION_DIR, 'agents.json');
+const AGENT_HEARTBEAT_INTERVAL_MS = Number(process.env.REMITS_CLI_AGENT_HEARTBEAT_MS || 30000);
+const AGENT_WORK_POLL_MS = Number(process.env.REMITS_CLI_AGENT_WORK_POLL_MS || 5000);
+const AGENT_WORK_DEFAULT_WAIT_SEC = Number(process.env.REMITS_CLI_AGENT_WORK_WAIT_SEC || 0);
+const AGENT_STATES = ['idle', 'working', 'paused'];
+
+function readAgentStore() {
+  if (!fs.existsSync(AGENT_STATE_FILE)) {
+    return { agents: {} };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(AGENT_STATE_FILE, 'utf8'));
+    return data && typeof data === 'object' && data.agents ? data : { agents: {} };
+  } catch (_) {
+    return { agents: {} };
+  }
+}
+
+function writeAgentStore(store) {
+  ensureSessionDir();
+  atomicWriteFile(AGENT_STATE_FILE, JSON.stringify(store || { agents: {} }, null, 2));
+}
+
+function processIsAlive(pid) {
+  const numeric = Number(pid);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return false;
+  }
+  try {
+    process.kill(numeric, 0);
+    return true;
+  } catch (err) {
+    // EPERM means the process exists but belongs to another user — still alive.
+    return err && err.code === 'EPERM';
+  }
+}
+
+/**
+ * The locally-known agent sessions, dropping any whose anchor process has gone.
+ *
+ * The store is a local convenience so a follow-up command in the same tab resolves the same agent
+ * without being told its id. It is never the source of truth: the platform's registry is.
+ */
+function listLocalAgents() {
+  const store = readAgentStore();
+  const alive = {};
+  let changed = false;
+  for (const [agentId, entry] of Object.entries(store.agents || {})) {
+    if (entry && processIsAlive(entry.anchorPid)) {
+      alive[agentId] = entry;
+    } else {
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeAgentStore({ agents: alive });
+  }
+  return Object.values(alive).sort((a, b) => Number(b.registeredAtMs || 0) - Number(a.registeredAtMs || 0));
+}
+
+function rememberLocalAgent(entry) {
+  const store = readAgentStore();
+  store.agents = store.agents || {};
+  store.agents[entry.agentId] = entry;
+  writeAgentStore(store);
+  return entry;
+}
+
+function forgetLocalAgent(agentId) {
+  const store = readAgentStore();
+  if (store.agents && store.agents[agentId]) {
+    delete store.agents[agentId];
+    writeAgentStore(store);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * The process whose death means "this agent session is over".
+ *
+ * Not our own parent: every `remits-cli` invocation from Claude Code, Codex, or a shell script gets
+ * a throwaway shell as its parent, and anchoring to that would kill the heartbeat the instant the
+ * registering command returned. So walk UP the process tree and anchor to the first ancestor that
+ * is recognisably the agent itself, then to the first interactive shell, and only then give up.
+ */
+function resolveAgentAnchorPid() {
+  const explicit = Number(process.env.REMITS_AGENT_ANCHOR_PID);
+  if (Number.isFinite(explicit) && explicit > 0 && processIsAlive(explicit)) {
+    return { pid: explicit, source: 'env', command: null };
+  }
+
+  const agentPattern = /(^|\/|\s)(claude|codex|gemini|cursor-agent|aider)(\s|$)/i;
+  const shellPattern = /(^|\/)(zsh|bash|fish|sh|ksh)$/i;
+  let shellCandidate = null;
+
+  try {
+    let pid = process.ppid;
+    for (let depth = 0; depth < 12 && pid && pid > 1; depth += 1) {
+      // pid 1 is launchd/init and never exits. Anchoring to it would register an agent that can never
+      // go offline, so the walk stops short of it and the caller refuses below.
+
+      const line = execFileSync('ps', ['-o', 'ppid=,command=', '-p', String(pid)], {
+        stdio: ['ignore', 'pipe', 'ignore']
+      }).toString().trim();
+      if (!line) break;
+      const match = line.match(/^\s*(\d+)\s+(.*)$/);
+      if (!match) break;
+      const parentPid = Number(match[1]);
+      const command = match[2];
+      if (agentPattern.test(command)) {
+        return { pid, source: 'agent', command };
+      }
+      if (!shellCandidate && shellPattern.test(String(command).split(/\s+/)[0] || '')) {
+        shellCandidate = { pid, source: 'shell', command };
+      }
+      pid = parentPid;
+    }
+  } catch (_) {
+    // ps is unavailable (or restricted). Fall through to the parent process.
+  }
+
+  if (shellCandidate) {
+    return shellCandidate;
+  }
+  const parent = process.ppid;
+  if (parent && parent > 1 && processIsAlive(parent)) {
+    return { pid: parent, source: 'parent', command: null };
+  }
+  // Nothing mortal to anchor to — typically a detached or orphaned process, whose parent is init.
+  // Registering here would create an agent that never expires and keeps receiving tickets forever,
+  // so refuse instead. Callers with a real session should pass REMITS_AGENT_ANCHOR_PID.
+  return { pid: null, source: 'none', command: null };
+}
+
+function agentLabelDefault(anchor, cwd) {
+  const repo = path.basename(cwd || process.cwd());
+  const kind = anchor && anchor.command && /claude/i.test(anchor.command) ? 'claude'
+    : anchor && anchor.command && /codex/i.test(anchor.command) ? 'codex'
+    : anchor && anchor.command && /gemini/i.test(anchor.command) ? 'gemini'
+    : getPreferredAgent();
+  return kind + '@' + repo;
+}
+
+/**
+ * Which agent session is THIS command acting as?
+ *
+ * Explicit beats implicit, and ambiguity is an error rather than a guess: routing work to the wrong
+ * tab is silent and confusing, whereas a message naming the candidates is neither.
+ */
+function resolveAgentId(flags, options = {}) {
+  const explicit = (flags && (flags['agent-id'] || flags.agentId)) || process.env.REMITS_AGENT_ID;
+  if (explicit) {
+    return String(explicit).trim();
+  }
+  const local = listLocalAgents();
+  if (!local.length) {
+    if (options.optional) return null;
+    throw new Error('No local agent is registered in this session. Run: remits-cli agent register');
+  }
+  const cwd = process.cwd();
+  const inCwd = local.filter((entry) => entry.cwd === cwd);
+  const candidates = inCwd.length ? inCwd : local;
+  if (candidates.length === 1) {
+    return candidates[0].agentId;
+  }
+  throw new Error(
+    'Several local agents are registered. Pass --agent-id (or set REMITS_AGENT_ID). Candidates:\n' +
+    candidates.map((entry) => '  ' + entry.agentId + '  ' + (entry.label || '') + '  ' + entry.cwd).join('\n')
+  );
+}
+
+function agentSessionFor(flags, entry) {
+  const cwd = (entry && entry.cwd) || process.cwd();
+  const context = resolveSessionContext(cwd, Object.assign({}, flags, {
+    'base-url': (flags && flags['base-url']) || (entry && entry.baseUrl) || undefined
+  }));
+  if (!context.session || !context.session.token) {
+    throw new Error('No authenticated session. Run: remits-cli auth');
+  }
+  // resolveSessionContext names it `resolvedBaseUrl` and resolves no data lane, so normalize both here
+  // rather than letting each caller re-derive them. Destructuring `{ baseUrl, dataMode }` off it yields
+  // undefined silently, and the failure then surfaces far away as an axios "Invalid URL".
+  return {
+    session: context.session,
+    accountId: context.accountId,
+    baseUrl: normalizeBaseUrl(context.resolvedBaseUrl || (entry && entry.baseUrl) || DEFAULT_BASE_URL),
+    dataMode: resolveDataMode(flags, context.session),
+    sessionResolutionWarning: context.sessionResolutionWarning
+  };
+}
+
+/** Every account repo checked out on this machine, as registration claims. The platform verifies them. */
+function agentAccountClaims(cwd) {
+  const claims = listAccountRepoEntries(readAccountRepoIndex()).map((entry) => ({
+    accountId: Number(entry.accountId),
+    name: entry.name || null,
+    type: entry.type || null,
+    platformAccountId: entry.platformAccountId || null,
+    directory: entry.directory || null,
+    routingScope: ['PLATFORM', 'PRODUCT'].includes(String(entry.type || '').toUpperCase())
+      ? 'self_and_descendants'
+      : 'self',
+    source: entry.source || 'repo'
+  })).filter((entry) => Number.isFinite(entry.accountId) && entry.accountId > 0);
+
+  // The repo the command was run from leads, so a tab working one account is routed that account's
+  // tickets first even when the machine has a dozen checkouts.
+  try {
+    const here = loadAccountId(cwd);
+    const index = claims.findIndex((entry) => entry.accountId === Number(here));
+    if (index > 0) {
+      claims.unshift(claims.splice(index, 1)[0]);
+    }
+  } catch (_) { /* not in an account repo */ }
+  return claims;
+}
+
+async function agentRegisterCommand(flags, options = {}) {
+  const cwd = process.cwd();
+  try { updateAccountRepoIndex(cwd); } catch (_) { /* not in an account repo */ }
+  try { discoverAccountRepos(); } catch (_) { /* best-effort */ }
+
+  const { session, baseUrl, dataMode } = agentSessionFor(flags, null);
+  const anchor = resolveAgentAnchorPid();
+  if (!anchor.pid) {
+    throw new Error(
+      'Could not find a process to anchor this agent to, so registering would create an agent that ' +
+      'never goes offline. Run this from an interactive terminal, or set REMITS_AGENT_ANCHOR_PID to ' +
+      'the pid whose exit should end this agent session.');
+  }
+  const explicitId = (flags['agent-id'] || flags.agentId || process.env.REMITS_AGENT_ID || '').trim();
+  // Adopt a previous registration only for THIS terminal. Matching on (cwd, anchorPid) alone was enough
+  // to let an unrelated record be adopted whenever two registrations shared an anchor.
+  const existingId = explicitId ||
+    (listLocalAgents().find((entry) =>
+      entry.cwd === cwd && entry.anchorPid === anchor.pid && entry.anchorSource === anchor.source) || {}).agentId ||
+    null;
+
+  const api = buildAxios(baseUrl, session.token, 15000);
+  const payload = {
+    agentId: existingId || undefined,
+    label: flags.label || agentLabelDefault(anchor, cwd),
+    agentType: flags.agent || getPreferredAgent(),
+    cliVersion: readCliVersion(),
+    host: os.hostname(),
+    pid: anchor.pid,
+    cwd,
+    dataMode,
+    accountId: Number(session.accountId) || undefined,
+    accounts: agentAccountClaims(cwd),
+    state: flags.state && AGENT_STATES.includes(String(flags.state)) ? String(flags.state) : 'idle',
+    activity: flags.activity || null,
+    source: flags.source || 'repo'
+  };
+
+  const response = await api.post('/cli/agentRegister', payload).then((r) => r.data);
+  if (!response || response.success === false) {
+    throw new Error((response && response.message) || 'Agent registration was refused.');
+  }
+
+  const entry = rememberLocalAgent({
+    agentId: response.agentId,
+    label: payload.label,
+    cwd,
+    baseUrl,
+    dataMode,
+    accountId: Number(session.accountId) || null,
+    anchorPid: anchor.pid,
+    anchorSource: anchor.source,
+    registeredAtMs: Date.now()
+  });
+
+  // A re-register from inside the heartbeat must not fork a second heartbeat: they would both keep
+  // re-registering, and the daemons multiply for as long as the platform stays unreachable.
+  if (options.spawnHeartbeat !== false) {
+    startAgentHeartbeatDaemon(entry);
+  }
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify({ ...response, local: entry }, null, 2));
+    return;
+  }
+
+  console.log('Registered agent ' + response.agentId);
+  console.log('  label      ' + payload.label);
+  console.log('  data lane  ' + dataMode + (dataMode === 'prod' ? '  (production data)' : ''));
+  console.log('  accounts   ' + (response.accountIds || []).join(', '));
+  console.log('  heartbeat  every ' + Math.round(AGENT_HEARTBEAT_INTERVAL_MS / 1000) + 's, anchored to pid ' +
+    anchor.pid + ' (' + anchor.source + ')');
+  if ((response.skippedAccounts || []).length) {
+    console.log('  refused    ' + response.skippedAccounts
+      .map((entry) => entry.accountId + ' (' + entry.reason + ')').join(', '));
+  }
+  console.log('');
+  console.log('This session is now available for support tickets. Ask for work with:');
+  console.log('  remits-cli agent work');
+}
+
+function readCliVersion() {
+  try {
+    return require(path.join(__dirname, 'package.json')).version || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Spawn the detached heartbeat that keeps this session visible.
+ *
+ * It is a separate process on purpose: the registering command must return immediately so the agent
+ * can get on with its work, and presence must continue between commands — an agent that only
+ * appeared online while it happened to be running remits-cli would be invisible for exactly the
+ * period it was busy working a ticket.
+ */
+function startAgentHeartbeatDaemon(entry) {
+  const { spawn } = require('child_process');
+  const child = spawn(process.execPath, [
+    __filename, 'agent', 'heartbeat-daemon',
+    '--agent-id', entry.agentId,
+    '--anchor-pid', String(entry.anchorPid),
+    '--base-url', entry.baseUrl,
+    '--cwd', entry.cwd
+  ], { detached: true, stdio: 'ignore', env: { ...process.env } });
+  child.unref();
+  appendGlobalActivityLog('agent', 'heartbeat.started', {
+    agentId: entry.agentId,
+    anchorPid: entry.anchorPid,
+    heartbeatPid: child.pid
+  });
+  return child.pid;
+}
+
+async function agentHeartbeatDaemonCommand(flags) {
+  const agentId = String(flags['agent-id'] || flags.agentId || '').trim();
+  const anchorPid = Number(flags['anchor-pid'] || flags.anchorPid);
+  const cwd = flags.cwd || process.cwd();
+  if (!agentId || !Number.isFinite(anchorPid)) {
+    throw new Error('agent heartbeat-daemon requires --agent-id and --anchor-pid.');
+  }
+
+  // The daemon runs detached, so its own process tree says nothing about the session it is watching.
+  // Re-registration must reuse the anchor it was given, never re-resolve one.
+  process.env.REMITS_AGENT_ANCHOR_PID = String(anchorPid);
+
+  const stop = async (reason) => {
+    appendGlobalActivityLog('agent', 'heartbeat.stopped', { agentId, anchorPid, reason });
+    forgetLocalAgent(agentId);
+    try {
+      const context = agentSessionFor(flags, { cwd, baseUrl: flags['base-url'] });
+      await buildAxios(context.baseUrl, context.session.token, 5000)
+        .post('/cli/agentDeregister', { agentId });
+    } catch (_) {
+      // A courtesy goodbye. The registry TTL is the mechanism; this only makes it immediate.
+    }
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', () => { stop('signal'); });
+  process.on('SIGINT', () => { stop('signal'); });
+
+  for (;;) {
+    if (!processIsAlive(anchorPid)) {
+      await stop('anchor_exited');
+      return;
+    }
+    try {
+      const context = agentSessionFor(flags, { cwd, baseUrl: flags['base-url'] });
+      const response = await buildAxios(context.baseUrl, context.session.token, 10000)
+        .post('/cli/agentHeartbeat', { agentId }).then((r) => r.data);
+      if (response && response.registered === false) {
+        // The record expired (a long sleep, a platform restart, a Redis flush). Re-register rather
+        // than heartbeating into a void — the tab is still very much alive.
+        appendGlobalActivityLog('agent', 'heartbeat.reregistering', { agentId });
+        await agentRegisterCommand(
+          { 'agent-id': agentId, 'base-url': context.baseUrl, json: 'true' },
+          { spawnHeartbeat: false }
+        ).catch((err) => {
+          appendGlobalActivityLog('agent', 'heartbeat.reregister_failed',
+            { agentId, error: describeError(err) }, 'error');
+        });
+      }
+    } catch (err) {
+      appendGlobalActivityLog('agent', 'heartbeat.failed', { agentId, error: describeError(err) }, 'error');
+    }
+    await new Promise((resolve) => setTimeout(resolve, AGENT_HEARTBEAT_INTERVAL_MS));
+  }
+}
+
+async function agentStatusCommand(flags) {
+  const agentId = resolveAgentId(flags);
+  const local = listLocalAgents().find((entry) => entry.agentId === agentId) || {};
+  const context = agentSessionFor(flags, local);
+
+  const update = { agentId };
+  const positional = flags._ && flags._.length > 2 ? flags._.slice(2).join(' ') : null;
+  const activity = flags.activity || positional;
+  if (flags.state) {
+    if (!AGENT_STATES.includes(String(flags.state))) {
+      throw new Error('--state must be one of: ' + AGENT_STATES.join(', '));
+    }
+    update.state = String(flags.state);
+  }
+  if (activity != null) update.activity = String(activity);
+  if (flags.ticket || flags['ticket-id']) update.ticketId = String(flags.ticket || flags['ticket-id']);
+  if (flags.step) update.step = String(flags.step);
+  if (flags.detail) update.detail = String(flags.detail);
+
+  // Reporting a ticket without a state is unambiguous: you are working it.
+  if (update.ticketId && !update.state) update.state = 'working';
+
+  const response = await buildAxios(context.baseUrl, context.session.token, 15000)
+    .post('/cli/agentHeartbeat', update).then((r) => r.data);
+
+  if (response && response.registered === false) {
+    console.log('This agent is no longer registered (its presence expired). Re-registering.');
+    await agentRegisterCommand({ ...flags, 'agent-id': agentId });
+    return;
+  }
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  const agent = (response && response.agent) || {};
+  // `||` binds looser than `+`, so writing this as one expression prints only the state and silently
+  // drops the ticket and activity — the two things the caller just set.
+  const parts = [agent.state || 'idle'];
+  if (agent.ticketId) parts.push('ticket ' + agent.ticketId);
+  if (agent.activity) parts.push(agent.activity);
+  console.log(parts.join('  '));
+}
+
+/**
+ * Ask for the work routed to this session.
+ *
+ * Polling, not listening: a terminal running an AI agent has no socket to push to, and the routing
+ * decision it is asking about is a durable field on the ticket rather than a message that could be
+ * missed. `--wait` turns a single question into a patient one.
+ */
+async function agentWorkCommand(flags) {
+  const agentId = resolveAgentId(flags);
+  const local = listLocalAgents().find((entry) => entry.agentId === agentId) || {};
+  const context = agentSessionFor(flags, local);
+  const api = buildAxios(context.baseUrl, context.session.token, 20000);
+  const waitSec = parsePositiveInt(flags.wait, AGENT_WORK_DEFAULT_WAIT_SEC);
+  const deadline = Date.now() + (waitSec * 1000);
+
+  for (;;) {
+    const response = await api.post('/cli/agentWork', {
+      agentId,
+      statuses: flags.statuses || 'all'
+    }).then((r) => r.data);
+
+    if (response && response.registered === false) {
+      console.log('This agent is no longer registered. Run: remits-cli agent register');
+      process.exitCode = 1;
+      return;
+    }
+
+    const tickets = (response && response.tickets) || [];
+    if (tickets.length || Date.now() >= deadline) {
+      if (flagEnabled(flags.json)) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+      }
+      if (!tickets.length) {
+        console.log('No tickets are routed to this agent.' +
+          (waitSec ? ' (waited ' + waitSec + 's)' : ''));
+        console.log('Nothing to do — the platform routes work here when an operator or a rule assigns it.');
+        return;
+      }
+      console.log(tickets.length + ' ticket(s) routed to this agent:');
+      for (const ticket of tickets) {
+        console.log('');
+        console.log('  ' + (ticket.id || ticket.ticketId) + '  [' + (ticket.priority || 'medium') + '/' +
+          (ticket.status || 'open') + '/' + (ticket.type || 'question') + ']');
+        console.log('  ' + (ticket.subject || '(no subject)'));
+        console.log('  account ' + (ticket.accountName || '?') + ' (' + (ticket.accountId || '?') + ')' +
+          (ticket.implementationAccountId
+            ? '  implementation ' + ticket.implementationAccountName + ' (' + ticket.implementationAccountId + ')'
+            : ''));
+        if (ticket.description) {
+          console.log('  ' + String(ticket.description).split('\n')[0].slice(0, 200));
+        }
+      }
+      console.log('');
+      console.log('Next: read it in full, then claim it.');
+      console.log('  remits-cli tool --name mcp_support_ticket --input \'{"action":"read","ticketId":"' +
+        (tickets[0].id || tickets[0].ticketId) + '"}\'');
+      console.log('  remits-cli agent status --state working --ticket ' + (tickets[0].id || tickets[0].ticketId) +
+        ' --activity "reproducing the issue"');
+      return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, AGENT_WORK_POLL_MS));
+  }
+}
+
+async function agentListCommand(flags) {
+  const cwd = process.cwd();
+  const context = agentSessionFor(flags, null);
+  const accountId = resolvePreferredAccountId(cwd, flags, context.session);
+  const response = await buildAxios(context.baseUrl, context.session.token, 15000)
+    .post('/cli/agents', {
+      accountId,
+      dataMode: context.dataMode,
+      all: flagEnabled(flags.all)
+    }).then((r) => r.data);
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  const agents = (response && response.agents) || [];
+  if (!agents.length) {
+    console.log('No agents are registered for account ' + accountId + ' in the ' + context.dataMode + ' lane.');
+    return;
+  }
+  console.log(agents.length + ' agent(s) available for account ' + accountId + ':');
+  for (const agent of agents) {
+    console.log('');
+    console.log('  ' + agent.agentId);
+    console.log('    ' + (agent.label || agent.userName || '(unlabelled)') + '   ' + (agent.userEmail || ''));
+    console.log('    state    ' + (agent.state || 'idle') +
+      (agent.ticketId ? '  ticket ' + agent.ticketId : '') +
+      '   last seen ' + (agent.secondsSinceSeen == null ? '?' : agent.secondsSinceSeen + 's ago'));
+    if (agent.activity) console.log('    doing    ' + agent.activity);
+    console.log('    where    ' + (agent.host || '?') + ':' + (agent.cwd || '?'));
+  }
+}
+
+async function agentReleaseCommand(flags) {
+  const agentId = resolveAgentId(flags, { optional: true });
+  if (!agentId) {
+    console.log('No local agent is registered in this session.');
+    return;
+  }
+  const local = listLocalAgents().find((entry) => entry.agentId === agentId) || {};
+  const context = agentSessionFor(flags, local);
+  await buildAxios(context.baseUrl, context.session.token, 10000)
+    .post('/cli/agentDeregister', { agentId }).then((r) => r.data).catch(() => null);
+  forgetLocalAgent(agentId);
+  console.log('Deregistered agent ' + agentId + '. This session will no longer receive tickets.');
+}
+
+async function agentCommand(flags, subcommand) {
+  switch (subcommand) {
+    case 'register': return agentRegisterCommand(flags);
+    case 'status': return agentStatusCommand(flags);
+    case 'work': return agentWorkCommand(flags);
+    case 'list': case 'ls': return agentListCommand(flags);
+    case 'release': case 'deregister': case 'stop': return agentReleaseCommand(flags);
+    case 'heartbeat-daemon': return agentHeartbeatDaemonCommand(flags);
+    default:
+      printAgentHelp();
+      return;
+  }
+}
+
+function printAgentHelp() {
+  console.log('Usage: remits-cli agent <subcommand>');
+  console.log('');
+  console.log('  register [--label NAME] [--data-mode test|prod] [--account-id ID]');
+  console.log('      Make THIS terminal session available to work support tickets. Starts a heartbeat');
+  console.log('      that ends when this session ends, so a closed tab stops receiving work on its own.');
+  console.log('');
+  console.log('  work [--wait SECONDS] [--json]');
+  console.log('      Ask for the tickets routed to this session. With --wait it keeps asking until');
+  console.log('      something arrives or the wait runs out.');
+  console.log('');
+  console.log('  status [--state idle|working|paused] [--ticket ID] [--activity "..."] [--step "..."]');
+  console.log('      Report what this session is doing, so operators can see it live.');
+  console.log('');
+  console.log('  list [--account-id ID] [--json]      Who else is available for an account.');
+  console.log('  release                              Deregister this session immediately.');
+}
+
 async function listenCommand(flags) {
   if (isListenerRunning()) {
     const state = readServiceState();
@@ -6079,43 +6102,15 @@ async function listenCommand(flags) {
     return;
   }
 
-  // Foreground mode — this is the actual long-running listener
-  // Clean slate: kill any leftover tmux session and pane state from a previous run
-  killTmuxSession();
-  paneMap = {};
-  savePaneMap();
-
+  // Foreground mode — this is the actual long-running service
   writeListenerPid();
   runtimeState.service.startedAt = new Date().toISOString();
   runtimeState.service.pid = process.pid;
   recordDiscoverySummary(discoverAccountRepos());
   const dashboardPort = Number(flags.port || flags.dashboardPort || DEFAULT_DASHBOARD_PORT);
   await startDashboardServer(dashboardPort);
-  await bestEffortRegisterCliListeners({ reason: 'listener.start' });
-  let lastListenerRegistrationAt = Date.now();
 
-  // Create the tmux session immediately so the user can attach right away
-  try {
-    const defaultDir = os.homedir();
-    execSync(
-      'tmux new-session -d -s ' + shellQuote(TMUX_SESSION_NAME) + ' -n ' + shellQuote('listener') + ' -c ' + shellQuote(defaultDir),
-      { stdio: 'ignore' }
-    );
-    configureTmuxSession();
-    appendGlobalActivityLog('tmux', 'session.created', {
-      sessionName: TMUX_SESSION_NAME,
-      accountDir: defaultDir,
-      source: 'listener.start'
-    });
-  } catch (err) {
-    console.error('[listener] Failed to create tmux session:', err.message);
-    appendGlobalActivityLog('tmux', 'session.create_failed', {
-      sessionName: TMUX_SESSION_NAME,
-      error: err.message
-    }, 'error');
-  }
-
-  // Clean up on exit — kill tmux session and clear state
+  // Clean up on exit
   let refreshInterval = null;
   const cleanup = () => {
     appendGlobalActivityLog('listener', 'cleanup', { pid: process.pid });
@@ -6136,9 +6131,6 @@ async function listenCommand(flags) {
       } catch (_) {}
       dashboardServer = null;
     }
-    killTmuxSession();
-    paneMap = {};
-    savePaneMap();
     clearListenerPid();
     clearServiceState();
     process.exit(0);
@@ -6151,7 +6143,7 @@ async function listenCommand(flags) {
   appendGlobalActivityLog('listener', 'foreground.started', {
     pid: process.pid,
     accountCount: entries.length,
-    logFile: TMUX_ACTIVITY_LOG_FILE,
+    logFile: ACTIVITY_LOG_FILE,
     dashboardUrl: runtimeState.service.dashboardUrl
   });
 
@@ -6166,8 +6158,6 @@ async function listenCommand(flags) {
     }
     maintenanceInFlight = true;
     try {
-      ensureTmuxSessionHealthy(os.homedir());
-
       const currentEntries = listenerSessionEntriesFromStore(readAllSessions());
       const currentSignature = listenerSessionSignature(currentEntries);
       if (currentSignature !== activeSessionSignature) {
@@ -6180,11 +6170,6 @@ async function listenCommand(flags) {
         activeSessionSignature = currentSignature;
       }
 
-      if (Date.now() - lastListenerRegistrationAt >= LISTENER_REGISTRATION_INTERVAL_MS) {
-        await bestEffortRegisterCliListeners({ reason: 'listener.heartbeat' });
-        lastListenerRegistrationAt = Date.now();
-      }
-
       await runManagedWebsocketWatchdog();
       updateRuntimeServiceState();
     } catch (err) {
@@ -6218,17 +6203,6 @@ async function listenStopCommand() {
     appendGlobalActivityLog('listener', 'stop.no_process');
   }
 
-  // Kill the tmux session and clear pane tracking
-  if (tmuxSessionExists()) {
-    killTmuxSession();
-    console.log('Killed tmux session:', TMUX_SESSION_NAME);
-  }
-  if (fs.existsSync(DISPATCH_STATE_FILE)) {
-    atomicWriteFile(DISPATCH_STATE_FILE, '{}');
-    appendGlobalActivityLog('tmux', 'dispatch_state.cleared', {
-      file: DISPATCH_STATE_FILE
-    });
-  }
   clearServiceState();
 }
 
@@ -6571,6 +6545,14 @@ async function main() {
   const wantsHelp = args.help === true || subcommand === 'help' || subcommand === '--help' || args._.includes('--help');
   const wantsJson = flagEnabled(args.json);
 
+  // The heartbeat sidecar runs for the whole life of a terminal session. It must not auto-update
+  // (re-exec'ing it would drop the anchor it is watching) and it has no use for repo discovery or the
+  // background service, so it short-circuits everything below.
+  if (command === 'agent' && subcommand === 'heartbeat-daemon') {
+    await agentHeartbeatDaemonCommand(args);
+    return;
+  }
+
   if (shouldAutoUpdate(command, args)) {
     const requireSuccessfulAutoUpdate = command === 'start';
     if (autoUpdateIfNeeded(originalArgv, { requireSuccess: requireSuccessfulAutoUpdate })) return;
@@ -6578,13 +6560,9 @@ async function main() {
 
   // Best-effort: update account-repo index whenever running from inside a remits repo
   try { updateAccountRepoIndex(process.cwd()); } catch (_) { /* not in account repo */ }
-  if (!wantsJson) {
-    try { await bestEffortRegisterCliListeners({ cwd: process.cwd(), reason: 'command' }); } catch (_) { /* best-effort */ }
-  }
-
   // Auto-start the background service if not already running.
   // Skip for lifecycle subcommands and help.
-  const isLifecycleCmd = command === 'listen' || command === 'start' || command === 'stop' || command === 'status' || command === 'whoami';
+  const isLifecycleCmd = command === 'listen' || command === 'start' || command === 'stop' || command === 'status' || command === 'whoami' || command === 'agent';
   const isHelpCmd = !command || command === 'help' || command === '--help' || wantsHelp;
   if (!wantsJson && !isHelpCmd && !isLifecycleCmd && !isListenerRunning()) {
     try {
@@ -6611,7 +6589,12 @@ async function main() {
     console.log('  remits-cli auth [--base-url URL] [--account-id ID] [--port 8765] [--data-mode test|prod]');
     console.log('  remits-cli sessions [list|remove] [--account-id ID] [--base-url URL] [--data-mode test|prod]');
     console.log('  remits-cli config [set] [--agent claude|codex|gemini]');
-    console.log('  remits-cli start [--foreground true] [--port 8787]');
+    console.log('  remits-cli agent register [--label NAME] [--data-mode test|prod]   # make THIS terminal available for tickets');
+    console.log('  remits-cli agent work [--wait SECONDS] [--json]                     # ask for tickets routed to this session');
+    console.log('  remits-cli agent status [--state idle|working|paused] [--ticket ID] [--activity "..."]');
+    console.log('  remits-cli agent list [--account-id ID]                             # who else is available');
+    console.log('  remits-cli agent release                                            # stop receiving tickets now');
+    console.log('  remits-cli start [--foreground true] [--port 8787]                  # human dashboard in the browser');
     console.log('  remits-cli stop');
     console.log('  remits-cli status [--base-url URL] [--account-id ID] [--data-mode test|prod] [--json]');
     console.log('  remits-cli whoami [--base-url URL] [--account-id ID] [--data-mode test|prod] [--json]');
@@ -6760,6 +6743,15 @@ async function main() {
     return;
   }
 
+  if (command === 'agent') {
+    if (wantsHelp) {
+      printAgentHelp();
+      process.exit(0);
+    }
+    await agentCommand(args, subcommand);
+    return;
+  }
+
   if (command === 'install') {
     await installSkillsCommand(args);
     return;
@@ -6789,6 +6781,9 @@ async function main() {
 }
 
 main().catch((err) => {
+  if (process.env.REMITS_CLI_DEBUG_STACK === '1' && err && err.stack) {
+    console.error(err.stack);
+  }
   console.error('remits-cli error:', describeError(err) + sandboxNetworkHint(err));
   process.exit(1);
 });