@remits/remits-cli 0.1.110 → 0.1.113

package/index.js

@@ -320,6 +320,7 @@ function resolveSessionIdentity(cwd, flags = {}) {
 
   const dataMode = requestedDataMode || resolveDataMode(flags, session);
   const branchName = flags.branch || flags.branchName || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const user = session && session.user ? session.user : {};
   const repoName = accountNameFromAccountInfo(accountInfo);
   const localAccountInfoAccountId = accountInfo ? Number(accountIdFromAccountInfo(accountInfo)) : null;
@@ -336,6 +337,8 @@ function resolveSessionIdentity(cwd, flags = {}) {
     userId: user.id || session?.userId || null,
     userName: user.name || user.username || user.email || null,
     branchName,
+    workspace,
+    workspaceSource: workspaceSource(cwd, flags),
     dataMode,
     // `test run` resolves its lane from the FLAG ONLY (testRunCommand), never the stored session, so that
     // an account whose session is parked on prod cannot have a test run silently follow it. Report both
@@ -358,6 +361,7 @@ function printSessionIdentity(identity, options = {}) {
     console.log('Account ID:', identity.accountId || 'unresolved');
     console.log('User ID:', 'unresolved');
     console.log('Branch:', identity.branchName || 'unresolved');
+    console.log('Workspace:', identity.workspace || 'none (shared default lane)');
     console.log('Data mode:', (identity.dataMode || DEFAULT_DATA_MODE) + ' (applies to tool/tools/token)');
     console.log('Data mode (test run):', identity.testRunDataMode || DEFAULT_DATA_MODE);
     console.log('Base URL:', identity.baseUrl);
@@ -382,6 +386,8 @@ function printSessionIdentity(identity, options = {}) {
     console.log('  User:', identity.userName);
   }
   console.log('  Branch:', identity.branchName);
+  console.log('  Workspace:', (identity.workspace || 'none (shared default lane)') +
+    (identity.workspaceSource ? '   [' + identity.workspaceSource + ']' : ''));
   console.log('  Data mode:', identity.dataMode, '(applies to tool/tools/token)');
   // `test run` deliberately ignores the stored session lane and defaults to test, so a session sitting on
   // prod would otherwise read as "prod" here while the next test run went to the test lane. Say so rather
@@ -528,10 +534,105 @@ function localStatePaths(cwd) {
     toolsDir: path.join(base, 'tools'),
     sessionsDir: path.join(base, 'sessions'),
     toolResponsesDir: path.join(base, 'tool-responses'),
-    currentSessionFile: path.join(base, 'current-session.txt')
+    currentSessionFile: path.join(base, 'current-session.txt'),
+    workspaceFile: path.join(base, 'workspace')
   };
 }
 
+// ---------------------------------------------------------------------------------------------------
+// Staging workspace
+// ---------------------------------------------------------------------------------------------------
+//
+// A workspace is an OPTIONAL second isolation axis for staging, alongside the git branch. It exists so
+// several coding agents can iterate on the SAME branch at once without overwriting each other: staging is
+// keyed by (account, cliUser, branch, workspace), and account and user are fixed for a given repo.
+//
+// It is stored in `.remits-cli/workspace`, which is PER-DIRECTORY and gitignored — so `git worktree add`
+// gives each agent its own file, and `remits-cli workspace use --auto` names the lane after the worktree
+// directory. That makes the ergonomic path a one-time setup per worktree rather than a flag on every
+// command, which is what an agent will actually get right.
+//
+// Precedence: explicit --workspace > REMITS_WORKSPACE env > .remits-cli/workspace > none (shared lane).
+
+const WORKSPACE_MAX_LENGTH = 48;
+
+// MUST match CliComponentStaging.normalizeWorkspace on the server. Normalizing here too means the name an
+// agent sees in its own output is the lane the server actually used, rather than a raw string the server
+// silently rewrote.
+function normalizeWorkspace(value) {
+  if (value === undefined || value === null) return null;
+  const trimmed = String(value).trim();
+  if (!trimmed) return null;
+  let normalized = trimmed
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[-.]+/, '')
+    .replace(/[-.]+$/, '');
+  if (normalized.length > WORKSPACE_MAX_LENGTH) {
+    normalized = normalized.slice(0, WORKSPACE_MAX_LENGTH).replace(/[-.]+$/, '');
+  }
+  return normalized || null;
+}
+
+function readWorkspaceFile(cwd) {
+  try {
+    const file = localStatePaths(cwd).workspaceFile;
+    if (!fs.existsSync(file)) return null;
+    return normalizeWorkspace(fs.readFileSync(file, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function writeWorkspaceFile(cwd, workspace) {
+  const paths = ensureLocalState(cwd);
+  if (!workspace) {
+    try { if (fs.existsSync(paths.workspaceFile)) fs.unlinkSync(paths.workspaceFile); } catch (_) { /* best-effort */ }
+    return null;
+  }
+  atomicWriteFile(paths.workspaceFile, workspace + '\n');
+  return workspace;
+}
+
+// `--no-workspace` explicitly opts back into the shared default lane even when a workspace file exists,
+// so a command can be run against the lane a teammate (or an older session) staged into without deleting
+// local state.
+function resolveWorkspace(cwd, flags = {}) {
+  if (flagEnabled(flags['no-workspace']) || flagEnabled(flags.noWorkspace)) {
+    return null;
+  }
+  const explicit = flags.workspace || flags.ws;
+  if (explicit !== undefined && explicit !== null && explicit !== true) {
+    return normalizeWorkspace(explicit);
+  }
+  return normalizeWorkspace(process.env.REMITS_WORKSPACE) || readWorkspaceFile(cwd);
+}
+
+// Where the resolved workspace came from. Printed alongside it so an agent never has to guess whether the
+// lane it is on was chosen deliberately or inherited from a file it forgot about.
+function workspaceSource(cwd, flags = {}) {
+  if (flagEnabled(flags['no-workspace']) || flagEnabled(flags.noWorkspace)) return 'explicit --no-workspace';
+  const explicit = flags.workspace || flags.ws;
+  if (explicit !== undefined && explicit !== null && explicit !== true) return '--workspace';
+  if (normalizeWorkspace(process.env.REMITS_WORKSPACE)) return 'REMITS_WORKSPACE';
+  if (readWorkspaceFile(cwd)) return '.remits-cli/workspace';
+  return 'none (shared default lane)';
+}
+
+// One line, printed by every command that stages, runs, or mints a token. The whole point of the feature
+// is that several lanes can exist at once; a command that did not say which one it used would trade one
+// kind of confusion for another.
+function printStagingLane(branchName, workspace, source) {
+  if (workspace) {
+    console.log('Staging lane:', branchName + '  [workspace: ' + workspace + ']' +
+      (source ? '   (from ' + source + ')' : ''));
+  } else {
+    console.log('Staging lane:', branchName + '  [shared default lane]' +
+      (source ? '   (' + source + ')' : ''));
+  }
+}
+
 function ensureLocalState(cwd) {
   const paths = localStatePaths(cwd);
   ensureDir(paths.base);
@@ -1147,13 +1248,45 @@ function countAccountRepos(index) {
   return listAccountRepoEntries(index).length;
 }
 
+/**
+ * Fold discovered checkouts into the index, one entry per account.
+ *
+ * <p><b>Two checkouts can claim one account, and the naive merge picked a silent winner.</b> The index is
+ * keyed by accountId, so a plain last-write-wins loop resolved a fork, a worktree or a dated backup copy
+ * by scan order — which is alphabetical, which is meaningless. Measured on this machine: account 33 had
+ * both `remits-invoice-automation` and `remits-invoice-automation copy-EOD-09302025`, and the index held
+ * the dated copy. Four open tickets would have been worked in a month-old snapshot.</p>
+ *
+ * <p>So: a real checkout always beats a non-checkout (an unpacked export cannot win merely by sorting
+ * later); an explicit `cwd` entry — the operator standing in the directory — always beats a scan; and
+ * when two genuine checkouts remain, the incumbent is KEPT and the loser is recorded in `ambiguousWith`
+ * rather than discarded. Ambiguity a person can see is recoverable; a silent winner is not.</p>
+ */
 function mergeAccountRepoEntries(entries, options = {}) {
   const nextIndex = options.existingIndex ? { ...options.existingIndex } : {};
+  const rank = (entry) => (isAccountCheckout(entry.directory) ? 2 : 0) + (entry.source === 'cwd' ? 1 : 0);
+
   for (const entry of entries) {
     if (!entry || !entry.accountId || !entry.directory) {
       continue;
     }
-    nextIndex[String(entry.accountId)] = entry;
+    const key = String(entry.accountId);
+    const current = nextIndex[key];
+    if (!current || !current.directory || current.directory === entry.directory) {
+      nextIndex[key] = { ...entry, ambiguousWith: (current && current.ambiguousWith) || [] };
+      continue;
+    }
+
+    const winner = rank(entry) > rank(current) ? entry : current;
+    const loser = winner === entry ? current : entry;
+    const seen = new Set([...((current.ambiguousWith) || []), ...((entry.ambiguousWith) || [])]);
+    // Only a genuine rival is worth reporting. A non-checkout losing to a checkout is the system
+    // working, not a decision the operator needs to review.
+    if (isAccountCheckout(loser.directory) && isAccountCheckout(winner.directory)) {
+      seen.add(loser.directory);
+    }
+    seen.delete(winner.directory);
+    nextIndex[key] = { ...winner, ambiguousWith: [...seen] };
   }
   writeAccountRepoIndex(nextIndex);
   return nextIndex;
@@ -1615,6 +1748,25 @@ function parsePositiveInt(value, fallback) {
   return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
 }
 
+/**
+ * How long to give a full stage, from how much it is actually uploading.
+ *
+ * A fixed 60s was fine for a small repo and wrong for a real one: the request completes server-side and
+ * the client abandons it, which is indistinguishable at the terminal from a stage that never landed.
+ * Roughly 60s of headroom per megabyte on top of a 60s floor, capped so a pathological payload cannot
+ * hang a session forever. `--stage-timeout-ms` overrides it.
+ */
+function stageTimeoutMs(components, flags = {}) {
+  const override = parsePositiveInt(flags['stage-timeout-ms'] || flags.stageTimeoutMs, 0);
+  if (override) return override;
+  let bytes = 0;
+  for (const component of components || []) {
+    try { bytes += Buffer.byteLength(JSON.stringify(component)); } catch (_) { /* unmeasurable is fine */ }
+  }
+  const megabytes = bytes / (1024 * 1024);
+  return Math.min(600000, Math.max(60000, Math.round(60000 + (megabytes * 60000))));
+}
+
 function buildAxios(baseUrl, token, timeoutMs = 60000) {
   const headers = token ? { Authorization: 'Bearer ' + token } : {};
   return axios.create({ baseURL: baseUrl, timeout: parsePositiveInt(timeoutMs, 60000), headers });
@@ -2059,24 +2211,54 @@ async function pushComponentsCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const dataMode = resolveDataMode(flags, session);
   const requestedMode = String(flags.mode || 'stage').toLowerCase();
   const mode = requestedMode === 'push' ? 'stage' : requestedMode;
-  const components = collectComponents(cwd);
   const changedFromWorkingTree = changedComponentsFromWorkingTree(cwd);
 
+  // --changed-only stages just the components this working tree edited, instead of re-uploading all of
+  // them. Two reasons it matters here: it is what makes an iteration loop cheap on a large repo, and it
+  // deliberately does NOT send `replace`, so the server's reconcile pass cannot delete the entries for
+  // components this partial stage did not mention.
+  const changedOnly = flagEnabled(flags['changed-only']) || flagEnabled(flags.changedOnly);
+  let components = collectComponents(cwd);
+  if (changedOnly) {
+    if (changedFromWorkingTree === null) {
+      throw new Error('--changed-only needs a git working tree to establish the changed set, and this directory is not one.');
+    }
+    const wanted = new Set(changedFromWorkingTree.map((entry) =>
+      entry.type + ':' + (entry.id ? 'id:' + entry.id : 'name:' + String(entry.name || '').toLowerCase())));
+    components = components.filter((component) => wanted.has(
+      component.type + ':' + (component.id ? 'id:' + component.id : 'name:' + String(component.name || '').toLowerCase())));
+    if (!components.length) {
+      console.log('--changed-only: this working tree has no uncommitted component edits; nothing to stage.');
+      printStagingLane(branchName, workspace, workspaceSource(cwd, flags));
+      return { success: true, mode, updated: 0, unchanged: 0, skipped: [], changedOnly: true };
+    }
+  }
+
   if (requestedMode === 'push') {
     console.log('Warning: `components push` is deprecated and currently behaves the same as `components stage`.');
   }
 
-  const api = buildAxios(baseUrl, session.token);
+  // A full stage uploads the WHOLE repo, and a large one is megabytes: Merchant Statements is 9.6 MB
+  // across 106 components. Against a remote platform that routinely runs past 60s — and the failure was
+  // the worst possible shape, because the server had already stored everything: the CLI reported
+  // "timeout ... ECONNABORTED" over a stage that had SUCCEEDED, so the caller would either re-upload it
+  // or, worse, conclude staging was broken and go on reading trunk. Scaled by payload size, floored at
+  // the old default, and overridable.
+  const api = buildAxios(baseUrl, session.token, stageTimeoutMs(components, flags));
   const response = await loggedPost(api, cwd, '/cli/components', {
     token: session.token,
     accountId,
     branchName,
+    workspace,
     dataMode,
     mode,
-    replace: true,
+    // A partial (--changed-only) stage must not trigger the server's reconcile pass: reconcile deletes
+    // every staged entry absent from the manifest, which for a partial manifest is nearly all of them.
+    replace: !changedOnly,
     components
   }).then((r) => r.data);
   response.changedFromWorkingTree = changedFromWorkingTree || [];
@@ -2089,8 +2271,9 @@ async function pushComponentsCommand(flags) {
 
   printSessionResolutionWarning(sessionContext);
   printResolvedBaseUrl(baseUrl);
+  printStagingLane(response.branchName || branchName, response.workspace || workspace, workspaceSource(cwd, flags));
   console.log('Data mode:', response.dataMode || dataMode);
-  console.log('Mode:', response.mode || mode);
+  console.log('Mode:', response.mode || mode + (changedOnly ? ' (--changed-only)' : ''));
   printStageSummary(response, flags);
 }
 
@@ -2166,8 +2349,26 @@ function printStageSummary(response, flags) {
 
 function printStatusSummary(response, flags) {
   printBranchContext(response);
+  printStagingLane(response.branchName, response.workspace, null);
   console.log('Staged count:', response.stagedCount || 0);
   printComponentTypeCounts(response.entries || []);
+
+  // Every lane staged on this branch, not just this one. An agent that believes it is working alone can
+  // see here that it is not — which was impossible before workspaces existed, and is a large part of why
+  // concurrent agents overwrote each other without anyone being able to observe it.
+  const lanes = Array.isArray(response.workspaces) ? response.workspaces : [];
+  if (lanes.length > 1 || (lanes.length === 1 && lanes[0].workspace !== (response.workspace || null))) {
+    console.log('');
+    console.log('Other staging lanes on branch "' + response.branchName + '" for this account/user:');
+    lanes.forEach((lane) => {
+      const isCurrent = (lane.workspace || null) === (response.workspace || null);
+      const label = lane.workspace ? 'workspace ' + lane.workspace : 'shared default lane';
+      const ttl = lane.ttlSeconds != null ? '  expires in ~' + Math.round(lane.ttlSeconds / 60) + 'm' : '';
+      console.log('  ' + (isCurrent ? '* ' : '  ') + label + ' — ' + (lane.keyCount || 0) + ' staged key(s)' + ttl);
+    });
+    console.log('  (* = this command\'s lane)');
+  }
+
   printComponentCommandResponse('Components staging', response, flags);
 }
 
@@ -2210,6 +2411,64 @@ function printClearSummary(response, flags) {
   printComponentCommandResponse('Components clear', response, flags);
 }
 
+/**
+ * `remits-cli workspace [show|use <name>|clear]`
+ *
+ * The ergonomic entry point for the staging workspace lane. `use --auto` names the lane after the
+ * checkout directory, which is what makes `git worktree add ../ms-agent-a` + one command enough to give
+ * an agent its own isolated staging lane on the SAME branch.
+ */
+async function workspaceCommand(flags) {
+  const cwd = process.cwd();
+  ensureLocalState(cwd);
+  const sub = String((flags._ && flags._[1]) || 'show').toLowerCase();
+
+  if (sub === 'clear' || sub === 'unset' || sub === 'none') {
+    writeWorkspaceFile(cwd, null);
+    console.log('Workspace cleared. This checkout now stages into the shared default lane for its branch.');
+    return;
+  }
+
+  if (sub === 'use' || sub === 'set') {
+    const auto = flagEnabled(flags.auto);
+    const requested = auto ? path.basename(cwd) : (flags._ && flags._[2]) || flags.name || flags.workspace;
+    if (!requested) {
+      throw new Error('Usage: remits-cli workspace use <name>   (or --auto to name it after this directory)');
+    }
+    const normalized = normalizeWorkspace(requested);
+    if (!normalized) {
+      throw new Error('Workspace name "' + requested + '" normalizes to nothing. Use letters, digits, dot, dash or underscore.');
+    }
+    writeWorkspaceFile(cwd, normalized);
+    console.log('Workspace set to:', normalized);
+    if (normalized !== String(requested).trim()) {
+      // Say so rather than silently accepting a name that is not the lane. An agent that thinks it is on
+      // "Agent A" and is actually on "agent-a" cannot reconcile its own output with a status listing.
+      console.log('  (normalized from "' + String(requested).trim() + '")');
+    }
+    console.log('Stored in:', localStatePaths(cwd).workspaceFile, '(gitignored, per-checkout)');
+    console.log('');
+    console.log('Every stage / test run / token from this directory now uses this lane.');
+    console.log('It does NOT change which branch a commit targets, or which committed variants run.');
+    return;
+  }
+
+  if (sub !== 'show' && sub !== 'status') {
+    throw new Error('Unknown workspace subcommand "' + sub + '". Expected show, use, or clear.');
+  }
+
+  const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
+  printStagingLane(branchName, workspace, workspaceSource(cwd, flags));
+  console.log('');
+  console.log('Precedence: --workspace  >  REMITS_WORKSPACE  >  .remits-cli/workspace  >  shared default lane');
+  console.log('');
+  console.log('  remits-cli workspace use <name>     set this checkout\'s lane');
+  console.log('  remits-cli workspace use --auto     name it after this directory (' + normalizeWorkspace(path.basename(cwd)) + ')');
+  console.log('  remits-cli workspace clear          go back to the shared default lane');
+  console.log('  remits-cli components status        see every lane staged on this branch');
+}
+
 async function statusComponentsCommand(flags) {
   const cwd = process.cwd();
   ensureLocalState(cwd);
@@ -2217,6 +2476,7 @@ async function statusComponentsCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const dataMode = resolveDataMode(flags, session);
   const api = buildAxios(baseUrl, session.token);
 
@@ -2224,6 +2484,7 @@ async function statusComponentsCommand(flags) {
     token: session.token,
     accountId,
     branchName,
+    workspace,
     dataMode,
     mode: 'status',
     componentType: flags['component-type'] || flags.type,
@@ -2272,6 +2533,9 @@ async function clearComponentsCommand(flags) {
   const response = await loggedPost(api, cwd, '/cli/components', {
     token: session.token,
     accountId,
+    // A clear NEVER reaches beyond this lane, so `--all` means "all of MY staged entries", not
+    // "everything staged on this branch by anyone".
+    workspace: resolveWorkspace(cwd, flags),
     branchName,
     dataMode,
     mode: 'clear',
@@ -2291,6 +2555,7 @@ async function clearComponentsCommand(flags) {
 
   printSessionResolutionWarning(sessionContext);
   printResolvedBaseUrl(baseUrl);
+  printStagingLane(response.branchName || branchName, response.workspace, workspaceSource(cwd, flags));
   console.log('Data mode:', response.dataMode || dataMode);
   console.log('Mode:', response.mode || 'clear');
   printClearSummary(response, flags);
@@ -2304,6 +2569,7 @@ async function syncComponentsCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const dataMode = resolveDataMode(flags, session);
   const forceTombstones = flagEnabled(flags['force-tombstones']) || flagEnabled(flags.forceTombstones);
   const dryRun = flagEnabled(flags['dry-run']) || flagEnabled(flags.dryRun);
@@ -2325,6 +2591,11 @@ async function syncComponentsCommand(flags) {
     token: session.token,
     accountId,
     branchName,
+    // A successful sync clears the staging scope so stale staged aliases cannot shadow the freshly synced
+    // DB rows. Sending the workspace keeps that clear scoped to THIS lane: without it, one agent's sync
+    // would wipe every sibling agent's staged work on the same branch, which is the exact failure the
+    // workspace lane exists to remove.
+    workspace,
     dataMode,
     forceTombstones,
     dryRun,
@@ -2338,6 +2609,7 @@ async function syncComponentsCommand(flags) {
       token: session.token,
       accountId,
       branchName,
+      workspace,
       dataMode,
       mode: 'status'
     }).then((r) => r.data);
@@ -3230,6 +3502,7 @@ async function testCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   // Test runs must default to test dataMode even when the most-recent authenticated
   // session for the account is prod. Production test runs therefore require an explicit
   // --data-mode prod on the command line.
@@ -3285,6 +3558,7 @@ async function testCommand(flags) {
     asAccountId,
     variantBranch,
     branchName,
+    workspace,
     dataMode,
     testId: /^\d+$/.test(String(testRef)) ? Number(testRef) : undefined,
     testName: /^\d+$/.test(String(testRef)) ? undefined : String(testRef),
@@ -3297,6 +3571,7 @@ async function testCommand(flags) {
 
   printSessionResolutionWarning(sessionContext);
   printResolvedBaseUrl(baseUrl);
+  printStagingLane(branchName, workspace, workspaceSource(cwd, flags));
   console.log('Test run started:', start.taskId);
   runtimeState.currentTestTaskId = start.taskId;
 
@@ -3354,6 +3629,7 @@ async function tokenCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const dataMode = resolveDataMode(flags, session);
 
   const api = buildAxios(baseUrl, session.token);
@@ -3371,6 +3647,7 @@ async function tokenCommand(flags) {
     asAccountId: flags['as-account'] || flags['as-account-id'],
     variantBranch,
     branchName,
+    workspace,
     dataMode,
     path: requestedPath
   }).then((r) => r.data);
@@ -3396,6 +3673,8 @@ async function tokenCommand(flags) {
     accountId: data.accountId,
     branchName: data.branchName,
     variantBranch: data.variantBranch,
+    workspace: data.workspace !== undefined ? data.workspace : workspace,
+    stagingLane: data.stagingLane,
     dataMode: data.dataMode || dataMode,
     shortBasePath: data.shortBasePath,
     embeddableUrl
@@ -3461,6 +3740,7 @@ async function toolsCommand(flags) {
   const { session, accountId } = sessionContext;
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
+  const workspace = resolveWorkspace(cwd, flags);
   const dataMode = resolveDataMode(flags, session);
   const variantBranch = flags['variant-branch'];
   const api = buildAxios(baseUrl, session.token);
@@ -3470,6 +3750,7 @@ async function toolsCommand(flags) {
     accountId,
     variantBranch,
     branchName,
+    workspace,
     dataMode
   }).then((r) => r.data);
 
@@ -3507,6 +3788,51 @@ function parseToolInput(flags) {
   return {};
 }
 
+const TOOL_SCOPES = ['self', 'children', 'hierarchy', 'parents'];
+
+// Hierarchy-scoped discovery flags, folded into the tool's own input.
+//
+// They are CONVENIENCE only: every one of them can be written inside --input, and a value already there
+// wins, because the explicit JSON is what the caller typed for this specific tool. The flags exist so the
+// overwhelmingly common shape — "search my repo account's children for this id" — does not require
+// hand-writing JSON.
+function applyScopeFlags(input, flags) {
+  const merged = input && typeof input === 'object' ? input : {};
+
+  const scope = flags && (flags.scope || flags['tool-scope']);
+  if (scope && merged.scope === undefined) {
+    const normalized = String(scope).trim().toLowerCase();
+    if (!TOOL_SCOPES.includes(normalized)) {
+      throw new Error('Invalid --scope "' + scope + '". Valid values: ' + TOOL_SCOPES.join(', '));
+    }
+    merged.scope = normalized;
+  }
+
+  const targetAccountId = flags && (flags['target-account-id'] || flags.targetAccountId);
+  if (targetAccountId && merged.targetAccountId === undefined) {
+    merged.targetAccountId = String(targetAccountId).trim();
+  }
+
+  const anchorAccountId = flags && (flags['anchor-account-id'] || flags.anchorAccountId);
+  if (anchorAccountId && merged.anchorAccountId === undefined) {
+    merged.anchorAccountId = String(anchorAccountId).trim();
+  }
+
+  const accountIds = flags && (flags['account-ids'] || flags.accountIds);
+  if (accountIds && merged.accountIds === undefined) {
+    const parsed = String(accountIds)
+      .split(',')
+      .map((part) => Number(String(part).trim()))
+      .filter((value) => Number.isFinite(value) && value > 0);
+    if (!parsed.length) {
+      throw new Error('--account-ids expects a comma-separated list of numeric account ids');
+    }
+    merged.accountIds = parsed;
+  }
+
+  return merged;
+}
+
 async function toolCommand(flags) {
   const cwd = process.cwd();
   ensureLocalState(cwd);
@@ -3525,7 +3851,7 @@ async function toolCommand(flags) {
   const explicitFlagAccountId = Number(flags && flags['account-id']);
   const accountIdExplicit = Number.isFinite(explicitFlagAccountId) && explicitFlagAccountId > 0;
 
-  const input = parseToolInput(flags);
+  const input = applyScopeFlags(parseToolInput(flags), flags);
   const baseUrl = flags['base-url'] || session.baseUrl || DEFAULT_BASE_URL;
   const branchName = flags.branch || currentBranch(cwd);
   const dataMode = resolveDataMode(flags, session);
@@ -3591,7 +3917,12 @@ async function toolCommand(flags) {
     token: session.token,
     accountId,
     accountIdExplicit,
+    // The repo/session account, sent as a FIRST-CLASS value rather than left to be inferred from
+    // `accountId`: a read tool may reinterpret its own `input.accountId`, and the scope root — what bounds
+    // what the call may discover — has to survive that. The server validates it; it is never authorization.
+    scopeRootAccountId: accountId,
     branchName,
+    workspace: resolveWorkspace(cwd, flags),
     dataMode,
     variantBranch,
     name: String(toolName),
@@ -4415,6 +4746,7 @@ function exportIssueBundle(snapshot) {
     agents: {
       localCount: snapshot.agents && snapshot.agents.local ? snapshot.agents.local.length : 0,
       registeredCount: snapshot.agents && snapshot.agents.registered ? snapshot.agents.registered.length : 0,
+      workerCount: snapshot.agents && snapshot.agents.workers ? snapshot.agents.workers.length : 0,
       errors: (snapshot.agents && snapshot.agents.errors) || []
     },
     repos: (snapshot.repos || []).map((repo) => ({
@@ -4528,6 +4860,31 @@ function buildRepoSnapshot(entry) {
   };
 }
 
+/**
+ * The first argument that was actually SUPPLIED, empty string included.
+ *
+ * `a || b` cannot express this: an empty string is a real value on any field that can be cleared, and it
+ * is falsy, so `||` silently turns "clear this" into "say nothing about this".
+ */
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null) return value;
+  }
+  return undefined;
+}
+
+/**
+ * A planning flag's value, where a valueless flag means CLEAR.
+ *
+ * `parseArgs` reports both `--planned-in` and `--planned-in ""` as `true`, because an empty next argument
+ * is indistinguishable from an absent one. A planning slot is a field an org must be able to blank, so the
+ * valueless form is given that meaning rather than being sent to the server as the literal string "true".
+ */
+function planningFlagValue(value) {
+  if (value === undefined || value === null) return undefined;
+  return value === true ? '' : value;
+}
+
 function compactSupportTicketRow(row) {
   if (!row || typeof row !== 'object') {
     return null;
@@ -4545,9 +4902,18 @@ function compactSupportTicketRow(row) {
     routedAgentId: row.routedAgentId || null,
     routedAgentLabel: row.routedAgentLabel || null,
     routedAt: row.routedAt || null,
+    claimedAgentId: row.claimedAgentId || null,
+    awaitingResponseSince: row.awaitingResponseSince || null,
+    awaitingResponseQuestion: row.awaitingResponseQuestion || null,
     implementationAccountId: row.implementationAccountId || null,
     implementationAccountName: row.implementationAccountName || null,
     affectedComponent: row.affectedComponent || null,
+    workstream: row.workstream || null,
+    plannedIn: row.plannedIn || null,
+    boardStage: row.boardStage || null,
+    rank: row.rank === undefined ? null : row.rank,
+    size: row.size || null,
+    blockedBy: row.blockedBy || null,
     updatedAt: row.updatedAt || row.updated || row.lastActivityAt || null,
     activityAt: row.activityAt || row.lastActivityAt || null,
     activityLabel: row.activityLabel || null
@@ -4565,8 +4931,13 @@ function compactSupportTicketRow(row) {
 async function fetchSupportTicketQueueForSession(session) {
   const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
   const api = buildAxios(baseUrl, session.token, 15000);
+  // The lane is PINNED, not left to the server's default. Without it the queue this row claims to
+  // describe is whichever lane the platform happened to choose, so a row labelled with a session's
+  // lane could be showing the other one.
+  const dataMode = normalizeDataMode(session.dataMode || 'prod');
   const result = await api.post('/cli/tickets', {
     accountId: Number(session.accountId),
+    dataMode,
     includeChildren: true,
     sortBy: 'triage',
     limit: Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100)
@@ -4580,7 +4951,8 @@ async function fetchSupportTicketQueueForSession(session) {
     baseUrl,
     accountId: Number(session.accountId),
     userId: session.user && session.user.id ? session.user.id : null,
-    dataMode: (result && result.dataMode) || session.dataMode || 'prod',
+    dataMode: (result && result.dataMode) || dataMode,
+    compartment: baseUrl + ' · ' + ((result && result.dataMode) || dataMode) + ' lane',
     totalCount: (result && result.totalCount) || tickets.length,
     count: (result && result.count) || tickets.length,
     counts: (result && result.counts) || {},
@@ -4604,27 +4976,46 @@ async function fetchSupportTicketQueueForSession(session) {
  * 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 }) {
+/**
+ * Route a ticket from the dashboard, on the platform and lane that ticket actually lives on.
+ *
+ * <p>Selecting the session by {@code accountId} alone — and falling back to any authenticated session
+ * at all — was a cross-platform write triggered from a button. Account 1 exists on production and on
+ * a localhost instance both, so routing a localhost test fixture could reach production, or the
+ * reverse. The ticket carries the compartment it came from; that is what decides where the write goes,
+ * and if no session matches it we refuse rather than write somewhere plausible.</p>
+ */
+async function routeTicketFromDashboard({ ticketId, accountId, agentId, baseUrl, dataMode }) {
   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);
+  const wantedBase = baseUrl ? normalizeBaseUrl(baseUrl) : null;
+  const wantedMode = dataMode ? normalizeDataMode(dataMode) : null;
+  const candidates = listSessionsFromStore(readAllSessions()).filter((entry) => {
+    if (!entry || !entry.token) return false;
+    if (wantedBase && normalizeBaseUrl(entry.baseUrl || DEFAULT_BASE_URL) !== wantedBase) return false;
+    if (wantedMode && normalizeDataMode(entry.dataMode || 'prod') !== wantedMode) return false;
+    return true;
+  });
+  const session = candidates.find((entry) => Number(entry.accountId) === numericAccountId) || candidates[0];
   if (!session) {
-    throw new Error('No authenticated session is available. Run: remits-cli auth');
+    throw new Error('No authenticated session for ' + (wantedBase || 'that platform') +
+      (wantedMode ? ' in the ' + wantedMode + ' lane' : '') + '. Run: remits-cli auth --base-url ' +
+      (wantedBase || DEFAULT_BASE_URL));
   }
-  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
-  const result = await buildAxios(baseUrl, session.token, 15000)
+  const targetBaseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const result = await buildAxios(targetBaseUrl, session.token, 15000)
     .post('/cli/ticketRoute', {
       ticketId: String(ticketId),
       accountId: numericAccountId,
       agentId: agentId || null,
-      dataMode: session.dataMode
+      dataMode: wantedMode || session.dataMode
     }).then((r) => r.data);
   appendGlobalActivityLog('ticket', 'routed', {
-    ticketId, accountId: numericAccountId, agentId: agentId || null, success: result && result.success
+    ticketId, accountId: numericAccountId, agentId: agentId || null,
+    baseUrl: targetBaseUrl, dataMode: wantedMode || session.dataMode,
+    success: result && result.success
   });
   if (result && result.success === false) {
     throw new Error(result.message || 'Routing was refused.');
@@ -4657,7 +5048,12 @@ async function collectAgentSnapshot() {
         .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;
+        // Stamp the platform and lane it was found on. Agent ids are UUIDs so a collision is unlikely,
+        // but a merged list with no provenance cannot tell a localhost fixture agent from a production
+        // one — the same blending that made the ticket panel report 583.
+        if (agent && agent.agentId) {
+          byAgentId[baseUrl + '|' + agent.agentId] = { ...agent, baseUrl, lane: agent.dataMode || session.dataMode };
+        }
       }
     } catch (err) {
       errors.push({ baseUrl, accountId: Number(session.accountId), message: describeError(err) });
@@ -4670,12 +5066,110 @@ async function collectAgentSnapshot() {
     registered: Object.values(byAgentId)
       .sort((a, b) => Number(b.lastSeenAtMs || 0) - Number(a.lastSeenAtMs || 0)),
     local: listLocalAgents(),
+    // Workers are a purely LOCAL fact — the platform knows a ticket is claimed, not that a process on
+    // this laptop is running it — so they are read from disk here rather than from any endpoint.
+    workers: listLocalAgents().reduce((all, entry) => all.concat(
+      listWorkers(entry.agentId).map((worker) => ({
+        ...worker,
+        agentId: entry.agentId,
+        label: entry.label || entry.agentId,
+        alive: !!(worker.pid && processIsAlive(worker.pid))
+      }))), []),
     errors
   };
   agentSnapshotCache = { fetchedAtMs: nowMs, value };
   return value;
 }
 
+/**
+ * Split the fetched queues into the compartments a number can honestly be reported for.
+ *
+ * <p>A compartment is one <b>platform and one data lane</b>. Blending them was the headline defect:
+ * the panel summed a production platform's queue with a localhost test-lane queue full of suite
+ * fixtures and presented the result as "OPEN". Prod showed 24; the panel showed 583.</p>
+ *
+ * <p>Three narrower defects rode along with it, and each would still be wrong after separating the
+ * regions:</p>
+ * <ul>
+ *   <li><b>The sum double-counted.</b> Two sessions whose account hierarchies overlap both return the
+ *       same ticket, and the totals were summed per queue while only the DISPLAYED list was deduped.
+ *       Overlap is detectable: {@code /cli/tickets} reports the accounts it actually scanned, so a
+ *       queue whose scanned set is contained in another's is dropped before anything is added up.</li>
+ *   <li><b>Ticket ids were deduped globally.</b> An id is unique within a platform, not across them —
+ *       so a localhost fixture with the same id as a real production ticket silently hid it. Keys are
+ *       per compartment now.</li>
+ *   <li><b>"Waiting" was total minus routed</b>, which is <i>unrouted</i>, not waiting. With a real
+ *       awaiting-a-reply concept on the record, that label was pointing at the wrong thing entirely.</li>
+ * </ul>
+ */
+function buildTicketCompartments(queues) {
+  const byCompartment = {};
+  for (const queue of queues || []) {
+    const key = queue.compartment || (queue.baseUrl + ' · ' + (queue.dataMode || 'prod') + ' lane');
+    if (!byCompartment[key]) {
+      byCompartment[key] = { compartment: key, baseUrl: queue.baseUrl, dataMode: queue.dataMode, queues: [] };
+    }
+    byCompartment[key].queues.push(queue);
+  }
+
+  return Object.values(byCompartment).map((group) => {
+    // Drop any queue whose scanned accounts are wholly contained in another's: its tickets are already
+    // in that one, so keeping it would count them twice. Equal sets keep the first seen.
+    const scanned = group.queues.map((queue) => new Set(
+      (queue.searchedAccounts || []).map((entry) => String(entry.accountId || entry.accountScope || ''))));
+    const independent = group.queues.filter((queue, i) => {
+      if (!scanned[i].size) {
+        return true;   // nothing reported: cannot prove overlap, so keep it and report honestly below
+      }
+      return !group.queues.some((other, j) => {
+        if (i === j || !scanned[j].size) return false;
+        const contained = [...scanned[i]].every((id) => scanned[j].has(id));
+        if (!contained) return false;
+        // Identical scopes: keep the earlier one, drop the later, or both would drop each other.
+        const identical = scanned[i].size === scanned[j].size;
+        return identical ? j < i : true;
+      });
+    });
+
+    const ticketsById = {};
+    for (const queue of independent) {
+      for (const ticket of queue.tickets || []) {
+        const id = String(ticket.ticketId || '');
+        if (!id || ticketsById[id]) continue;
+        ticketsById[id] = { ...ticket, queueAccountId: queue.accountId, baseUrl: queue.baseUrl,
+                            dataMode: queue.dataMode, compartment: group.compartment };
+      }
+    }
+    const tickets = Object.values(ticketsById);
+
+    const open = independent.reduce((sum, queue) => sum + Number(queue.totalCount || 0), 0);
+    const routed = independent.reduce((sum, queue) => sum + Number((queue.counts || {}).routed || 0), 0);
+    const assigned = independent.reduce((sum, queue) => sum + Number((queue.counts || {}).assigned || 0), 0);
+
+    return {
+      compartment: group.compartment,
+      baseUrl: group.baseUrl,
+      dataMode: group.dataMode,
+      queueCount: independent.length,
+      overlappingQueuesDropped: group.queues.length - independent.length,
+      // Counted from queues proven to scan disjoint account scopes, so the same ticket is never added
+      // twice. `scopeUnknown` says so out loud when a queue could not report what it scanned — a count
+      // that MIGHT overlap must never read as one that cannot.
+      scopeUnknown: independent.some((queue) => !(queue.searchedAccounts || []).length),
+      open,
+      routed,
+      unrouted: Math.max(0, open - routed),
+      assigned,
+      // Only ever counted over the page actually retrieved, and labelled as such in the UI.
+      awaitingReplyOnPage: tickets.filter((t) => t.awaitingResponseSince).length,
+      accounts: independent.map((queue) => ({
+        accountId: queue.accountId, open: Number(queue.totalCount || 0), scanned: (queue.searchedAccounts || []).length
+      })),
+      tickets: tickets.slice(0, Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100))
+    };
+  }).sort((a, b) => b.open - a.open);
+}
+
 async function collectSupportTicketSnapshot() {
   const nowMs = Date.now();
   if (supportTicketSnapshotCache.value &&
@@ -4711,34 +5205,11 @@ async function collectSupportTicketSnapshot() {
     }
   }));
 
-  const ticketsById = {};
-  for (const queue of queues) {
-    for (const ticket of queue.tickets || []) {
-      const key = String(ticket.ticketId || '');
-      if (!key || ticketsById[key]) {
-        continue;
-      }
-      ticketsById[key] = {
-        ...ticket,
-        queueAccountId: queue.accountId,
-        baseUrl: queue.baseUrl
-      };
-    }
-  }
-
   const value = {
     fetchedAt: new Date(nowMs).toISOString(),
     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)),
+    compartments: buildTicketCompartments(queues),
     queues,
     errors
   };
@@ -4793,7 +5264,8 @@ function renderDashboardHtml(snapshot) {
       ':root{--bg:#f5f1e8;--surface:#fffdf8;--surface-strong:#fff;--ink:#1f1c16;--muted:#6f685d;--line:#d9d0c0;--line-strong:#bbaa93;--green:#1f8f58;--green-soft:#e8f6ee;--yellow:#c38a16;--yellow-soft:#fff6db;--red:#c1493d;--red-soft:#fdeae7;--blue:#2456d3;--blue-soft:#eaf0ff;}' +
       '*{box-sizing:border-box;}body{margin:0;font-family:Menlo,Monaco,monospace;background:radial-gradient(circle at top left,#fffdf8 0,#f5f1e8 48%,#ece4d7 100%);color:var(--ink);}h1,h2,h3,h4,summary{font-family:Georgia,serif;}button{font:inherit;}a{color:var(--blue);}main{max-width:1440px;margin:0 auto;padding:24px;}header.hero{display:flex;justify-content:space-between;gap:16px;align-items:flex-start;margin-bottom:20px;padding:24px;border:1px solid var(--line);border-radius:22px;background:linear-gradient(135deg,#fffefb 0,#f8f1e3 100%);box-shadow:0 14px 40px rgba(72,53,22,.08);}header.hero p{margin:8px 0 0 0;max-width:760px;color:var(--muted);line-height:1.5;} .hero-meta{display:flex;gap:10px;flex-wrap:wrap;justify-content:flex-end;} .pill{display:inline-flex;align-items:center;gap:8px;padding:8px 12px;border:1px solid var(--line);border-radius:999px;background:rgba(255,255,255,.75);font-size:12px;} .status-grid,.section-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:16px;} .section-grid{margin-top:18px;} .status-card,.panel,.action-card{border:1px solid var(--line);border-radius:18px;background:var(--surface-strong);box-shadow:0 10px 28px rgba(72,53,22,.06);} .status-card{padding:18px;position:relative;overflow:hidden;} .status-card::after{content:"";position:absolute;inset:auto -40px -40px auto;width:120px;height:120px;border-radius:999px;background:rgba(0,0,0,.03);} .status-head{display:flex;align-items:center;gap:12px;margin-bottom:12px;} .status-dot{width:14px;height:14px;border-radius:50%;display:inline-block;box-shadow:0 0 0 4px rgba(0,0,0,.04);} .ok .status-dot{background:var(--green);} .warn .status-dot{background:var(--yellow);} .bad .status-dot{background:var(--red);} .status-value{font-size:30px;line-height:1;font-family:Georgia,serif;} .status-label{font-size:12px;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);} .status-sub{margin-top:10px;color:var(--muted);font-size:13px;line-height:1.45;} .status-card.ok{background:linear-gradient(180deg,var(--surface-strong),var(--green-soft));} .status-card.warn{background:linear-gradient(180deg,var(--surface-strong),var(--yellow-soft));} .status-card.bad{background:linear-gradient(180deg,var(--surface-strong),var(--red-soft));}' +
       '.action-card{padding:18px;margin:18px 0 0 0;background:linear-gradient(180deg,#fffdf9,#f7f1e6);} .action-row{display:flex;flex-wrap:wrap;gap:10px;margin-top:12px;} .action-btn{padding:10px 14px;border-radius:12px;border:1px solid var(--line-strong);background:var(--surface-strong);cursor:pointer;transition:transform .12s ease,background .12s ease,border-color .12s ease;} .action-btn:hover{transform:translateY(-1px);background:#fff7ea;} .action-btn:disabled{opacity:.55;cursor:wait;transform:none;} .panel{padding:18px;} .panel h2{margin:0 0 12px 0;font-size:22px;} .muted{color:var(--muted);} .summary-list{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-top:8px;} .summary-item{padding:12px;border:1px solid var(--line);border-radius:14px;background:#fcfaf4;} .summary-item .k{display:block;font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);margin-bottom:6px;} .summary-item .v{font-size:18px;font-family:Georgia,serif;}' +
-      '.accordion{display:grid;gap:14px;} details.group,details.item{border:1px solid var(--line);border-radius:16px;background:#fffdf9;overflow:hidden;} details.group[open],details.item[open]{border-color:var(--line-strong);box-shadow:0 10px 24px rgba(72,53,22,.05);} summary{list-style:none;cursor:pointer;padding:16px 18px;display:flex;align-items:center;justify-content:space-between;gap:16px;} summary::-webkit-details-marker{display:none;} .summary-main{display:flex;align-items:center;gap:12px;min-width:0;} .summary-text{display:flex;flex-direction:column;gap:4px;min-width:0;} .summary-title{font-size:18px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} .summary-meta{font-size:12px;color:var(--muted);} .summary-caret{color:var(--muted);font-size:18px;} details[open] > summary .summary-caret{transform:rotate(90deg);} .group-body,.item-body{padding:0 18px 18px 18px;} .mini-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px;margin-bottom:14px;} .mini-card{padding:12px;border:1px solid var(--line);border-radius:12px;background:#fcfaf4;} .mini-card strong{display:block;font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:var(--muted);margin-bottom:6px;} .code-block{white-space:pre-wrap;overflow:auto;max-height:320px;padding:14px;border:1px solid var(--line);border-radius:12px;background:#f7f4ee;font-size:12px;line-height:1.45;} .code-block.log{max-height:420px;background:#1f1c16;color:#f4ead7;border-color:#3f382d;} .stack{display:grid;gap:12px;} .badge{display:inline-flex;align-items:center;gap:6px;padding:5px 9px;border-radius:999px;border:1px solid var(--line);font-size:11px;text-transform:uppercase;letter-spacing:.08em;} .badge.ok{background:var(--green-soft);border-color:#b9dfc9;color:#175a39;} .badge.warn{background:var(--yellow-soft);border-color:#edd69c;color:#895c08;} .badge.bad{background:var(--red-soft);border-color:#efc1bb;color:#8b322a;} .repo-files{display:grid;gap:12px;} .empty{padding:18px;border:1px dashed var(--line-strong);border-radius:16px;background:#fcfaf4;color:var(--muted);} .toast{position:fixed;right:18px;bottom:18px;padding:12px 14px;border-radius:14px;border:1px solid var(--line-strong);background:#fffdf8;box-shadow:0 14px 24px rgba(72,53,22,.16);display:none;max-width:360px;} .toast.show{display:block;} @media (max-width:900px){main{padding:16px;}header.hero{flex-direction:column;} .hero-meta{justify-content:flex-start;}}' +
+      '.wlog{max-height:460px;overflow:auto;background:#1f1c16;color:#f4ead7;border-radius:12px;border:1px solid #3f382d;padding:12px;font-size:12px;line-height:1.5;} .wlog .ev{padding:6px 8px;border-radius:8px;margin-bottom:6px;white-space:pre-wrap;word-break:break-word;} .wlog .cmd{background:#2b271f;border-left:3px solid #8fb98f;} .wlog .cmd.bad{border-left-color:#d98b80;} .wlog .msg{background:#262219;border-left:3px solid #e0c07a;} .wlog .think{color:#a89f8c;font-style:italic;} .wlog .edit{background:#2b271f;border-left:3px solid #7aa7d9;} .wlog .res{background:#2f2a1f;border-left:3px solid #e0c07a;font-weight:600;} .wlog .raw{color:#d98b80;} .wlog .out{color:#b8ae99;display:block;margin-top:4px;max-height:180px;overflow:auto;} .wlog-bar{display:flex;align-items:center;gap:10px;margin-bottom:8px;flex-wrap:wrap;} '+
+        '.accordion{display:grid;gap:14px;} details.group,details.item{border:1px solid var(--line);border-radius:16px;background:#fffdf9;overflow:hidden;} details.group[open],details.item[open]{border-color:var(--line-strong);box-shadow:0 10px 24px rgba(72,53,22,.05);} summary{list-style:none;cursor:pointer;padding:16px 18px;display:flex;align-items:center;justify-content:space-between;gap:16px;} summary::-webkit-details-marker{display:none;} .summary-main{display:flex;align-items:center;gap:12px;min-width:0;} .summary-text{display:flex;flex-direction:column;gap:4px;min-width:0;} .summary-title{font-size:18px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} .summary-meta{font-size:12px;color:var(--muted);} .summary-caret{color:var(--muted);font-size:18px;} details[open] > summary .summary-caret{transform:rotate(90deg);} .group-body,.item-body{padding:0 18px 18px 18px;} .mini-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px;margin-bottom:14px;} .mini-card{padding:12px;border:1px solid var(--line);border-radius:12px;background:#fcfaf4;} .mini-card strong{display:block;font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:var(--muted);margin-bottom:6px;} .code-block{white-space:pre-wrap;overflow:auto;max-height:320px;padding:14px;border:1px solid var(--line);border-radius:12px;background:#f7f4ee;font-size:12px;line-height:1.45;} .code-block.log{max-height:420px;background:#1f1c16;color:#f4ead7;border-color:#3f382d;} .stack{display:grid;gap:12px;} .badge{display:inline-flex;align-items:center;gap:6px;padding:5px 9px;border-radius:999px;border:1px solid var(--line);font-size:11px;text-transform:uppercase;letter-spacing:.08em;} .badge.ok{background:var(--green-soft);border-color:#b9dfc9;color:#175a39;} .badge.warn{background:var(--yellow-soft);border-color:#edd69c;color:#895c08;} .badge.bad{background:var(--red-soft);border-color:#efc1bb;color:#8b322a;} .repo-files{display:grid;gap:12px;} .empty{padding:18px;border:1px dashed var(--line-strong);border-radius:16px;background:#fcfaf4;color:var(--muted);} .toast{position:fixed;right:18px;bottom:18px;padding:12px 14px;border-radius:14px;border:1px solid var(--line-strong);background:#fffdf8;box-shadow:0 14px 24px rgba(72,53,22,.16);display:none;max-width:360px;} .toast.show{display:block;} @media (max-width:900px){main{padding:16px;}header.hero{flex-direction:column;} .hero-meta{justify-content:flex-start;}}' +
     '</style>' +
     '</head><body>' +
     '<main>' +
@@ -4831,6 +5303,9 @@ function renderDashboardHtml(snapshot) {
       '<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>Ticket Workers</h2><div id="worker-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>' +
@@ -4864,15 +5339,16 @@ 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 agentState=state.agents||{};const agentList=agentState.registered||[];const idleAgents=agentList.filter(function(a){return (a.state||"idle")==="idle";}).length;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 ticketParts=ticketState.compartments||[];const ticketTotal=ticketParts.reduce(function(s,p){return s+Number(p.open||0);},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:"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:"Tickets",value:String(ticketTotal),label:"Open, all platforms and lanes",tone:ticketErrors?"warn":"ok",sub:ticketErrors?String(ticketErrors)+" queue fetch error(s)":(ticketParts.length>1?ticketParts.map(function(p){return String(p.open||0)+" "+(p.dataMode||"prod");}).join(" · "):"One compartment")},' +
+          '{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 serve"},' +
+          '{title:"Workers",value:String(((state.agents||{}).workers||[]).length),label:"Autonomous ticket runs",tone:((state.agents||{}).workers||[]).length?"ok":"warn",sub:((state.agents||{}).workers||[]).length?"One headless process per ticket":"Nothing running. Start with: remits-cli agent serve"},' +
           '{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 agentList=(state.agents||{}).registered||[];const ticketCounts=(state.supportTickets||{}).counts||{};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 ticketParts2=(state.supportTickets||{}).compartments||[];const ticketCounts={routed:ticketParts2.reduce(function(s,p){return s+Number(p.routed||0);},0)};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)),' +
@@ -4884,19 +5360,25 @@ function renderDashboardHtml(snapshot) {
         '].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||[];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 renderSupportTickets(state){const target=document.getElementById("support-ticket-section");const support=state.supportTickets||{};const parts=support.compartments||[];const errors=support.errors||[];let html="";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(!parts.length&&!errors.length){target.innerHTML=html+\'<div class="empty">No authenticated support-ticket queue is available yet.</div>\';return;}html+=parts.map(function(part,pi){const lane=(part.dataMode||"prod");const meta=badge(lane+" lane",lane==="test"?"warn":"ok")+\' \'+badge(String(part.open||0)+" open","ok")+\' <span class="muted">\'+escapeHtml(String(part.queueCount||0))+\' account queue(s)\'+(part.overlappingQueuesDropped?", "+part.overlappingQueuesDropped+" overlapping dropped":"")+\'</span>\';const caveat=part.scopeUnknown?\'<div class="mini-card"><strong>Note</strong>A queue did not report which accounts it scanned, so this total may count a ticket more than once.</div>\':"";const cards=\'<div class="mini-grid"><div class="mini-card"><strong>Open</strong>\'+escapeHtml(String(part.open||0))+\'</div><div class="mini-card"><strong>Routed To An Agent</strong>\'+escapeHtml(String(part.routed||0))+\'</div><div class="mini-card"><strong>Unrouted</strong>\'+escapeHtml(String(part.unrouted||0))+\'</div><div class="mini-card"><strong>Awaiting A Reply</strong>\'+escapeHtml(String(part.awaitingReplyOnPage||0))+\' <span class="muted">of \'+escapeHtml(String((part.tickets||[]).length))+\' shown</span></div></div>\'+caveat;const rows=(part.tickets||[]).length?(part.tickets||[]).map(function(ticket,index){const routed=!!ticket.routedAgentId;const waiting=!!ticket.awaitingResponseSince;const meta2=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")+(waiting?\' \'+badge("awaiting reply","warn"):"")+\' <span class="muted">\'+escapeHtml(ticket.accountName||ticket.accountId||"unknown account")+\'</span>\';return detailsBlock("support-ticket:"+pi+":"+ticket.ticketId,String(ticket.ticketId||"ticket")+" "+(ticket.subject||""),meta2,supportTicketDetails(state,ticket,"support-ticket:"+pi+":"+index),false);}).join(""):\'<div class="empty">No open support tickets in this compartment.</div>\';return detailsBlock("compartment:"+part.compartment,part.baseUrl||part.compartment,meta,cards+\'<div class="accordion">\'+rows+\'</div>\',pi===0);}).join("");html+=\'<div class="muted" style="margin-top:10px;">Each platform and data lane is counted separately. A localhost test-lane queue is full of suite fixtures and is not comparable to a production queue — summing them is what made this panel report 583 open tickets against a production queue of 24.</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){if(ticket.baseUrl&&a.baseUrl&&a.baseUrl!==ticket.baseUrl)return false;if(ticket.dataMode&&a.dataMode&&a.dataMode!==ticket.dataMode)return false;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)+\'" data-route-base="\'+escapeHtml(ticket.baseUrl||"")+\'" data-route-mode="\'+escapeHtml(ticket.dataMode||"")+\'" 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 lane=ticket.dataMode||"prod";const planning=[ticket.workstream?("Workstream "+ticket.workstream):"",ticket.plannedIn?("Planned "+ticket.plannedIn):"",ticket.boardStage?("Board "+ticket.boardStage):"",ticket.rank!==undefined&&ticket.rank!==null&&ticket.rank!==""?("Rank "+ticket.rank):"",ticket.size?("Size "+ticket.size):"",ticket.blockedBy?("Blocked by "+ticket.blockedBy):""].filter(Boolean).join(" / ");const command="remits-cli ticket read --ticket "+String(ticket.ticketId||"")+" --data-mode "+lane+"\\nremits-cli ticket accept --ticket "+String(ticket.ticketId||"")+" --data-mode "+lane;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 class="mini-card"><strong>Planning</strong>\'+escapeHtml(planning||"No planning fields")+\'</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 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 renderWorkers(state){const target=document.getElementById("worker-section");const workers=((state.agents||{}).workers)||[];if(!workers.length){target.innerHTML=\'<div class="empty">No autonomous ticket workers are running. Start one with <strong>remits-cli agent serve</strong> — it launches a fresh headless agent process per routed ticket, so no session accumulates context across tickets.</div>\';return;}target.innerHTML=workers.map(function(w,index){const meta=badge(w.agentType||"agent",w.alive?"ok":"bad")+\' \'+badge(w.alive?"running":"exited",w.alive?"ok":"bad")+\' <span class="muted">attempt \'+escapeHtml(String(w.attempt||1))+\'</span>\';const t=escapeHtml(String(w.ticketId||""));const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Ticket</strong>\'+escapeHtml(String(w.ticketId||"?"))+\'</div><div class="mini-card"><strong>Doing Now</strong>\'+escapeHtml(w.activity||"nothing reported yet")+\'</div><div class="mini-card"><strong>Started</strong>\'+escapeHtml(formatTime(w.startedAt))+\'</div><div class="mini-card"><strong>Pid</strong>\'+escapeHtml(String(w.pid||"?"))+\'</div><div class="mini-card"><strong>Repo</strong>\'+escapeHtml(w.workingDirectory||"(none resolved)")+\'</div><div class="mini-card"><strong>Supervisor</strong>\'+escapeHtml(w.label||w.agentId||"?")+\'</div></div><div class="wlog-bar"><button class="action-btn" data-follow-ticket="\'+t+\'">Follow live</button><label class="muted"><input type="checkbox" data-follow-tail="\'+t+\'" checked> stick to bottom</label><span class="muted" data-follow-status="\'+t+\'"></span></div><div class="wlog" data-follow-log="\'+t+\'"><div class="muted">Press <strong>Follow live</strong> to stream this run.</div></div>\'+codeBlock("wlog-tail:"+t,"tail -f "+(w.logFile||""))+\'</div>\';return detailsBlock("worker:"+w.ticketId,"Ticket "+w.ticketId+" - "+(w.subject||"(no subject)"),meta,body,index===0);}).join("");restartActiveFollows();}' +
+        'var followState={};' +
+        'function eventHtml(ev){if(!ev)return "";const t=escapeHtml(ev.text||"");if(ev.kind==="command"){const bad=(ev.exitCode!==null&&ev.exitCode!==undefined&&ev.exitCode!==0);const out=ev.detail?\'<span class="out">\'+escapeHtml(String(ev.detail).slice(0,2000))+\'</span>\':"";return \'<div class="ev cmd\'+(bad?" bad":"")+\'">$ \'+t+(bad?\' <span class="muted">(exit \'+escapeHtml(String(ev.exitCode))+\')</span>\':"")+out+\'</div>\';}if(ev.kind==="message")return \'<div class="ev msg">\'+t+\'</div>\';if(ev.kind==="thinking")return \'<div class="ev think">\'+t+\'</div>\';if(ev.kind==="edit")return \'<div class="ev edit">\'+t+\'</div>\';if(ev.kind==="result")return \'<div class="ev res">\'+t+\'</div>\';if(ev.kind==="raw")return \'<div class="ev raw">\'+t+\'</div>\';return \'<div class="ev">\'+t+\'</div>\';}' +
+        'async function pollFollow(ticket){const st=followState[ticket];if(!st)return;const box=document.querySelector(\'[data-follow-log="\'+ticket+\'"]\');const status=document.querySelector(\'[data-follow-status="\'+ticket+\'"]\');if(!box){return;}try{const r=await fetch("/api/worker-log?ticket="+encodeURIComponent(ticket)+"&offset="+st.offset);const d=await r.json();if(d.missing){status&&(status.textContent="no transcript yet");}else{if(st.offset===0)box.innerHTML="";st.offset=d.offset||st.offset;const html=(d.events||[]).map(eventHtml).join("");if(html){box.insertAdjacentHTML("beforeend",html);const stick=document.querySelector(\'[data-follow-tail="\'+ticket+\'"]\');if(!stick||stick.checked)box.scrollTop=box.scrollHeight;}status&&(status.textContent=(d.running?"live":"finished")+" - "+(d.size||0)+" bytes");if(!d.running&&d.offset>=d.size){st.settleCount=(st.settleCount||0)+1;if(st.settleCount>2){clearInterval(st.timer);delete followState[ticket];return;}}else{st.settleCount=0;}}}catch(e){status&&(status.textContent="stream error");}}' +
+        'function startFollow(ticket){if(followState[ticket]){clearInterval(followState[ticket].timer);}followState[ticket]={offset:0,timer:null};pollFollow(ticket);followState[ticket].timer=setInterval(function(){pollFollow(ticket);},2000);}' +
+        'function restartActiveFollows(){Object.keys(followState).forEach(function(t){const box=document.querySelector(\'[data-follow-log="\'+t+\'"]\');if(!box){clearInterval(followState[t].timer);delete followState[t];return;}const st=followState[t];st.offset=0;box.innerHTML="";pollFollow(t);});}' +
+        '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">\'+escapeHtml(agent.baseUrl||"?")+\' · 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);renderAgents(state);renderActivity(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);renderWorkers(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,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);});' +
+        'document.addEventListener("click",function(event){const follow=event.target.closest?event.target.closest("[data-follow-ticket]"):null;if(follow){startFollow(follow.getAttribute("data-follow-ticket"));return;}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,baseUrl:select.getAttribute("data-route-base"),dataMode:select.getAttribute("data-route-mode")};}triggerAction(action,button,extra);});' +
         'renderAll(dashboardState);' +
         'setInterval(function(){fetchState().then(renderAll).catch(function(err){showToast(err.message||String(err));});},refreshMs);' +
       '})();' +
@@ -4929,6 +5411,172 @@ async function reconnectManagedWebsockets() {
   }
 }
 
+/**
+ * Turn a worker's raw JSONL transcript into readable events for the dashboard.
+ *
+ * <p>A worker has no terminal to attach to — it is spawned with pipes, deliberately, and `codex exec`
+ * / `claude -p` are non-interactive, so there is nothing to type at even if there were a tty. What a
+ * reader actually wants is to FOLLOW ALONG, and for that the JSONL is strictly better than a terminal
+ * would be: it is already structured, so commands, their exit codes, file changes and the agent's own
+ * messages can be rendered as distinct things instead of scraped back out of ANSI output.</p>
+ *
+ * <p>Reads incrementally from a byte offset so the browser polls for the tail rather than re-fetching
+ * a transcript that grows to megabytes.</p>
+ */
+function readWorkerTranscript(logFile, fromOffset = 0) {
+  const empty = { events: [], offset: 0, size: 0, missing: true };
+  if (!logFile || !fs.existsSync(logFile)) {
+    return empty;
+  }
+  // Only ever serve files from the worker log directory. The dashboard binds to 127.0.0.1, but a path
+  // taken from a query string and handed to readFileSync is a file-read primitive regardless.
+  const resolved = path.resolve(logFile);
+  if (path.dirname(resolved) !== path.resolve(WORKER_LOG_DIR)) {
+    return { ...empty, missing: false, forbidden: true };
+  }
+
+  const size = fs.statSync(resolved).size;
+  // A truncated or rotated file (size went backwards) must restart, not read from a stale offset.
+  const start = Math.min(Math.max(0, Number(fromOffset) || 0), size);
+  if (start >= size) {
+    return { events: [], offset: size, size, missing: false };
+  }
+
+  const fd = fs.openSync(resolved, 'r');
+  let text = '';
+  try {
+    const length = size - start;
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, start);
+    text = buffer.toString('utf8');
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  // Only whole lines are consumed; a partial trailing line is left for the next poll by rewinding the
+  // reported offset, so a JSON object split across two reads is never dropped as unparseable.
+  const lines = text.split('\n');
+  const trailing = lines.pop();
+  const consumed = size - Buffer.byteLength(trailing, 'utf8');
+
+  const events = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    // describeWorkerEvent returns null for the bookkeeping frames a reader does not want
+    // (thread.started, todo_list, …). Dropping them here keeps the payload a clean list.
+    const described = describeWorkerEvent(line);
+    if (described) {
+      events.push(described);
+    }
+  }
+  return { events, offset: consumed, size, missing: false };
+}
+
+/** One transcript line as {kind, text, detail} — never throws, and never drops a line it cannot parse. */
+function describeWorkerEvent(line) {
+  let event = null;
+  try {
+    event = JSON.parse(line);
+  } catch (_) {
+    // Not JSON: a plain stderr line from the agent or the shell. Worth showing verbatim — the times
+    // this matters most (a crash, a missing binary) are exactly the times it is not JSON.
+    return { kind: 'raw', text: line.slice(0, 4000) };
+  }
+  if (!event || typeof event !== 'object') {
+    return { kind: 'raw', text: line.slice(0, 4000) };
+  }
+
+  if (event.type === 'item.completed' && event.item) {
+    const item = event.item;
+    const kind = item.item_type || item.type;
+    if (kind === 'command_execution') {
+      return {
+        kind: 'command',
+        text: String(item.command || ''),
+        exitCode: item.exit_code == null ? null : Number(item.exit_code),
+        detail: String(item.aggregated_output || '').slice(0, 4000)
+      };
+    }
+    if (kind === 'file_change') {
+      return { kind: 'edit', text: 'edited files', detail: JSON.stringify(item.changes || item, null, 2).slice(0, 4000) };
+    }
+    if (kind === 'reasoning') return { kind: 'thinking', text: String(item.text || '').slice(0, 4000) };
+    if (kind === 'agent_message') return { kind: 'message', text: String(item.text || '').slice(0, 8000) };
+    if (kind === 'todo_list') return null;
+  }
+  if (event.type === 'assistant' && event.message && Array.isArray(event.message.content)) {
+    for (const block of event.message.content) {
+      if (block && block.type === 'tool_use') {
+        const input = block.input || {};
+        return {
+          kind: 'command',
+          text: String(block.name || 'tool') + (input.command || input.file_path || input.pattern
+            ? ': ' + (input.command || input.file_path || input.pattern) : ''),
+          detail: JSON.stringify(input, null, 2).slice(0, 4000)
+        };
+      }
+      if (block && block.type === 'text' && block.text) {
+        return { kind: 'message', text: String(block.text).slice(0, 8000) };
+      }
+    }
+  }
+  if (event.type === 'result') {
+    return { kind: 'result', text: 'finished: ' + (event.subtype || 'done'), detail: String(event.result || '').slice(0, 4000) };
+  }
+  if (event.type === 'turn.completed' && event.usage) {
+    return { kind: 'result', text: 'turn complete', detail: JSON.stringify(event.usage) };
+  }
+  // Bookkeeping frames a reader gains nothing from. `item.started` in particular is paired with an
+  // `item.completed` carrying the same command plus its output and exit code, so showing both doubles
+  // the transcript and puts every command on screen twice.
+  if (event.type === 'thread.started' || event.type === 'turn.started' ||
+      event.type === 'item.started' || event.type === 'item.updated' || event.type === 'system') {
+    return null;
+  }
+  return { kind: 'event', text: String(event.type || 'event') };
+}
+
+/** The transcript of one running or finished worker, addressed by its ticket. */
+function workerTranscriptFor(ticketId, fromOffset) {
+  const id = String(ticketId || '').trim();
+  if (!id) {
+    return { error: 'a ticketId is required' };
+  }
+  let worker = null;
+  for (const entry of listLocalAgents()) {
+    const found = listWorkers(entry.agentId).find((w) => String(w.ticketId) === id);
+    if (found) {
+      worker = { ...found, agentId: entry.agentId };
+      break;
+    }
+  }
+  // A worker that has EXITED is gone from the store but its transcript is the most interesting one to
+  // read, so fall back to the newest log file for that ticket.
+  let logFile = worker && worker.logFile;
+  if (!logFile && fs.existsSync(WORKER_LOG_DIR)) {
+    const candidates = fs.readdirSync(WORKER_LOG_DIR)
+      .filter((name) => name.startsWith(id + '-') && name.endsWith('.log'))
+      .sort();
+    if (candidates.length) {
+      logFile = path.join(WORKER_LOG_DIR, candidates[candidates.length - 1]);
+    }
+  }
+  if (!logFile) {
+    return { ticketId: id, missing: true, events: [], offset: 0 };
+  }
+  const transcript = readWorkerTranscript(logFile, fromOffset);
+  return {
+    ticketId: id,
+    logFile,
+    running: !!(worker && worker.pid && processIsAlive(worker.pid)),
+    pid: worker ? worker.pid : null,
+    agentType: worker ? worker.agentType : null,
+    startedAt: worker ? worker.startedAt : null,
+    follow: 'tail -f ' + logFile,
+    ...transcript
+  };
+}
+
 function startDashboardServer(preferredPort) {
   return new Promise((resolve, reject) => {
     const sendDashboardError = (res, err, wantsJson = true) => {
@@ -4992,7 +5640,9 @@ function startDashboardServer(preferredPort) {
               actionResult = await routeTicketFromDashboard({
                 ticketId: params.get('ticketId'),
                 accountId: params.get('accountId'),
-                agentId: params.get('agentId')
+                agentId: params.get('agentId'),
+                baseUrl: params.get('baseUrl'),
+                dataMode: params.get('dataMode')
               });
               supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
               agentSnapshotCache = { fetchedAtMs: 0, value: null };
@@ -5018,6 +5668,20 @@ function startDashboardServer(preferredPort) {
         return;
       }
 
+      if (req.method === 'GET' && requestUrl.pathname === '/api/worker-log') {
+        try {
+          const payload = workerTranscriptFor(
+            requestUrl.searchParams.get('ticket'),
+            Number(requestUrl.searchParams.get('offset')) || 0);
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify(payload));
+        } catch (err) {
+          sendDashboardError(res, err, true);
+        }
+        return;
+      }
+
       if (req.method === 'GET' && requestUrl.pathname === '/') {
         try {
           const snapshot = await collectDashboardSnapshot();
@@ -5451,45 +6115,409 @@ const AGENT_WORK_POLL_MS = Number(process.env.REMITS_CLI_AGENT_WORK_POLL_MS || 5
 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: {} };
+// ---------------------------------------------------------------------------------------------
+// Autonomous ticket workers
+//
+// A registered agent can also SERVE: a detached supervisor polls for the tickets routed to this
+// session and launches ONE fresh headless agent process per ticket.
+//
+// One ticket = one process is the whole point, and it is what makes context grooming structural
+// rather than a discipline. `/clear` and `/new` are TUI commands a human types; a model cannot
+// invoke them, so a long-lived interactive session working ticket after ticket has no way to reset
+// itself. A process that exits has nothing to reset.
+//
+// The supervisor is deliberately dumb: it starts workers, reports what they are doing, and cleans
+// up after them. Every decision that must survive it — which session a ticket is routed to, which
+// worker holds it — is durable on the platform, so killing the supervisor loses nothing but time.
+// ---------------------------------------------------------------------------------------------
+
+const WORKER_LOG_DIR = path.join(SESSION_DIR, 'workers');
+const AGENT_SERVE_POLL_MS = Number(process.env.REMITS_CLI_AGENT_SERVE_POLL_MS || 20000);
+const AGENT_SERVE_IDLE_POLL_MS = Number(process.env.REMITS_CLI_AGENT_SERVE_IDLE_POLL_MS || 60000);
+// After this many consecutive empty polls, back off to the idle cadence. An agent waiting all night
+// should not hold a request-per-20s against production for work that arrives twice a day.
+const AGENT_SERVE_IDLE_AFTER_POLLS = 10;
+const AGENT_WORKER_MAX_ATTEMPTS = Number(process.env.REMITS_CLI_AGENT_WORKER_MAX_ATTEMPTS || 2);
+const AGENT_WORKER_STATUS_THROTTLE_MS = 20000;
+const AGENT_WORKER_MAX_LOG_BYTES = 8 * 1024 * 1024;
+
+/**
+ * How each supported agent is invoked headlessly, and how far it is allowed to go.
+ *
+ * Every one of them takes the brief on STDIN rather than in argv: a brief is a page of prose and
+ * argv has a hard length limit, so passing it as an argument fails on exactly the detailed tickets
+ * that most need the detail.
+ *
+ * `mode` is the autonomy bound, not a preference. `investigate` maps to each CLI's genuine
+ * read-only mode so an operator can put a real boundary around a production support agent; `edit`
+ * lets it change files but never commits (the brief says so, and nothing here runs git).
+ */
+const AGENT_LAUNCHERS = {
+  codex: {
+    binary: 'codex',
+    // A ticket worker's whole job runs THROUGH the platform: `remits-cli ticket read/accept/progress/
+    // complete`, and every investigation tool. So the sandbox has to let it reach the platform, and by
+    // default it does not — `workspace-write` disables network, and a worker launched without this flag
+    // fails its FIRST command with exit 6 / HTTP 000 while looking, from the outside, like an agent that
+    // simply did not do much. Passed on the command line rather than documented as a config edit so the
+    // supervisor works on a machine nobody has prepared.
+    //
+    // `read-only` is deliberately NOT used for investigate mode, even though it is the tighter sandbox.
+    // It has no network AND no setting that restores it, so a read-only worker cannot read the ticket it
+    // was given, cannot run a diagnostic, and cannot record a finding — the three things investigating
+    // IS. It would then exit 0 having written nothing, which the supervisor reads as a delivered
+    // judgement and un-routes, so the next sweep hands the same ticket to another worker that learns the
+    // same nothing. A loop that reports success is worse than a refusal.
+    //
+    // What enforces the read-only phase instead: the brief's Boundaries section, which names the lease
+    // holder, says which commands not to run, and explains that the shared CHECKOUT is the thing at
+    // risk. Enforcement moved from the sandbox to the instructions deliberately — the sandbox could not
+    // express "may talk to the platform, may not write this directory".
+    build: ({ cwd, mode, lastMessageFile }) => ({
+      args: [
+        'exec',
+        '--cd', cwd,
+        '--skip-git-repo-check',
+        '--sandbox', 'workspace-write',
+        '-c', 'sandbox_workspace_write.network_access=true',
+        '--json',
+        ...(lastMessageFile ? ['--output-last-message', lastMessageFile] : []),
+        '-'
+      ],
+      // Reported on the worker record so an operator can tell a phase the platform derived from a
+      // sandbox the launcher applied — they are no longer the same thing for codex.
+      sandbox: 'workspace-write' + (mode === 'investigate' ? ' (investigate: boundary is the brief)' : '')
+    })
+  },
+  claude: {
+    binary: 'claude',
+    // Same requirement, different mechanism: in `-p` there is no one to answer a permission prompt, so
+    // an un-allowlisted Bash call is DENIED rather than queued. Without this the worker cannot run
+    // remits-cli at all. `plan` mode is avoided for the same reason `read-only` is avoided above.
+    build: ({ cwd, mode }) => ({
+      args: [
+        '-p',
+        '--add-dir', cwd,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--permission-mode', 'acceptEdits',
+        '--allowedTools', 'Bash,Read,Grep,Glob,WebFetch' + (mode === 'investigate' ? '' : ',Edit,Write')
+      ],
+      sandbox: 'acceptEdits' + (mode === 'investigate' ? ' (investigate: no Edit/Write tool)' : '')
+    })
+  },
+  gemini: {
+    binary: 'gemini',
+    // gemini's -p takes the prompt as a value and APPENDS it to stdin, so the brief still travels on
+    // stdin and -p carries only the instruction to act on it.
+    build: ({ mode }) => ({
+      args: [
+        '-p', 'Work the support ticket described above, following its instructions exactly.',
+        '--approval-mode', mode === 'investigate' ? 'plan' : 'auto_edit',
+        '--output-format', 'stream-json'
+      ],
+      sandbox: mode === 'investigate' ? 'plan' : 'auto_edit'
+    })
   }
-  try {
-    const data = JSON.parse(fs.readFileSync(AGENT_STATE_FILE, 'utf8'));
-    return data && typeof data === 'object' && data.agents ? data : { agents: {} };
-  } catch (_) {
-    return { agents: {} };
+};
+
+/**
+ * Which supported agent IS this process, judged from the anchor's command line.
+ *
+ * The binary name leads: an agent's command line routinely mentions another agent's name in a path
+ * (`/Users/me/.codex/skills/...` while running claude), so a plain substring scan over the whole line
+ * picks the wrong one. Returns null for an anchor that is not a supported worker — `cursor-agent` and
+ * `aider` can anchor a session but cannot be launched as workers — so the caller falls back rather
+ * than guessing.
+ */
+function detectAgentKind(command) {
+  const line = String(command || '').trim();
+  if (!line) {
+    return null;
+  }
+  const binary = path.basename(line.split(/\s+/)[0] || '').toLowerCase();
+  const exact = SUPPORTED_AGENTS.find((agent) => binary === agent || binary.startsWith(agent + '-'));
+  if (exact) {
+    return exact;
   }
+  return SUPPORTED_AGENTS.find((agent) => new RegExp('(^|[/\\s])' + agent + '($|[\\s])', 'i').test(line)) || null;
 }
 
-function writeAgentStore(store) {
-  ensureSessionDir();
-  atomicWriteFile(AGENT_STATE_FILE, JSON.stringify(store || { agents: {} }, null, 2));
+/**
+ * Which agent a worker should be launched as.
+ *
+ * Precedence: an explicit flag, then WHAT THIS SESSION ACTUALLY IS, then the configured preference,
+ * then the default. The anchor beats the config because it is specific to this session, and because
+ * the alternative is the surprise this ordering exists to remove: `agent serve` in a Claude tab
+ * labelling itself `claude@repo` while launching codex workers, since the label already detected
+ * from the anchor and only the worker choice read the config. One question, one answer.
+ */
+function workerAgentType(value, anchor = null) {
+  return resolveWorkerAgent(value, anchor).agent;
 }
 
-function processIsAlive(pid) {
-  const numeric = Number(pid);
-  if (!Number.isFinite(numeric) || numeric <= 0) {
-    return false;
+/**
+ * The worker choice AND why it was made.
+ *
+ * The reason is reported, not just the value, because the intended host for a supervisor is a plain
+ * terminal tab — where nothing in the process tree is an AI agent, so the choice comes from a config
+ * file the operator may have set months ago and forgotten. "codex" on its own is indistinguishable
+ * from a default; "codex (from your ~/.remits-cli/config.json)" is a fact they can act on.
+ */
+function resolveWorkerAgent(value, anchor = null) {
+  const candidate = String(value || '').trim().toLowerCase();
+  if (SUPPORTED_AGENTS.includes(candidate)) {
+    return { agent: candidate, source: 'flag', why: 'you passed --worker-agent' };
   }
-  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';
+  const detected = detectAgentKind(anchor && anchor.command);
+  if (detected) {
+    return { agent: detected, source: 'session', why: 'this session is running ' + detected };
+  }
+  const config = readConfig();
+  if (SUPPORTED_AGENTS.includes(String(config.agent || '').toLowerCase())) {
+    return {
+      agent: String(config.agent).toLowerCase(),
+      source: 'config',
+      why: 'from ' + CONFIG_FILE + ' — override per run with --worker-agent'
+    };
   }
+  return {
+    agent: DEFAULT_AGENT,
+    source: 'default',
+    why: 'nothing configured and no agent in this session — pass --worker-agent to choose'
+  };
 }
 
 /**
- * The locally-known agent sessions, dropping any whose anchor process has gone.
+ * Is this directory a real checkout, rather than something that merely contains an account-info.json?
  *
- * 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.
+ * <p>The index is built by scanning for `account-info.json`, and that file is also in every zip export
+ * of an account. An unpacked export in `~/Downloads` therefore looks exactly like a checkout, and it
+ * exists — which was the whole of the previous validation.</p>
  */
-function listLocalAgents() {
-  const store = readAgentStore();
+function isAccountCheckout(directory) {
+  try {
+    return !!directory && fs.existsSync(path.join(directory, '.git'));
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Where the repository for an account is checked out on THIS machine, or null.
+ *
+ * <p>Null when the entry is not a git checkout, and that is the load-bearing part. The caller's next
+ * step on null is the brief telling the worker "no local checkout was resolved — do not guess", which
+ * is the correct outcome; the previous `fs.existsSync` test let an unpacked zip export in `~/Downloads`
+ * satisfy it instead, so the guard never fired and a worker edited, staged and reported success against
+ * a directory with no remote and no history. Nothing about that run looked wrong. Measured on this
+ * machine: account 11 (11 open tickets) and account 2 both resolved that way.</p>
+ */
+function repoDirectoryForAccount(accountId) {
+  const wanted = Number(accountId);
+  if (!Number.isFinite(wanted) || wanted <= 0) {
+    return null;
+  }
+  const entry = listAccountRepoEntries(readAccountRepoIndex())
+    .find((candidate) => Number(candidate.accountId) === wanted);
+  if (!entry || !entry.directory || !isAccountCheckout(entry.directory)) {
+    return null;
+  }
+  return entry.directory;
+}
+
+/**
+ * Everything wrong with the local account-repo index, as sentences an operator can act on.
+ *
+ * <p>Reported at `agent serve` rather than discovered one ticket at a time: a supervisor about to work a
+ * production queue should be told up front which accounts it cannot work, because the alternative is
+ * finding out per ticket, hours apart, from a brief that says only "no checkout resolved".</p>
+ */
+function accountRepoIndexProblems(ownCwd = null) {
+  const problems = [];
+  // The account this session is standing in resolves from its OWN directory, not from the shared index,
+  // so an ambiguity there is not a problem for this supervisor — it is two worktrees working as intended.
+  // Reporting it anyway trains an operator to ignore the warning, and the warning is load-bearing for
+  // every OTHER account, where a silent wrong winner is unrecoverable.
+  const own = ownCwd ? accountCheckoutIdentity(ownCwd) : null;
+  for (const entry of listAccountRepoEntries(readAccountRepoIndex())) {
+    const label = 'account ' + entry.accountId + ' (' + (entry.name || 'unnamed') + ')';
+    if (!fs.existsSync(entry.directory)) {
+      problems.push({ accountId: Number(entry.accountId), severity: 'unusable',
+        message: label + ': the recorded directory no longer exists — ' + entry.directory });
+    } else if (!isAccountCheckout(entry.directory)) {
+      problems.push({ accountId: Number(entry.accountId), severity: 'unusable',
+        message: label + ': ' + entry.directory + ' is not a git checkout (an unpacked export?). ' +
+          'Tickets for this account will park instead of being worked.' });
+    }
+    if (Array.isArray(entry.ambiguousWith) && entry.ambiguousWith.length &&
+        !(own && own.accountId === Number(entry.accountId))) {
+      problems.push({ accountId: Number(entry.accountId), severity: 'ambiguous',
+        message: label + ': more than one checkout claims this account. Using ' + entry.directory +
+          '; also found ' + entry.ambiguousWith.join(', ') +
+          '. Set the right one with `remits-cli agent repos --account-id ' + entry.accountId +
+          ' --directory <path>`.' });
+    }
+  }
+  return problems;
+}
+
+/**
+ * The working directory a ticket should be worked in.
+ *
+ * The implementation account leads when the ticket names one — a defect observed on a CLIENT is
+ * almost always fixed in the PLATFORM/PRODUCT repo above it — then the ticket's own account. When
+ * neither is checked out here the answer is null, and the brief says so explicitly instead of
+ * letting the worker start in whatever directory the supervisor happened to inherit.
+ */
+function resolveTicketWorkingDirectory(ticket, ownCwd = null) {
+  const facts = (ticket && ticket.briefFacts) || {};
+  const candidates = [
+    facts.repoAccountId,
+    ticket && ticket.implementationAccountId,
+    ticket && ticket.accountId
+  ].map((value) => Number(value)).filter((value) => Number.isFinite(value) && value > 0);
+
+  // THIS supervisor's own checkout wins, when it is a checkout of one of the candidate accounts.
+  //
+  // The account-repo index is a single global map keyed by accountId, and `agent serve` writes its own
+  // cwd into it — so two supervisors serving two git WORKTREES of one account fight over one entry, and
+  // the second to start silently repoints the first's future workers into its own tree. That is the
+  // shape worktrees exist to prevent: a supervisor must launch its workers where IT is, not where the
+  // machine's last-registered session happened to be. The index stays the answer for every account this
+  // session is not standing in, which is the normal case.
+  const own = ownCwd ? accountCheckoutIdentity(ownCwd) : null;
+  if (own && candidates.includes(own.accountId)) {
+    return own.directory;
+  }
+
+  for (const candidate of candidates) {
+    const dir = repoDirectoryForAccount(candidate);
+    if (dir) {
+      return dir;
+    }
+  }
+  return null;
+}
+
+/**
+ * Which account this directory is a checkout OF, read from the directory itself.
+ *
+ * Deliberately not a lookup in the shared index: the whole point is to answer for one process without
+ * consulting a map another process can overwrite. Null when the directory is not a real checkout — an
+ * unpacked zip export carries `account-info.json` too, which is exactly the trap `isAccountCheckout`
+ * exists to close.
+ */
+function accountCheckoutIdentity(directory) {
+  try {
+    if (!directory || !isAccountCheckout(directory)) {
+      return null;
+    }
+    const info = loadAccountInfo(directory);
+    const accountId = Number(info && accountIdFromAccountInfo(info));
+    if (!Number.isFinite(accountId) || accountId <= 0) {
+      return null;
+    }
+    return { accountId, directory: path.resolve(directory) };
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Turn a worker's streamed output into something an operator can read in one line.
+ *
+ * All three agents emit JSONL, and all three emit a different shape, so this reads defensively and
+ * returns null for anything it does not recognise rather than guessing. A wrong activity line is
+ * worse than none: the dashboard is the only window into a headless run, and it has to be trusted.
+ */
+function summarizeWorkerEvent(line) {
+  let event = null;
+  try {
+    event = JSON.parse(line);
+  } catch (_) {
+    return null;
+  }
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  // codex exec --json. The item's kind is spelled `type` on the versions observed and `item_type` in
+  // some published examples, so read both rather than betting on one — a miss here is silent, and the
+  // whole run then reports "nothing reported yet" while working perfectly.
+  if (event.type === 'item.completed' && event.item) {
+    const item = event.item;
+    const kind = item.item_type || item.type;
+    if (kind === 'command_execution' && item.command) {
+      return 'ran: ' + String(item.command).slice(0, 120);
+    }
+    if (kind === 'file_change') {
+      return 'edited files';
+    }
+    if ((kind === 'reasoning' || kind === 'agent_message') && item.text) {
+      return String(item.text).split('\n')[0].slice(0, 120);
+    }
+  }
+
+  // claude / gemini stream-json
+  if (event.type === 'assistant' && event.message && Array.isArray(event.message.content)) {
+    for (const block of event.message.content) {
+      if (block && block.type === 'tool_use' && block.name) {
+        const input = block.input || {};
+        const detail = input.command || input.file_path || input.pattern || input.path || '';
+        return String(block.name + (detail ? ': ' + detail : '')).slice(0, 120);
+      }
+      if (block && block.type === 'text' && block.text) {
+        return String(block.text).split('\n')[0].slice(0, 120);
+      }
+    }
+  }
+  if (event.type === 'result' && event.subtype) {
+    return 'finishing: ' + event.subtype;
+  }
+  return null;
+}
+
+
+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 || {})) {
@@ -5582,11 +6610,9 @@ function resolveAgentAnchorPid() {
 
 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;
+  // Same resolution as the WORKER choice, deliberately: a label that says one agent while the
+  // supervisor launches another is worse than no label, because it is the only thing an operator sees.
+  return workerAgentType(null, anchor) + '@' + repo;
 }
 
 /**
@@ -5717,9 +6743,19 @@ async function agentRegisterCommand(flags, options = {}) {
     host: os.hostname(),
     pid: anchor.pid,
     cwd,
+    // WHERE this session works, not just who it is. One account can now have several checkouts at once
+    // (git worktrees) on different branches staging into different workspace lanes, so the account alone
+    // no longer identifies the tree a worker would edit — and the edit lease refusal, the work map and the
+    // ticket claim all report these back.
+    branch: currentBranch(cwd) || undefined,
+    workspace: resolveWorkspace(cwd, flags) || undefined,
     dataMode,
     accountId: Number(session.accountId) || undefined,
     accounts: agentAccountClaims(cwd),
+    // Capacity is how many workers this session can actually RUN, which only this side knows. The
+    // platform stops routing past it, so a supervisor at capacity is not handed work it cannot start.
+    maxConcurrent: options.serve ? options.serve.maxConcurrent : (flags['max-concurrent'] ? parsePositiveInt(flags['max-concurrent'], 1) : undefined),
+    autonomous: options.serve ? true : undefined,
     state: flags.state && AGENT_STATES.includes(String(flags.state)) ? String(flags.state) : 'idle',
     activity: flags.activity || null,
     source: flags.source || 'repo'
@@ -5748,7 +6784,18 @@ async function agentRegisterCommand(flags, options = {}) {
   // 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);
+    // Remembered so `agent release` can actually STOP it. Without the pid, deregistering only removes
+    // the platform record — and the daemon's very next poll sees registered:false and re-registers,
+    // so the session comes straight back and, when serving, resumes launching workers.
+    const daemonPid = startAgentHeartbeatDaemon(entry, options.serve || null);
+    entry.daemonPid = daemonPid;
+    entry.serving = !!options.serve;
+    if (options.serve) {
+      entry.workerAgent = options.serve.workerAgent;
+      entry.mode = options.serve.mode;
+      entry.maxConcurrent = options.serve.maxConcurrent;
+    }
+    rememberLocalAgent(entry);
   }
 
   if (flagEnabled(flags.json)) {
@@ -5775,14 +6822,170 @@ async function agentRegisterCommand(flags, options = {}) {
     console.log('      --data-mode prod to take real support work.');
   }
   console.log('');
-  console.log('You are on duty. The support loop, repeated for as long as you are working:');
+  if (options.serve) {
+    const serve = options.serve;
+    console.log('AUTONOMOUS. A supervisor is now running in the background for this session.');
+    console.log('  worker     ' + serve.workerAgent + '  (' + serve.mode + ' mode)');
+    console.log('             ' + serve.workerAgentWhy);
+    console.log('  capacity   ' + serve.maxConcurrent + ' ticket(s) at a time');
+    console.log('');
+    console.log('When a ticket is routed here it launches a fresh ' + serve.workerAgent + ' process for that');
+    console.log('ticket, in that account\'s repo, and that process exits when the ticket is done — so no');
+    console.log('session ever accumulates context across tickets.');
+    console.log('');
+    console.log('  remits-cli agent workers     what is running right now');
+    console.log('  remits-cli agent list        who else is available');
+    console.log('  remits-cli agent release     stop serving and go offline');
+    console.log('');
+    console.log('You do not have to do anything else. This terminal is free.');
+    return;
+  }
+  console.log('You are on duty, but nothing will start on its own. Either:');
+  console.log('');
+  console.log('  remits-cli agent serve       # autonomous: a worker process per routed ticket');
+  console.log('');
+  console.log('or work the loop yourself:');
   console.log('  1. remits-cli agent work --wait 600        # ask for work; returns as soon as any arrives');
   console.log('  2. remits-cli agent status --state working --ticket <id> --activity "what you are doing"');
   console.log('  3. work the ticket; keep step 2 current as you change what you are doing');
-  console.log('  4. close it out via mcp_support_ticket (accept -> update_status -> complete)');
+  console.log('  4. close it out via remits-cli ticket (accept -> status -> complete, ask, or release)');
   console.log('  5. remits-cli agent status --state idle    # then go back to step 1');
 }
 
+/**
+ * Register this session AND start working tickets autonomously.
+ *
+ * <p>Returns immediately, on purpose. The caller is very often an AI agent inside an interactive
+ * terminal, and a command that blocked would consume the session it was supposed to free — the
+ * supervisor is detached precisely so the tab that started it can go and do something else, or
+ * nothing at all.</p>
+ */
+async function agentServeCommand(flags) {
+  const choice = resolveWorkerAgent(flags['worker-agent'] || flags.agent, resolveAgentAnchorPid());
+  const workerAgent = choice.agent;
+  const launcher = AGENT_LAUNCHERS[workerAgent];
+  if (!commandExists(launcher.binary)) {
+    throw new Error('Cannot serve with "' + workerAgent + '": the `' + launcher.binary +
+      '` command is not on PATH. Install it, or pick another with --worker-agent ' +
+      SUPPORTED_AGENTS.filter((a) => a !== workerAgent).join('|') + '.');
+  }
+  const mode = String(flags.mode || (flagEnabled(flags['investigate-only']) ? 'investigate' : 'edit'))
+    .toLowerCase() === 'investigate' ? 'investigate' : 'edit';
+
+  // Say what this supervisor CANNOT work, before it starts rather than one ticket at a time. A worker
+  // pointed at an account with no usable checkout parks correctly, but the operator only learns that
+  // from a brief they may never read, hours later, on one ticket. `--strict-repos` turns it into a
+  // refusal for anyone who would rather not start a production run with known holes.
+  try {
+    updateAccountRepoIndex(process.cwd());
+    discoverAccountRepos();
+  } catch (_) { /* best-effort; the checks below still report what the index does say */ }
+  const problems = accountRepoIndexProblems(process.cwd());
+  if (problems.length) {
+    console.log('');
+    console.log('Account repository index — ' + problems.length + ' issue(s) to know about before serving:');
+    for (const problem of problems) {
+      console.log('  [' + problem.severity + '] ' + problem.message);
+    }
+    console.log('  Tickets for an "unusable" account are parked with an explanation, never worked in the');
+    console.log('  wrong directory. Fix with: remits-cli agent repos --account-id <id> --directory <path>');
+    const ownHere = accountCheckoutIdentity(process.cwd());
+    if (ownHere) {
+      console.log('  Account ' + ownHere.accountId + ' is exempt: this session serves it from its own directory');
+      console.log('  (' + ownHere.directory + '), so a second worktree elsewhere cannot redirect these workers.');
+    }
+    console.log('');
+    if (flagEnabled(flags['strict-repos'])) {
+      throw new Error('Refusing to serve with ' + problems.length +
+        ' account-repository issue(s). Resolve them, or drop --strict-repos to serve anyway.');
+    }
+  }
+
+  return agentRegisterCommand(flags, {
+    serve: {
+      workerAgent,
+      workerAgentWhy: choice.why,
+      mode,
+      maxConcurrent: Math.max(1, parsePositiveInt(flags['max-concurrent'], 1))
+    }
+  });
+}
+
+/** Is this binary runnable on this machine? Checked before serving, not on the first ticket. */
+function commandExists(binary) {
+  // `binary` only ever comes from AGENT_LAUNCHERS, so it is a fixed allowlist rather than user input.
+  try {
+    execFileSync('/bin/sh', ['-c', 'command -v ' + binary], { stdio: ['ignore', 'ignore', 'ignore'] });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Find this agent's daemon by looking for the process, when its pid was never recorded.
+ *
+ * `daemonPid` is only in the local store for agents registered by a build that writes it. An agent
+ * registered by an EARLIER build has none — and that daemon is precisely the one that cannot be
+ * stopped any other way: it is orphaned (its parent shell is long gone), it re-registers itself on
+ * the next heartbeat after any deregister, and it predates `serve` so it responds to nothing else.
+ * Its own command line carries the agentId, which is enough to find it.
+ */
+function findAgentDaemonPid(agentId) {
+  if (!agentId) {
+    return null;
+  }
+  try {
+    const listing = execFileSync('ps', ['-ax', '-o', 'pid=,command='], {
+      stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 8 * 1024 * 1024
+    }).toString();
+    for (const line of listing.split('\n')) {
+      if (!line.includes('agent') || !line.includes('heartbeat-daemon') || !line.includes(agentId)) {
+        continue;
+      }
+      const pid = Number((line.trim().match(/^(\d+)/) || [])[1]);
+      // Never signal ourselves: `agent release` run from inside a daemon would kill the command.
+      if (Number.isFinite(pid) && pid > 0 && pid !== process.pid && processIsAlive(pid)) {
+        return pid;
+      }
+    }
+  } catch (_) {
+    // ps unavailable or restricted — fall back to the recorded pid only.
+  }
+  return null;
+}
+
+/** What this session has running right now, and where to read each run's transcript. */
+async function agentWorkersCommand(flags) {
+  const agentId = resolveAgentId(flags, { optional: true });
+  if (!agentId) {
+    console.log('No local agent is registered in this session. Run: remits-cli agent serve');
+    return;
+  }
+  const workers = listWorkers(agentId);
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify({ agentId, workers }, null, 2));
+    return;
+  }
+  if (!workers.length) {
+    console.log('No ticket workers are running for ' + agentId + '.');
+    return;
+  }
+  console.log(workers.length + ' worker(s) running:');
+  for (const worker of workers) {
+    const alive = worker.pid && processIsAlive(worker.pid);
+    console.log('');
+    console.log('  ticket ' + worker.ticketId + '  [' + worker.agentType + ', pid ' + worker.pid +
+      (alive ? '' : ', NOT RUNNING') + ']');
+    console.log('    ' + (worker.subject || '(no subject)'));
+    console.log('    since   ' + worker.startedAt + '  attempt ' + (worker.attempt || 1));
+    console.log('    in      ' + (worker.workingDirectory || '(no repo resolved)') +
+      (worker.workspace ? '  workspace ' + worker.workspace : ''));
+    console.log('    doing   ' + (worker.activity || 'nothing reported yet'));
+    console.log('    log     ' + worker.logFile);
+  }
+}
+
 function readCliVersion() {
   try {
     return require(path.join(__dirname, 'package.json')).version || null;
@@ -5799,24 +7002,413 @@ function readCliVersion() {
  * 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) {
+function startAgentHeartbeatDaemon(entry, serve = null) {
   const { spawn } = require('child_process');
-  const child = spawn(process.execPath, [
+  const args = [
     __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 } });
+  ];
+  if (serve) {
+    args.push(
+      '--serve', 'true',
+      '--worker-agent', serve.workerAgent,
+      '--mode', serve.mode,
+      '--max-concurrent', String(serve.maxConcurrent));
+  }
+  const child = spawn(process.execPath, args, { detached: true, stdio: 'ignore', env: { ...process.env } });
   child.unref();
   appendGlobalActivityLog('agent', 'heartbeat.started', {
     agentId: entry.agentId,
     anchorPid: entry.anchorPid,
-    heartbeatPid: child.pid
+    heartbeatPid: child.pid,
+    serving: !!serve,
+    workerAgent: serve ? serve.workerAgent : null,
+    mode: serve ? serve.mode : null,
+    maxConcurrent: serve ? serve.maxConcurrent : null
   });
   return child.pid;
 }
 
+const WORKER_STATE_FILE = path.join(SESSION_DIR, 'workers.json');
+
+function readWorkerStore() {
+  if (!fs.existsSync(WORKER_STATE_FILE)) {
+    return { agents: {} };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(WORKER_STATE_FILE, 'utf8'));
+    return data && typeof data === 'object' && data.agents ? data : { agents: {} };
+  } catch (_) {
+    return { agents: {} };
+  }
+}
+
+function writeWorkerStore(store) {
+  ensureSessionDir();
+  atomicWriteFile(WORKER_STATE_FILE, JSON.stringify(store || { agents: {} }, null, 2));
+}
+
+/**
+ * The workers this agent has running, as a file.
+ *
+ * In memory would be enough for the supervisor itself; on disk is what lets `remits-cli agent
+ * workers` answer from another process, and what lets a restarted supervisor find the claims a
+ * killed one left behind and drop them instead of waiting out the TTL.
+ */
+function listWorkers(agentId) {
+  const store = readWorkerStore();
+  return Object.values((store.agents || {})[agentId] || {});
+}
+
+function recordWorker(agentId, ticketId, patch) {
+  const store = readWorkerStore();
+  store.agents = store.agents || {};
+  store.agents[agentId] = store.agents[agentId] || {};
+  const existing = store.agents[agentId][ticketId] || {};
+  store.agents[agentId][ticketId] = { ...existing, ...patch, ticketId };
+  writeWorkerStore(store);
+  return store.agents[agentId][ticketId];
+}
+
+function clearWorker(agentId, ticketId) {
+  const store = readWorkerStore();
+  if (store.agents && store.agents[agentId] && store.agents[agentId][ticketId]) {
+    delete store.agents[agentId][ticketId];
+    writeWorkerStore(store);
+  }
+}
+
+/**
+ * Attempts are counted on disk, per ticket, and survive the supervisor.
+ *
+ * Without this a ticket that reliably kills its worker is retried forever: the claim drops on exit,
+ * the next poll sees it routed and unclaimed, and a fresh process starts into the same wall. The
+ * counter is what turns that into a bounded retry ending in an honest release.
+ */
+function workerAttemptCount(agentId, ticketId) {
+  const store = readWorkerStore();
+  const attempts = ((store.attempts || {})[agentId] || {})[ticketId];
+  return Number(attempts) || 0;
+}
+
+function recordWorkerAttempt(agentId, ticketId) {
+  const store = readWorkerStore();
+  store.attempts = store.attempts || {};
+  store.attempts[agentId] = store.attempts[agentId] || {};
+  const next = (Number(store.attempts[agentId][ticketId]) || 0) + 1;
+  store.attempts[agentId][ticketId] = next;
+  writeWorkerStore(store);
+  return next;
+}
+
+function clearWorkerAttempts(agentId, ticketId) {
+  const store = readWorkerStore();
+  if (store.attempts && store.attempts[agentId] && store.attempts[agentId][ticketId] != null) {
+    delete store.attempts[agentId][ticketId];
+    writeWorkerStore(store);
+  }
+}
+
+/**
+ * The worker's closing summary, recorded on the ticket by the SUPERVISOR.
+ *
+ * <p>A worker is supposed to record what it established itself, with `remits-cli ticket progress`. Most
+ * do. The ones that do not are exactly the runs worth hearing from: a worker that hit its context limit,
+ * that crashed after investigating, or that could not reach the platform at all. Their conclusion was
+ * captured to disk the whole time (`codex exec --output-last-message`) and thrown away, so a ticket came
+ * back to the queue with nothing on it and the next worker rediscovered the same thing.</p>
+ *
+ * <p>Posted only when the run added no worklog entry of its own, so a worker that reported properly is
+ * not duplicated. Marked `worker_summary` rather than `investigation` so a reader can tell a finding the
+ * worker chose to record from a transcript tail the supervisor salvaged.</p>
+ */
+async function postWorkerSummary(context, agentId, ticket, summaryFile, options = {}) {
+  let text = '';
+  try {
+    text = fs.readFileSync(summaryFile, 'utf8').trim();
+  } catch (_) {
+    return false;   // codex only writes it on a clean finish, and the other launchers never do.
+  }
+  if (!text) {
+    return false;
+  }
+  // The worklog is read by people and by the next worker's brief; a whole transcript would bury both.
+  const MAX = 4000;
+  const body = text.length > MAX ? (text.slice(0, MAX) + '\n\n…truncated; full run: ' + options.logFile) : text;
+  try {
+    await buildAxios(context.baseUrl, context.session.token, 20000)
+      .post('/cli/ticket', {
+        action: 'progress',
+        ticketId: ticket.ticketId || ticket.id,
+        accountId: Number(ticket.accountId) || undefined,
+        dataMode: context.dataMode,
+        agentId,
+        category: 'worker_summary',
+        summary: 'Autonomous worker exited without recording a finding; this is its closing summary.',
+        details: body,
+        nextStep: options.nextStep || null
+      });
+    return true;
+  } catch (err) {
+    appendGlobalActivityLog('agent', 'worker.summary_post_failed', {
+      agentId, ticketId: ticket.ticketId || ticket.id, error: describeError(err)
+    }, 'error');
+    return false;
+  }
+}
+
+/** Drop a claim on the platform. Best-effort: the claim expires on its own if this never lands. */
+async function releaseTicketClaim(context, agentId, ticket, options = {}) {
+  try {
+    const response = await buildAxios(context.baseUrl, context.session.token, 20000)
+      .post('/cli/ticketClaim', {
+        action: 'unclaim',
+        agentId,
+        ticketId: ticket.ticketId || ticket.id,
+        accountId: Number(ticket.accountId),
+        outcome: options.outcome || null,
+        notes: options.notes || null,
+        release: options.release === true,
+        unroute: options.unroute === true
+      }).then((r) => r.data);
+    return response || null;
+  } catch (err) {
+    appendGlobalActivityLog('agent', 'worker.unclaim_failed', {
+      agentId, ticketId: ticket.ticketId || ticket.id, error: describeError(err)
+    }, 'error');
+    return null;
+  }
+}
+
+async function postAgentStatus(context, agentId, update) {
+  try {
+    await buildAxios(context.baseUrl, context.session.token, 10000)
+      .post('/cli/agentHeartbeat', { agentId, ...update });
+  } catch (_) {
+    // Status is commentary. Losing a line of it must never interrupt a run.
+  }
+}
+
+/**
+ * Launch one headless agent process for one ticket, and see it through to its exit.
+ *
+ * The brief comes from the platform ({@code SupportTicketBrief}) so all three agent types are told
+ * the same thing; only the working directory is resolved here, because only this machine knows
+ * where the account is checked out.
+ */
+function spawnTicketWorker(context, ctx, ticket) {
+  const { spawn } = require('child_process');
+  const agentId = ctx.agentId;
+  const ticketId = String(ticket.id || ticket.ticketId);
+  const agentType = ctx.workerAgent;
+  const launcher = AGENT_LAUNCHERS[agentType];
+  const runId = ctx.runId + '-' + ticketId;
+
+  if (!launcher) {
+    appendGlobalActivityLog('agent', 'worker.unsupported_agent', { agentId, ticketId, agentType }, 'error');
+    return { pid: null, done: Promise.resolve({ ticketId, ok: false, reason: 'unsupported_agent' }) };
+  }
+
+  const workingDirectory = resolveTicketWorkingDirectory(ticket, ctx && ctx.cwd);
+  // The brief is rendered server-side without the local path (the platform cannot know it), so the
+  // resolved directory is appended here. When nothing resolved, the server-rendered brief already
+  // tells the worker to find it rather than guess — do not paper over that with a default.
+  // The staging lane is set BY THIS FUNCTION (REMITS_WORKSPACE below) and the worker has no other way to
+  // learn it: `components status` would show it a lane it never chose, and anything it reports about "the
+  // staged code" is ambiguous until it knows which lane it means. Telling it is one line; making it guess
+  // is the whole class of defect the lane exists to remove.
+  const workerWorkspace = 'ticket-' + ticketId;
+  const brief = String(ticket.brief || '') + (workingDirectory
+    ? '\n\n## Resolved working directory\n\n`' + workingDirectory + '`\n'
+    : '') +
+    '\n\n## Your staging lane\n\n' +
+    'Every `remits-cli` command you run stages into the **`' + workerWorkspace + '`** workspace lane, not the\n' +
+    'shared one. This is set for you; you do not need to pass `--workspace`. It means your staged components\n' +
+    'are isolated from anyone else working this repository, and it also means a person looking at the shared\n' +
+    'lane will not see your changes — so say which lane you staged into when you report what you verified.\n';
+
+  fs.mkdirSync(WORKER_LOG_DIR, { recursive: true });
+  const logFile = path.join(WORKER_LOG_DIR, ticketId + '-' + Date.now() + '.log');
+  const lastMessageFile = path.join(WORKER_LOG_DIR, ticketId + '-' + Date.now() + '.result.txt');
+  // The sandbox and the brief MUST agree, and they used not to: `--mode investigate` set the launcher's
+  // sandbox while the server-rendered brief, never told, said "edit and verify freely" — so a read-only
+  // worker spent its run fighting a restriction nobody had mentioned. The platform now returns the phase
+  // it derived from the repository's edit lease, and that is the authority. The session's own --mode can
+  // only narrow it: an operator who asked for a read-only agent gets one even when the lease is free.
+  const effectiveMode = (ctx.mode === 'investigate' || ticket.phase === 'investigating')
+    ? 'investigate'
+    : 'edit';
+  const built = launcher.build({
+    cwd: workingDirectory || ctx.cwd,
+    mode: effectiveMode,
+    lastMessageFile: agentType === 'codex' ? lastMessageFile : null
+  });
+
+  const attempt = recordWorkerAttempt(agentId, ticketId);
+  const child = spawn(launcher.binary, built.args, {
+    cwd: workingDirectory || ctx.cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      // A worker must never be mistaken for its supervisor. Without this a `remits-cli agent status`
+      // run from inside the worker would resolve ambiguously against the local store.
+      REMITS_AGENT_ID: agentId,
+      REMITS_SUPPORT_TICKET_ID: ticketId,
+      REMITS_WORKER_RUN_ID: runId,
+      // Give the worker its OWN staging lane.
+      //
+      // The edit LEASE already serializes who may edit a repo, and this does not replace it — a lease
+      // protects the working tree, which two processes editing the same files would corrupt regardless of
+      // staging. What the lease does NOT cover is everyone else pointed at the same directory: a developer
+      // iterating in that repo, or a read-only investigating worker running a diagnostic. They all shared
+      // one staging lane with the editing worker, and `components stage` uploads the whole repo and
+      // REPLACES the lane — so a worker staging mid-edit made the human's next test run execute the
+      // worker's half-finished code, and vice versa.
+      //
+      // Env var rather than a flag because the worker is an arbitrary coding agent running arbitrary
+      // remits-cli commands; only the environment reaches all of them. An explicit --workspace on a
+      // command still wins, and `.remits-cli/workspace` in the repo does not override it.
+      REMITS_WORKSPACE: workerWorkspace
+    }
+  });
+
+  recordWorker(agentId, ticketId, {
+    pid: child.pid,
+    runId,
+    // The lane this worker was launched into. An operator reading `agent workers` otherwise has to know
+    // the naming convention to work out where its staged components went.
+    workspace: workerWorkspace,
+    attempt,
+    agentType,
+    // The sandbox the launcher actually applied. Kept beside the phase because for codex they are no
+    // longer the same fact: an investigating worker still runs workspace-write (it needs the network to
+    // report at all), and its boundary is the brief. An operator reading "investigating" must be able to
+    // see that.
+    sandbox: built.sandbox || null,
+    startedAt: new Date().toISOString(),
+    workingDirectory: workingDirectory || null,
+    accountId: ticket.accountId || null,
+    subject: ticket.subject || null,
+    logFile
+  });
+  appendGlobalActivityLog('agent', 'worker.started', {
+    agentId, ticketId, agentType, pid: child.pid, attempt, workingDirectory: workingDirectory || null,
+    // Which phase a run started in is the first thing anyone asks when its output looks thin, so it is
+    // on the record rather than inferable from a sandbox flag nobody logged.
+    phase: effectiveMode === 'investigate' ? 'investigating' : 'editing',
+    editLease: ticket.editLease ? { agentId: ticket.editLease.agentId, ticketId: ticket.editLease.ticketId } : null
+  });
+  if (ticket.phase === 'investigating' && ticket.editLeaseMessage) {
+    appendGlobalActivityLog('agent', 'worker.read_only', {
+      agentId, ticketId, message: ticket.editLeaseMessage
+    });
+  }
+
+  const logStream = fs.createWriteStream(logFile, { flags: 'a' });
+  let logBytes = 0;
+  let lastStatusAtMs = 0;
+  let buffered = '';
+
+  const consume = (chunk) => {
+    const text = chunk.toString();
+    if (logBytes < AGENT_WORKER_MAX_LOG_BYTES) {
+      logBytes += text.length;
+      logStream.write(text);
+    }
+    buffered += text;
+    const lines = buffered.split('\n');
+    buffered = lines.pop();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const summary = summarizeWorkerEvent(line);
+      if (!summary) continue;
+      const nowMs = Date.now();
+      if (nowMs - lastStatusAtMs < AGENT_WORKER_STATUS_THROTTLE_MS) continue;
+      lastStatusAtMs = nowMs;
+      recordWorker(agentId, ticketId, { activity: summary, activityAt: new Date().toISOString() });
+      postAgentStatus(context, agentId, {
+        state: 'working', ticketId, activity: summary, step: 'worker:' + agentType
+      });
+    }
+  };
+
+  child.stdout.on('data', consume);
+  child.stderr.on('data', consume);
+  child.stdin.on('error', () => { /* the worker exited before reading the brief */ });
+  child.stdin.write(brief);
+  child.stdin.end();
+
+  const done = new Promise((resolve) => {
+    child.on('error', (err) => {
+      appendGlobalActivityLog('agent', 'worker.spawn_failed',
+        { agentId, ticketId, agentType, error: describeError(err) }, 'error');
+      resolve({ ticketId, ok: false, reason: 'spawn_failed', message: describeError(err) });
+    });
+    child.on('close', async (code, signal) => {
+      try { logStream.end(); } catch (_) { /* nothing to do */ }
+      const ok = code === 0 && !signal;
+      appendGlobalActivityLog('agent', 'worker.finished',
+        { agentId, ticketId, agentType, code, signal, attempt, logFile }, ok ? 'info' : 'error');
+
+      // The exit code is a weak signal: a worker can exit non-zero having resolved the ticket, and
+      // zero having done nothing. So the TICKET decides — unclaim always, and only give up (release
+      // it back to the queue) once it has genuinely failed enough times and is still not terminal.
+      const giveUp = !ok && attempt >= AGENT_WORKER_MAX_ATTEMPTS;
+      const result = await releaseTicketClaim(context, agentId, { ticketId, accountId: ticket.accountId }, {
+        outcome: ok ? 'completed' : (signal ? 'killed' : 'failed'),
+        release: giveUp,
+        // A clean exit that left the ticket short of terminal is a DELIVERED judgement, not a failure —
+        // the worker chose pending_review, or documented that it cannot be done. Keeping it routed here
+        // would have the next poll start another worker that reaches the same conclusion, forever.
+        unroute: ok,
+        notes: giveUp
+          ? ('Autonomous ' + agentType + ' worker failed ' + attempt + ' time(s); returning to the queue. Log: ' + logFile)
+          : null
+      });
+
+      const row = (result && result.ticket) || {};
+
+      // Did this run leave anything on the record? If not, salvage its closing summary before the ticket
+      // goes back to the queue — otherwise the next worker starts from exactly where this one did.
+      // Compared against the count we were HANDED at spawn, so a worker that reported properly (or that
+      // asked a question, or completed) is never duplicated.
+      const worklogBefore = Number(ticket.worklogCount || 0);
+      const worklogAfter = Number(row.worklogCount != null ? row.worklogCount : worklogBefore);
+      if (worklogAfter <= worklogBefore && !['resolved', 'closed'].includes(String(row.status || ''))) {
+        await postWorkerSummary(context, agentId, { ticketId, accountId: ticket.accountId }, lastMessageFile, {
+          logFile,
+          nextStep: giveUp
+            ? 'This worker failed ' + attempt + ' time(s) and the ticket was returned to the queue.'
+            : null
+        });
+      }
+
+      const terminal = ['resolved', 'closed'].includes(String(row.status || ''));
+      if (terminal || giveUp) {
+        clearWorkerAttempts(agentId, ticketId);
+      }
+      clearWorker(agentId, ticketId);
+      resolve({ ticketId, ok, code, signal, terminal, gaveUp: giveUp, status: row.status || null, logFile });
+    });
+  });
+
+  return { pid: child.pid, done };
+}
+
+/**
+ * The one detached process behind a registered agent session: presence, and optionally work.
+ *
+ * <p>Presence and work-collection live in the SAME process on purpose. Both need to know how many
+ * workers are running — presence publishes it as capacity, collection needs it to decide how many
+ * tickets to take — and two processes maintaining that number separately would disagree the moment
+ * one of them stalled, with the platform believing whichever wrote last.</p>
+ *
+ * <p>When serving, the work poll IS the heartbeat: `/cli/agentWork` refreshes presence, publishes
+ * the live worker set, renews their claims, and returns newly claimed work, all in one request.</p>
+ */
 async function agentHeartbeatDaemonCommand(flags) {
   const agentId = String(flags['agent-id'] || flags.agentId || '').trim();
   const anchorPid = Number(flags['anchor-pid'] || flags.anchorPid);
@@ -5829,11 +7421,36 @@ async function agentHeartbeatDaemonCommand(flags) {
   // Re-registration must reuse the anchor it was given, never re-resolve one.
   process.env.REMITS_AGENT_ANCHOR_PID = String(anchorPid);
 
+  const serving = flagEnabled(flags.serve);
+  const ctx = {
+    agentId,
+    cwd,
+    // The daemon is detached: its own process tree says nothing about the session it serves, so the
+    // worker kind must come from the flag it was started with, never from re-detection.
+    workerAgent: workerAgentType(flags['worker-agent'] || flags.agent),
+    mode: String(flags.mode || 'edit').toLowerCase() === 'investigate' ? 'investigate' : 'edit',
+    maxConcurrent: Math.max(1, parsePositiveInt(flags['max-concurrent'], 1)),
+    runId: 'run-' + Date.now().toString(36)
+  };
+  const inFlight = new Map();
+
   const stop = async (reason) => {
-    appendGlobalActivityLog('agent', 'heartbeat.stopped', { agentId, anchorPid, reason });
+    appendGlobalActivityLog('agent', 'heartbeat.stopped',
+      { agentId, anchorPid, reason, workers: inFlight.size });
+    // Kill the workers first, then drop their claims. A worker left running after its supervisor is
+    // gone is unsupervised autonomy on production tickets — and its claim would then expire under a
+    // process that is still writing.
+    for (const [ticketId, entry] of inFlight.entries()) {
+      try { process.kill(entry.pid, 'SIGTERM'); } catch (_) { /* already gone */ }
+      clearWorker(agentId, ticketId);
+    }
     forgetLocalAgent(agentId);
     try {
       const context = agentSessionFor(flags, { cwd, baseUrl: flags['base-url'] });
+      for (const [ticketId, entry] of inFlight.entries()) {
+        await releaseTicketClaim(context, agentId,
+          { ticketId, accountId: entry.accountId }, { outcome: 'supervisor_stopped' });
+      }
       await buildAxios(context.baseUrl, context.session.token, 5000)
         .post('/cli/agentDeregister', { agentId });
     } catch (_) {
@@ -5845,21 +7462,108 @@ async function agentHeartbeatDaemonCommand(flags) {
   process.on('SIGTERM', () => { stop('signal'); });
   process.on('SIGINT', () => { stop('signal'); });
 
+  // A previous supervisor for this agent may have been killed mid-run, leaving claims behind. They
+  // would expire on their own, but that is up to 15 minutes during which this session cannot restart
+  // the work it is still routed. Clear anything whose process is demonstrably gone.
+  if (serving) {
+    for (const stale of listWorkers(agentId)) {
+      if (stale && stale.pid && processIsAlive(stale.pid)) {
+        continue;
+      }
+      clearWorker(agentId, stale.ticketId);
+      try {
+        const context = agentSessionFor(flags, { cwd, baseUrl: flags['base-url'] });
+        await releaseTicketClaim(context, agentId, stale, { outcome: 'orphaned' });
+      } catch (_) { /* the claim expires regardless */ }
+    }
+  }
+
+  let emptyPolls = 0;
   for (;;) {
     if (!processIsAlive(anchorPid)) {
       await stop('anchor_exited');
       return;
     }
+    let response = null;
     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);
+      const api = buildAxios(context.baseUrl, context.session.token, 30000);
+
+      if (serving) {
+        const activeTickets = [...inFlight.keys()];
+        response = await api.post('/cli/agentWork', {
+          agentId,
+          claim: inFlight.size < ctx.maxConcurrent,
+          runId: ctx.runId,
+          activeTickets,
+          maxConcurrent: ctx.maxConcurrent,
+          // Declared so the phase the platform derives already accounts for an operator who asked for a
+          // read-only agent. Without it the server would hand out an edit lease this session will never
+          // use, blocking a repository nobody is editing.
+          mode: ctx.mode,
+          statuses: 'all'
+        }).then((r) => r.data);
+
+        // The CLI and the platform are released separately, so a new supervisor can meet an older
+        // platform. That platform ignores `claim` and answers with EVERY routed ticket — which this loop
+        // would read as "start all of these", spawning past capacity with no claim protecting any of
+        // them. `supervising` is the platform confirming it understood the request, so its absence means
+        // stand down rather than guess.
+        if (response && response.supervising !== true) {
+          if (emptyPolls === 0) {
+            appendGlobalActivityLog('agent', 'serve.platform_too_old', {
+              agentId,
+              message: 'This platform does not support supervised claiming, so no workers will be started. ' +
+                'Update the platform, or work tickets manually with: remits-cli agent work'
+            }, 'error');
+          }
+          emptyPolls += 1;
+          await new Promise((resolve) => setTimeout(resolve, AGENT_SERVE_IDLE_POLL_MS));
+          continue;
+        }
+
+        // A swept ticket was routed at nobody and this session took it itself. Logged distinctly from a
+        // routed one so an operator reading the activity log can tell "somebody handed me this" from
+        // "nobody had, and I picked it up".
+        const sweptIds = new Set(((response && response.sweptTicketIds) || []).map((id) => String(id)));
+        if (sweptIds.size) {
+          appendGlobalActivityLog('agent', 'serve.swept_unrouted', {
+            agentId,
+            ticketIds: [...sweptIds],
+            message: 'Claimed ' + sweptIds.size + ' unrouted ticket(s) nobody had been given'
+          });
+        }
+
+        for (const ticket of (response && response.tickets) || []) {
+          const ticketId = String(ticket.id || ticket.ticketId || '');
+          if (!ticketId || inFlight.has(ticketId)) {
+            continue;
+          }
+          const started = spawnTicketWorker(context, ctx, ticket);
+          inFlight.set(ticketId, { pid: started.pid, accountId: ticket.accountId });
+          started.done.then(() => {
+            inFlight.delete(ticketId);
+            postAgentStatus(context, agentId, inFlight.size
+              ? { state: 'working', ticketId: [...inFlight.keys()][0] }
+              : { state: 'idle', ticketId: null, activity: null, step: null });
+          });
+        }
+        emptyPolls = (response && response.count) ? 0 : emptyPolls + 1;
+      } else {
+        response = await api.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' },
+          {
+            'agent-id': agentId,
+            'base-url': context.baseUrl,
+            'max-concurrent': String(ctx.maxConcurrent),
+            json: 'true'
+          },
           { spawnHeartbeat: false }
         ).catch((err) => {
           appendGlobalActivityLog('agent', 'heartbeat.reregister_failed',
@@ -5869,7 +7573,11 @@ async function agentHeartbeatDaemonCommand(flags) {
     } catch (err) {
       appendGlobalActivityLog('agent', 'heartbeat.failed', { agentId, error: describeError(err) }, 'error');
     }
-    await new Promise((resolve) => setTimeout(resolve, AGENT_HEARTBEAT_INTERVAL_MS));
+
+    const interval = !serving
+      ? AGENT_HEARTBEAT_INTERVAL_MS
+      : (emptyPolls >= AGENT_SERVE_IDLE_AFTER_POLLS ? AGENT_SERVE_IDLE_POLL_MS : AGENT_SERVE_POLL_MS);
+    await new Promise((resolve) => setTimeout(resolve, interval));
   }
 }
 
@@ -5972,8 +7680,8 @@ async function agentWorkCommand(flags) {
       }
       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 ticket read --ticket ' + (tickets[0].id || tickets[0].ticketId));
+      console.log('  remits-cli ticket accept --ticket ' + (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;
@@ -5983,6 +7691,647 @@ async function agentWorkCommand(flags) {
   }
 }
 
+/**
+ * The generic ticket lifecycle — read a ticket, and move it through its workflow.
+ *
+ * Deliberately NOT a wrapper around any account's ticket tool. `mcp_support_ticket` belongs to one
+ * particular System Account: it is owned by an account a given caller may not reach, it scopes to
+ * its own account, and a partner platform need not have it at all. This talks to the platform's own
+ * record, so the same commands work on every Remits platform — which is what an autonomous worker
+ * needs, since its brief has to be written before anyone knows which platform it will run on.
+ */
+async function ticketCommand(flags, subcommand) {
+  const action = String(subcommand || 'read').toLowerCase();
+
+  // `queue` and `create` are the two verbs with no ticket to act on, so they are dispatched before the
+  // id requirement rather than being forced to invent one.
+  if (action === 'queue' || action === 'list' || action === 'ls') {
+    return ticketQueueCommand(flags);
+  }
+  if (action === 'create' || action === 'new' || action === 'raise') {
+    return ticketCreateCommand(flags);
+  }
+  // Bulk reclaim scans a queue rather than acting on one id, so it is dispatched here too. With
+  // --ticket it falls through to the single-ticket path below like any other verb.
+  if (action === 'reclaim' && !flags.ticket && !flags['ticket-id']) {
+    return ticketReclaimSweepCommand(flags);
+  }
+
+  const ticketId = String(flags.ticket || flags['ticket-id'] || flags._?.[2] || process.env.REMITS_SUPPORT_TICKET_ID || '').trim();
+  if (!ticketId) {
+    printTicketHelp();
+    throw new Error('A --ticket ID is required (or set REMITS_SUPPORT_TICKET_ID).');
+  }
+
+  const local = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, local);
+
+  // Routing lives on its own endpoint (the operator surface the dashboard and any Embeddable share),
+  // so it is dispatched here rather than folded into the lifecycle switch.
+  if (action === 'route' || action === 'unroute') {
+    const agentId = action === 'unroute' ? null : String(flags.agent || flags['agent-id'] || '').trim();
+    if (action === 'route' && !agentId) {
+      throw new Error('route needs --agent <agentId>. See: remits-cli agent list');
+    }
+    const accountId = Number(flags['account-id']) || (await resolveTicketAccountId(context, ticketId));
+    const result = await buildAxios(context.baseUrl, context.session.token, 20000)
+      .post('/cli/ticketRoute', { ticketId, accountId, agentId, dataMode: context.dataMode })
+      .then((r) => r.data)
+      .catch((err) => (err && err.response && err.response.data) || null);
+    if (!result || result.success === false) {
+      console.error('Refused: ' + ((result && result.message) || 'routing failed'));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(result.routed
+      ? 'routed ticket ' + ticketId + ' to ' + (result.agentLabel || result.agentId)
+      : 'cleared routing on ticket ' + ticketId);
+    return;
+  }
+
+  const payload = {
+    action,
+    ticketId,
+    accountId: Number(flags['account-id']) || undefined,
+    dataMode: context.dataMode,
+    status: flags.status,
+    resolution: flags.resolution,
+    assignee: flags.assignee,
+    notes: flags.notes,
+    summary: flags.summary || flags.note,
+    question: flags.question,
+    context: flags.context,
+    // Recipients are a list on the platform side (message.to / deliver.to). A single value still works,
+    // so `--to a@x.test` and `--to a@x.test,b@x.test` both do what they look like they do.
+    to: flags.to ? String(flags.to).split(',').map((v) => v.trim()).filter(Boolean) : undefined,
+    message: flags.message || flags.answer,
+    route: flags.route === 'false' ? false : undefined,
+    details: flags.details,
+    nextStep: flags['next-step'],
+    category: flags.category,
+    // Clearing a planning slot has to be expressible, and `||` could not express it: an empty value is
+    // falsy, so it collapsed to undefined, JSON.stringify dropped the key, and the server was never told.
+    // The platform side has always supported clearing (an explicit blank nulls the field) — only the CLI
+    // could not ask for it. `--planned-in` with no value now means "clear it".
+    plannedIn: planningFlagValue(firstDefined(flags['planned-in'], flags.plannedIn)),
+    boardStage: planningFlagValue(firstDefined(flags['board-stage'], flags.boardStage)),
+    rank: planningFlagValue(flags.rank),
+    size: planningFlagValue(flags.size),
+    blockedBy: planningFlagValue(firstDefined(flags['blocked-by'], flags.blockedBy)),
+    workstream: planningFlagValue(flags.workstream),
+    tags: flags.tags ? String(flags.tags).split(',').map((v) => v.trim()).filter(Boolean) : undefined,
+    label: flags.label,
+    url: flags.url,
+    body: flags.body,
+    role: flags.role,
+    email: flags.email,
+    key: flags.key,
+    value: flags.value,
+    // Conversation and outbox. `--message` is shared with `answer`/`note`, which is deliberate: it is
+    // always "the text", and the ACTION decides who ends up reading it.
+    channel: flags.channel,
+    subject: flags.subject,
+    visibility: flags.visibility,
+    direction: flags.direction,
+    template: flags.template,
+    cc: flags.cc ? String(flags.cc).split(',').map((v) => v.trim()).filter(Boolean) : undefined,
+    deliveryId: flags['delivery-id'] || flags.deliveryId || undefined,
+    idempotencyKey: flags['idempotency-key'] || flags.idempotencyKey || undefined,
+    providerMessageId: flags['provider-message-id'] || undefined,
+    reason: flags.reason,
+    // Lease operations act as the AGENT, not the user: the lease is held by a worker session, and a
+    // human's email is not a thing that can hold one. Inside a worker these come from the environment
+    // the supervisor set, so the commands need no flags.
+    agentId: flags['agent-id'] || process.env.REMITS_AGENT_ID || undefined,
+    runId: flags['run-id'] || process.env.REMITS_WORKER_RUN_ID || undefined,
+    agentLabel: flags['agent-label'] || undefined,
+    // WHERE this run is working, sent with every lifecycle call so the lease and the claim record THIS
+    // process's checkout rather than the supervisor's. A ticket worker runs in its own workspace lane
+    // (REMITS_WORKSPACE=ticket-<id>) and may run in its own worktree, so the two genuinely differ.
+    ...runContextPayload(flags)
+  };
+
+  let response;
+  try {
+    response = await buildAxios(context.baseUrl, context.session.token, 30000)
+      .post('/cli/ticket', payload).then((r) => r.data);
+  } catch (err) {
+    // A lifecycle guard answers with 409 and a sentence saying what is wrong ("accept it first",
+    // "already assigned to someone else"). That sentence IS the correction a caller needs, so it must
+    // reach them intact rather than as an HTTP status.
+    const body = err && err.response && err.response.data;
+    if (body && body.message) {
+      console.error('Refused: ' + body.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+
+  if (action === 'where' || action === 'context') {
+    // The one run-context block, rendered by the platform so `ticket where`, `agent map`, the MCP tool and
+    // the operator UI cannot paraphrase the same repository four different ways.
+    const lines = (response && response.runContext && response.runContext.lines) || [];
+    if (!lines.length) console.log('No run context for ticket ' + ticketId + '.');
+    else lines.forEach((line) => console.log('  ' + line));
+    return;
+  }
+
+  if (flagEnabled(flags.json) || action === 'read' || action === 'deliveries') {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  if (action === 'force-unlease' || action === 'force_unlease') {
+    const previous = (response && response.previous) || null;
+    console.log(response.released
+      ? 'Edit lease on repository account ' + (response.repoAccountId || '?') + ' force-released' +
+        (previous ? ' (was held by ' + (previous.agentLabel || previous.agentId) + ')' : '') + '.'
+      : 'Nothing was holding the edit lease on this repository.');
+    console.log('  A handoff worklog entry was recorded on ticket ' + ticketId + '.');
+    return;
+  }
+
+  if (action === 'lease' || action === 'unlease') {
+    const lease = (response && response.editLease) || null;
+    if (action === 'unlease') {
+      console.log(response.released
+        ? 'Edit lease released. Another agent can now edit this repository.'
+        : 'You did not hold the edit lease on this repository; nothing to release.');
+      return;
+    }
+    if (response.success) {
+      console.log('Edit lease acquired — you may edit, stage and verify this repository.');
+      console.log('Release it as soon as you are done: remits-cli ticket unlease');
+      return;
+    }
+    // Not an error. The run continues read-only, and the message says who has it, WHERE they are working,
+    // and what to do instead of waiting.
+    console.log('Edit lease NOT acquired — this run stays read-only.');
+    if (response.message) console.log(response.message);
+    else if (lease) console.log('Held by ' + (lease.agentLabel || lease.agentId) + '.');
+    const holderAt = describeRunLocation(lease);
+    if (holderAt) console.log('Holder is working ' + holderAt);
+    process.exitCode = 0;
+    return;
+  }
+
+  const ticket = (response && response.ticket) || {};
+  console.log(action + ' ok — ticket ' + ticketId + ' is now [' + (ticket.status || '?') + ']' +
+    (ticket.assignedTo ? ', owned by ' + ticket.assignedTo : ', unassigned'));
+  // Say what was actually written. Without this, `message`, `note`, `deliver` and `participant` all
+  // printed the same status line, so the only feedback distinguishing "told the customer" from "left an
+  // internal note" was the word the caller had just typed.
+  if (action === 'message') {
+    console.log('  public message added (' + (ticket.messageCount || '?') + ' on the ticket) — visible to the requester.');
+    console.log('  This did NOT send anything. To have it delivered: remits-cli ticket deliver --channel email --to <who>');
+  }
+  if (action === 'note') console.log('  internal note added — the requester does not see it.');
+  if (action === 'participant') console.log('  participants: ' + (ticket.participantCount || '?'));
+  if (action === 'deliver') {
+    console.log('  delivery queued (' + (ticket.deliveryCount || '?') + ' on the ticket). An account-owned rule or');
+    console.log('  scheduled Action sends it. Check with: remits-cli ticket deliveries --ticket ' + ticketId);
+  }
+  if (action === 'planning' || action === 'plan') {
+    const planning = [
+      ticket.workstream ? 'workstream=' + ticket.workstream : '',
+      ticket.plannedIn ? 'plannedIn=' + ticket.plannedIn : '',
+      ticket.boardStage ? 'boardStage=' + ticket.boardStage : '',
+      ticket.rank !== undefined && ticket.rank !== null && ticket.rank !== '' ? 'rank=' + ticket.rank : '',
+      ticket.size ? 'size=' + ticket.size : '',
+      ticket.blockedBy ? 'blockedBy=' + ticket.blockedBy : ''
+    ].filter(Boolean).join(', ');
+    console.log('  planning: ' + (planning || 'cleared'));
+  }
+  if (ticket.awaitingResponseSince) {
+    console.log('  waiting on an answer since ' + ticket.awaitingResponseSince);
+    if (ticket.awaitingResponseQuestion) {
+      console.log('  question: ' + String(ticket.awaitingResponseQuestion).split('\n')[0].slice(0, 160));
+    }
+    console.log('  answer it with: remits-cli ticket reply --ticket ' + ticketId + ' --message "..."');
+  }
+}
+
+/**
+ * The ticket queue — what else is open, and what it looks like as a whole.
+ *
+ * <p><b>Why this had to exist.</b> The worker brief is emphatic that `remits-cli ticket` is the surface to
+ * use, and that an account's own ticket tooling must not be reached for: it belongs to one account, may not
+ * exist on this platform, and refuses tickets other accounts own. That advice was right and the surface was
+ * incomplete — it could act on ONE ticket whose id it was handed, and could not see anything else. So a
+ * worker could not tell that the ticket it was given is one of eleven instances of the same fix, could not
+ * check whether the defect it just found is already filed, and could not triage at all. The server side
+ * already existed in full (`/cli/tickets`, the same `queue(...)` the operator UI reads); its only consumer
+ * was the local dashboard.</p>
+ */
+async function ticketQueueCommand(flags) {
+  const local = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, local);
+  const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
+  if (!Number.isFinite(accountId) || accountId <= 0) {
+    throw new Error('ticket queue needs --account-id (or run it from an account repo).');
+  }
+
+  const csv = (value) => (value ? String(value).split(',').map((v) => v.trim()).filter(Boolean) : undefined);
+  const response = await buildAxios(context.baseUrl, context.session.token, 30000)
+    .post('/cli/tickets', {
+      accountId,
+      dataMode: context.dataMode,
+      statuses: csv(flags.status || flags.statuses),
+      priorities: csv(flags.priority || flags.priorities),
+      types: csv(flags.type || flags.types),
+      sources: csv(flags.source || flags.sources),
+      workstream: flags.workstream,
+      assignedTo: flags['assigned-to'] || flags.assignedTo,
+      routedAgentId: flags['routed-to'] || flags.routedAgentId,
+      unrouted: flagEnabled(flags.unrouted) || undefined,
+      unassigned: flagEnabled(flags.unassigned) || undefined,
+      // "Parked on a human" cannot be asked for with a status filter: `ask` parks a ticket in
+      // pending_review, which also means "done, review me".
+      awaitingResponse: flagEnabled(flags['awaiting-response'] || flags.awaitingResponse) || undefined,
+      plannedIn: flags['planned-in'] || flags.plannedIn,
+      boardStage: flags['board-stage'] || flags.boardStage,
+      blockedBy: flags['blocked-by'] || flags.blockedBy,
+      search: flags.search || flags.q,
+      sortBy: flags['sort-by'] || flags.sortBy,
+      sortDirection: flags['sort-direction'] || flags.sortDirection,
+      includeChildren: flags['include-children'] === 'false' ? false : undefined,
+      limit: parsePositiveInt(flags.limit, 25)
+    }).then((r) => r.data);
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  const tickets = (response && response.tickets) || [];
+  const counts = (response && response.counts) || {};
+  if (!tickets.length) {
+    console.log('No tickets match. (' + (response && response.dataMode) + ' lane, account ' + accountId + ')');
+    return;
+  }
+  console.log(String(response.totalCount != null ? response.totalCount : tickets.length) +
+    ' ticket(s) — ' + (counts.unrouted || 0) + ' unrouted, ' + (counts.unassigned || 0) + ' unassigned' +
+    ', ' + (counts.awaitingResponse || 0) + ' waiting on a human' +
+    '   [' + (response.dataMode || '?') + ' lane]');
+  console.log('');
+  // Board position is printed only when some ticket in this queue actually has one. An always-on column
+  // would be blank for every account that does not run a board, and a blank column reads as missing data.
+  const showsBoard = tickets.some((t) => t.boardStage || t.plannedIn || t.blockedBy);
+  for (const t of tickets) {
+    // The repo account, not just the owning account: it is what the edit lease excludes on, so it is
+    // what tells a reader which of these can be worked at the same time.
+    const repo = t.implementationAccountId || t.accountId;
+    const who = t.routedAgentLabel || t.routedAgentId || t.assignedTo || '—';
+    console.log('  ' + String(t.ticketId || t.id).padStart(6) + '  ' +
+      String(t.status || '').padEnd(14) + String(t.priority || '').padEnd(9) +
+      'repo ' + String(repo || '?').padEnd(6) +
+      String(who).slice(0, 18).padEnd(20) + String(t.subject || '').slice(0, 58));
+    // A second line rather than more columns: these are the account's own labels, of unbounded length,
+    // and truncating `awaiting_customer_confirmation` to fit a column makes it unrecognisable.
+    const marks = [
+      t.awaitingResponseSince ? 'WAITING ON A HUMAN' : '',
+      showsBoard && t.boardStage ? 'stage ' + t.boardStage : '',
+      showsBoard && t.plannedIn ? 'in ' + t.plannedIn : '',
+      showsBoard && t.blockedBy ? 'BLOCKED BY ' + t.blockedBy : ''
+    ].filter(Boolean);
+    if (marks.length) console.log(' '.repeat(10) + marks.join('   '));
+  }
+  if (response.totalCount > tickets.length) {
+    console.log('');
+    console.log('  showing ' + tickets.length + ' of ' + response.totalCount + ' — raise --limit to see more');
+  }
+}
+
+/**
+ * Find tickets an agent took and abandoned, and hand them back to the queue.
+ *
+ * <p><b>Dry by default.</b> This takes work away from a holder on a judgement about staleness, across a
+ * whole account tree, in one command — so the default is to show what it WOULD do. `--apply` is the
+ * operator saying yes. The platform re-checks every row against the document before acting, so a stale
+ * listing cannot cause a wrong reclaim even if this list is minutes old.</p>
+ */
+async function ticketReclaimSweepCommand(flags) {
+  const local = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, local);
+  const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
+  if (!Number.isFinite(accountId) || accountId <= 0) {
+    throw new Error('ticket reclaim needs --account-id (or --ticket ID for a single ticket).');
+  }
+  const staleHours = parsePositiveInt(flags['stale-hours'] || flags.staleHours, 24);
+  const apply = flagEnabled(flags.apply);
+
+  const queue = await buildAxios(context.baseUrl, context.session.token, 30000)
+    .post('/cli/tickets', {
+      accountId, dataMode: context.dataMode,
+      statuses: ['accepted', 'in_progress'], limit: parsePositiveInt(flags.limit, 200)
+    }).then((r) => r.data);
+
+  const cutoff = Date.now() - staleHours * 3600000;
+  // A local pre-filter only, to keep the output short and avoid asking about obviously-live rows. The
+  // platform owns the actual decision and will refuse anything that does not qualify.
+  const candidates = ((queue && queue.tickets) || []).filter((t) => {
+    const holder = t.assignedTo || t.routedAgentId;
+    if (!holder || String(holder).includes('@')) return false;
+    if (t.awaitingResponseSince) return false;
+    const touched = Date.parse(t.updatedAt || t.claimedAt || t.assignedAt || '');
+    return Number.isFinite(touched) && touched < cutoff;
+  });
+
+  if (!candidates.length) {
+    console.log('No abandoned tickets under account ' + accountId + ' (agent-held, untouched for ' +
+      staleHours + 'h). ' + (((queue && queue.tickets) || []).length) + ' accepted/in_progress ticket(s) checked.');
+    return;
+  }
+
+  console.log((apply ? 'Reclaiming ' : 'Would reclaim ') + candidates.length + ' abandoned ticket(s) — ' +
+    'agent-held, no live session, untouched for ' + staleHours + 'h:');
+  console.log('');
+  let done = 0;
+  for (const t of candidates) {
+    const id = String(t.ticketId || t.id);
+    const line = '  ' + id.padStart(6) + '  ' + String(t.status || '').padEnd(13) +
+      String(t.assignedTo || t.routedAgentId || '').slice(0, 16).padEnd(18) +
+      String(t.subject || '').slice(0, 52);
+    if (!apply) {
+      console.log(line);
+      continue;
+    }
+    try {
+      await buildAxios(context.baseUrl, context.session.token, 30000)
+        .post('/cli/ticket', {
+          action: 'reclaim', ticketId: id, accountId: Number(t.accountId) || undefined,
+          dataMode: context.dataMode, staleHours, reason: flags.reason || undefined
+        });
+      done += 1;
+      console.log(line + '   -> open');
+    } catch (err) {
+      const body = err && err.response && err.response.data;
+      // A refusal is the platform re-checking against the document and disagreeing with this listing.
+      // That is the guard working, so it is reported per ticket rather than failing the run.
+      console.log(line + '   -> refused: ' + ((body && body.message) || describeError(err)).slice(0, 90));
+    }
+  }
+  console.log('');
+  console.log(apply
+    ? (done + ' reclaimed and back in the queue; an idle supervisor will sweep them.')
+    : 'Dry run. Re-run with --apply to reclaim these.');
+}
+
+/**
+ * Raise a ticket.
+ *
+ * <p>The verb a worker needs when it finds a SECOND problem. Without it the only options were to widen the
+ * ticket it was given until the record no longer described one piece of work, or to drop the finding.</p>
+ */
+async function ticketCreateCommand(flags) {
+  const local = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, local);
+  const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
+  if (!Number.isFinite(accountId) || accountId <= 0) {
+    throw new Error('ticket create needs --account-id (or run it from an account repo).');
+  }
+  if (!flags.subject) {
+    throw new Error('ticket create needs --subject "..." and --type defect|question|task|incident|enhancement.');
+  }
+
+  let response;
+  try {
+    response = await buildAxios(context.baseUrl, context.session.token, 30000)
+      .post('/cli/ticketCreate', {
+        accountId,
+        dataMode: context.dataMode,
+        subject: flags.subject,
+        description: flags.description || flags.body,
+        type: flags.type || 'defect',
+        priority: flags.priority,
+        source: flags.source,
+        workstream: flags.workstream,
+        affectedComponent: flags['affected-component'] || flags.affectedComponent,
+        implementationAccountId: flags['implementation-account-id'] || flags.implementationAccountId,
+        // A deterministic key makes this get-or-create, which is what stops a swept fleet raising the
+        // same follow-up once per worker.
+        referenceId: flags['reference-id'] || flags.referenceId,
+        tags: flags.tags ? String(flags.tags).split(',').map((v) => v.trim()).filter(Boolean) : undefined,
+        agentId: flags['agent-id'] || process.env.REMITS_AGENT_ID || undefined
+      }).then((r) => r.data);
+  } catch (err) {
+    const body = err && err.response && err.response.data;
+    if (body && body.message) {
+      console.error('Refused: ' + body.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  const t = (response && response.ticket) || {};
+  console.log('created ticket ' + response.ticketId + ' on account ' + response.accountId +
+    ' [' + (t.status || 'open') + ']');
+  console.log('  ' + (t.subject || flags.subject));
+}
+
+/** The account a ticket belongs to, so routing does not make the caller look it up by hand. */
+async function resolveTicketAccountId(context, ticketId) {
+  const read = await buildAxios(context.baseUrl, context.session.token, 20000)
+    .post('/cli/ticket', { action: 'read', ticketId, dataMode: context.dataMode })
+    .then((r) => r.data)
+    .catch(() => null);
+  const accountId = Number(read && read.ticket && read.ticket.accountId);
+  if (!Number.isFinite(accountId) || accountId <= 0) {
+    throw new Error('Could not resolve the owning account for ticket ' + ticketId + '. Pass --account-id.');
+  }
+  return accountId;
+}
+
+function printTicketHelp() {
+  console.log('Usage: remits-cli ticket <action> --ticket ID');
+  console.log('');
+  console.log('  queue [--account-id ID] [--status open,accepted] [--unrouted] [--search "..."]');
+  console.log('      What else is open. Read it BEFORE deciding your ticket is unique — the same fix often');
+  console.log('      appears a dozen times, and the "repo" column is the account the edit lease excludes');
+  console.log('      on, so it also tells you which of these can be worked at the same time.');
+  console.log('      Also: --priority --type --workstream --assigned-to --unassigned --board-stage');
+  console.log('            --planned-in --blocked-by --sort-by --sort-direction --limit --json');
+  console.log('      --awaiting-response lists only tickets parked on a human. A status filter cannot');
+  console.log('      ask that: `ask` parks a ticket in pending_review, which also means "done, review me".');
+  console.log('  create --subject "..." --type defect|question|task|incident|enhancement');
+  console.log('      Raise a ticket. Use it when you find a SECOND problem while working one — file it');
+  console.log('      rather than widening the ticket you were given. [--priority --description --tags');
+  console.log('      --workstream --affected-component --implementation-account-id --reference-id]');
+  console.log('      --reference-id makes it get-or-create, so a re-run does not duplicate it.');
+  console.log('');
+  console.log('  read                                  The full ticket record, as JSON.');
+  console.log('  where                                 WHERE this work is happening: repository account,');
+  console.log('      checkout, branch, staging workspace lane, the live edit lease and who holds it, the');
+  console.log('      live claim, and your phase. Read it BEFORE you edit anything — with git worktrees and');
+  console.log('      workspace lanes, two agents on one account can be in completely different trees.');
+  console.log('  accept                                Claim it as yours before you start work.');
+  console.log('  status --status in_progress|pending_review');
+  console.log('  progress --summary "..." [--category investigation|fix|verification|...] [--next-step "..."]');
+  console.log('  complete --resolution "what you found and did"');
+  console.log('  ask --question "..." [--context "..."] [--to WHO]');
+  console.log('      Put a decision to a human and park. Use it when the CHOICE is not yours.');
+  console.log('  answer --message "..." [--route false]   (alias: reply)');
+  console.log('      Answer the open question a previous run asked. By default this re-routes the ticket,');
+  console.log('      so a fresh worker resumes with your answer already in its brief. This is NOT how you');
+  console.log('      talk to the requester — that is `message`. (`reply` means the conversational one in');
+  console.log('      some account tools, so this surface teaches `answer` and keeps `reply` as an alias.)');
+  console.log('  message --message "..." [--to a@x,b@y] [--subject "..."] [--channel email]');
+  console.log('      A PUBLIC conversation entry the requester reads. Writing it does not send it:');
+  console.log('      the record is vendor-agnostic and the account\'s own rule chooses the transport.');
+  console.log('  deliver --channel email --to a@x [--template T] [--subject "..."] [--idempotency-key K]');
+  console.log('      Ask for that entry to actually be SENT. It records an outbox request; an account-owned');
+  console.log('      rule or scheduled Action delivers it and marks the result. Use it when a ticket is');
+  console.log('      waiting on somebody who is not watching the queue.');
+  console.log('  deliveries [--channel email]          What is queued to go out, and what already went.');
+  console.log('  delivered --delivery-id ID  |  delivery-failed --delivery-id ID --reason "..."');
+  console.log('  release [--notes "..."]               Hand it back to the queue.');
+  console.log('  reclaim [--ticket ID | --account-id ID] [--stale-hours 24] [--apply]');
+  console.log('      OPERATOR: take a ticket back from an agent that accepted it and vanished. Such a');
+  console.log('      ticket is invisible to the sweep (it is assigned, so nothing offers it to anyone).');
+  console.log('      Never touches a ticket owned by a person, holding a live claim, or awaiting a reply.');
+  console.log('      Without --ticket it scans the account tree and is a DRY RUN until --apply.');
+  console.log('  reopen | assign --assignee EMAIL');
+  console.log('  route --agent AGENT_ID                 Hand it to a registered agent session.');
+  console.log('  unroute                               Clear its routing, e.g. when that session is gone.');
+  console.log('  tag --tags a,b                        Mark it. The cheapest way to make a cluster of');
+  console.log('      near-identical tickets visible as one cluster to whoever looks next.');
+  console.log('  artifact --type TYPE --label "..." [--url U | --content "..."]');
+  console.log('      Attach evidence — a log, a query result, a repro. Better than pasting it into a');
+  console.log('      worklog summary, where it is neither typed nor retrievable.');
+  console.log('  note --message "..."                  An INTERNAL note. The next worker and a reviewer');
+  console.log('      see it; the requester does not. Use `message` for anything they should read.');
+  console.log('  participant --email E [--role watcher|requester|agent]');
+  console.log('  field --key K --value V               Write the ORGANIZATION\'s own field on the ticket,');
+  console.log('      outside the platform\'s bounded planning slots. Whatever your account models.');
+  console.log('  planning [--workstream V] [--planned-in V] [--board-stage V] [--rank N] [--size V] [--blocked-by V]');
+  console.log('      Update organization-owned planning fields without changing platform lifecycle status.');
+  console.log('      Pass a flag with no value to CLEAR that slot, e.g. --blocked-by');
+  console.log('  force-unlease [--reason "..."]        Break a stale repository lease somebody else holds.');
+  console.log('      For an operator only: unlease returns YOUR lease, this one takes away theirs, and it');
+  console.log('      records a handoff worklog entry on the ticket so the intervention is visible.');
+  console.log('  lease | unlease                       Take or give back the right to EDIT this ticket\'s');
+  console.log('      repository. One agent at a time per account; everyone else investigates read-only.');
+  console.log('      Your run already holds it if the brief said so. Take it when you started read-only');
+  console.log('      and have reached an actual edit. A refusal is not an error — it names who has it,');
+  console.log('      and investigating is still useful work. complete/ask/release free it for you.');
+  console.log('');
+  console.log('  Works on every Remits platform: it reads and writes the platform ticket record, not');
+  console.log('  any one account\'s ticket tooling. Inside a worker, --ticket defaults to the ticket');
+  console.log('  that worker was launched for.');
+}
+
+/**
+ * The run-context fields every call that RECORDS a location sends: checkout, branch, staging workspace.
+ *
+ * One helper so the lease, the claim and the registration cannot describe this process three ways —
+ * the same reason the platform builds the tuple in exactly one class (AgentRunContext).
+ */
+function runContextPayload(flags = {}) {
+  const cwd = process.cwd();
+  return {
+    workingDirectory: cwd,
+    branch: currentBranch(cwd) || undefined,
+    workspace: resolveWorkspace(cwd, flags) || undefined
+  };
+}
+
+/**
+ * WHERE a worker is working — checkout, branch, staging workspace lane — on one line.
+ *
+ * The platform builds the same string server-side (AgentRunContext.describeLocation) for the surfaces it
+ * renders; this is the terminal's copy for rows it prints itself. The workspace is always named, `shared`
+ * when it is the default lane, because "no workspace shown" and "the shared lane" were the same output
+ * and they are opposite facts: the shared lane is exactly the one where concurrent agents overwrite
+ * each other's staged components.
+ */
+function describeRunLocation(record) {
+  if (!record) return '';
+  const dir = record.workingDirectory || record.cwd || record.claimedWorkingDirectory;
+  const branch = record.branch || record.claimedBranch;
+  const workspace = record.workspace || record.claimedWorkspace;
+  if (!dir && !branch && !workspace) return '';
+  const parts = [];
+  if (dir) parts.push(dir);
+  if (branch) parts.push('branch ' + branch);
+  parts.push('workspace ' + (workspace || 'shared'));
+  return parts.join('  ');
+}
+
+/**
+ * The live work map: which repositories are being edited, by whom, and who else is around.
+ *
+ * The question every agent has to answer before it starts — "can I safely edit account 33 right now" —
+ * and the one an operator asks when a queue is not moving. Agents, leases and tickets were each readable
+ * on their own and never together, so every caller invented its own join and they disagreed.
+ */
+async function agentWorkMapCommand(flags) {
+  const agentId = resolveAgentId(flags, { optional: true });
+  const local = agentId ? (listLocalAgents().find((entry) => entry.agentId === agentId) || {}) : {};
+  const context = agentSessionFor(flags, local);
+  const accountId = flags['account-id'] ? Number(flags['account-id']) : Number(context.accountId);
+
+  const response = await buildAxios(context.baseUrl, context.session.token, 30000)
+    .post('/cli/workMap', {
+      agentId,
+      accountId,
+      accountIds: flags['account-ids'] ? String(flags['account-ids']).split(',').map((s) => Number(s.trim())) : undefined,
+      dataMode: context.dataMode,
+      all: flagEnabled(flags.all)
+    }).then((r) => r.data);
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  const repositories = (response && response.repositories) || [];
+  if (!repositories.length) {
+    console.log('No repositories in scope for ' + context.baseUrl + ' (' + context.dataMode + ' lane).');
+    return;
+  }
+  console.log('Work map — ' + context.baseUrl + ' · ' + response.dataMode + ' lane');
+  console.log('');
+  for (const repo of repositories) {
+    const lease = repo.editLease;
+    console.log('  ' + repo.accountName + ' (' + repo.accountId + ')' +
+      (repo.accountType ? '  ' + repo.accountType : ''));
+    if (lease) {
+      const who = lease.agentLabel || lease.agentId;
+      console.log('    EDIT LEASE  ' + who +
+        (lease.ticketId ? '  ticket ' + lease.ticketId : '') +
+        (lease.heldForSeconds != null ? '  held ' + lease.heldForSeconds + 's' : '') +
+        (lease.expiresInSeconds != null ? '  expires in ' + lease.expiresInSeconds + 's' : '') +
+        (repo.editable ? '  (yours)' : ''));
+      // The holder's checkout, branch and staging lane. Without them a refused agent cannot tell a real
+      // file conflict from a holder working in an entirely different worktree.
+      const holderAt = describeRunLocation(lease);
+      if (holderAt) console.log('                ' + holderAt);
+    } else {
+      console.log('    EDIT LEASE  free');
+    }
+    for (const agent of (repo.agents || [])) {
+      // No phase means the session is present but holding nothing. Saying "investigating" there would
+      // report work that is not happening.
+      const phase = agent.phase ? agent.phase.padEnd(13) : 'available    ';
+      console.log('    ' + phase + ' ' +
+        (agent.label || agent.agentId) + '  ' + (agent.state || '?') +
+        (agent.activeTickets && agent.activeTickets.length ? '  tickets ' + agent.activeTickets.join(',') : '') +
+        (agent.secondsSinceSeen != null ? '  seen ' + agent.secondsSinceSeen + 's ago' : ''));
+      const at = describeRunLocation(agent);
+      if (at) console.log('        ' + at);
+      if (agent.activity) console.log('        ' + String(agent.activity).slice(0, 100));
+    }
+    console.log('');
+  }
+  console.log('Only the lease holder may edit or stage a repository. Everyone else investigates read-only.');
+}
+
 async function agentListCommand(flags) {
   const cwd = process.cwd();
   const mine = listLocalAgents()[0] || null;
@@ -6018,7 +8367,8 @@ async function agentListCommand(flags) {
     console.log('No agents are registered for ' + scopeLabel + ' in the ' + context.dataMode + ' lane.');
     return;
   }
-  console.log(agents.length + ' agent(s) available across ' + scopeLabel + ':');
+  console.log(agents.length + ' agent(s) available across ' + scopeLabel +
+    ' in the ' + context.dataMode + ' lane:');
   for (const agent of agents) {
     console.log('');
     console.log('  ' + agent.agentId);
@@ -6026,9 +8376,117 @@ async function agentListCommand(flags) {
     console.log('    state    ' + (agent.state || 'idle') +
       (agent.ticketId ? '  ticket ' + agent.ticketId : '') +
       '   last seen ' + (agent.secondsSinceSeen == null ? '?' : agent.secondsSinceSeen + 's ago'));
+    // The agent's OWN lane, not the query's. --all skips the lane filter for diagnostics, and without
+    // this a test-lane session and a production one render identically in that listing. An agent at
+    // capacity is likewise not routable, which is the other reason an idle-looking agent gets nothing.
+    console.log('    lane     ' + (agent.dataMode || 'prod') +
+      '   capacity ' + (agent.activeTicketCount || 0) + '/' + (agent.maxConcurrent || 1) +
+      (agent.hasCapacity === false ? '  (at capacity — not routable)' : ''));
     if (agent.activity) console.log('    doing    ' + agent.activity);
-    console.log('    where    ' + (agent.host || '?') + ':' + (agent.cwd || '?'));
+    // Through describeRunLocation, which reads BOTH the canonical `workingDirectory` and the historical
+    // `cwd`: a record written by an older platform, or still in Redis from before this field was
+    // canonicalized, must not render as an unknown location.
+    console.log('    where    ' + (agent.host || '?') + ':' +
+      (describeRunLocation(agent) || agent.workingDirectory || agent.cwd || '?'));
+  }
+}
+
+/**
+ * Inspect and correct the local account-repository index — which checkout a ticket for an account is
+ * worked in.
+ *
+ * <p>This index is the one fact the platform cannot supply: it knows the ticket and the account, and
+ * only this machine knows where that account is checked out. It is built by scanning for
+ * `account-info.json`, which is also present in every unpacked zip export, so it can and does acquire
+ * entries that are not checkouts at all. There was no way to see it, and no way to correct it.</p>
+ */
+async function agentReposCommand(flags) {
+  const accountId = Number(flags['account-id'] || flags.accountId);
+  const directory = flags.directory || flags.dir;
+
+  if (Number.isFinite(accountId) && accountId > 0 && directory) {
+    const resolved = path.resolve(String(directory));
+    if (!fs.existsSync(resolved)) {
+      throw new Error('No such directory: ' + resolved);
+    }
+    if (!isAccountCheckout(resolved)) {
+      throw new Error(resolved + ' is not a git checkout. A ticket worker edits, stages and reports ' +
+        'against this directory, so an unpacked export would silently lose the work.');
+    }
+    const info = loadAccountInfo(resolved);
+    const declared = info ? Number(accountIdFromAccountInfo(info)) : null;
+    if (declared && declared !== accountId) {
+      throw new Error(resolved + ' declares account ' + declared + ', not ' + accountId +
+        '. Point account ' + declared + ' at it instead, or pass the directory that belongs to ' + accountId + '.');
+    }
+    const index = readAccountRepoIndex();
+    const previous = index[String(accountId)];
+    index[String(accountId)] = {
+      ...(previous || {}),
+      ...(info ? buildAccountRepoEntryFromInfo(info, resolved, 'manual') : {}),
+      accountId,
+      directory: resolved,
+      source: 'manual',
+      // The operator has just answered the question, so the rival is no longer ambiguity.
+      ambiguousWith: [],
+      updatedAt: new Date().toISOString()
+    };
+    writeAccountRepoIndex(index);
+    console.log('account ' + accountId + ' -> ' + resolved);
+    if (previous && previous.directory && previous.directory !== resolved) {
+      console.log('  (was ' + previous.directory + ')');
+    }
+    return;
+  }
+
+  if (Number.isFinite(accountId) && accountId > 0 && flagEnabled(flags.forget)) {
+    const index = readAccountRepoIndex();
+    const previous = index[String(accountId)];
+    delete index[String(accountId)];
+    writeAccountRepoIndex(index);
+    console.log(previous
+      ? 'account ' + accountId + ' removed (was ' + previous.directory + '). Its tickets will now park ' +
+        'with an explanation rather than being worked in that directory.'
+      : 'account ' + accountId + ' was not in the index.');
+    return;
+  }
+
+  if (flagEnabled(flags.rescan)) {
+    try { discoverAccountRepos(); } catch (err) { console.error('scan failed: ' + describeError(err)); }
+  }
+
+  const entries = listAccountRepoEntries(readAccountRepoIndex())
+    .sort((a, b) => Number(a.accountId) - Number(b.accountId));
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify({ repos: entries, problems: accountRepoIndexProblems() }, null, 2));
+    return;
+  }
+
+  console.log('Account repositories on this machine (' + entries.length + '):');
+  console.log('');
+  for (const entry of entries) {
+    const ok = isAccountCheckout(entry.directory);
+    const missing = !fs.existsSync(entry.directory);
+    const state = missing ? 'MISSING ' : (ok ? 'ok      ' : 'NOT-GIT ');
+    console.log('  ' + state + String(entry.accountId).padStart(5) + '  ' +
+      String(entry.name || '').slice(0, 26).padEnd(26) + '  ' + entry.directory);
+    for (const rival of entry.ambiguousWith || []) {
+      console.log('           also claims this account: ' + rival);
+    }
+  }
+
+  const problems = accountRepoIndexProblems();
+  if (problems.length) {
+    console.log('');
+    console.log(problems.length + ' issue(s):');
+    for (const problem of problems) {
+      console.log('  [' + problem.severity + '] ' + problem.message);
+    }
   }
+  console.log('');
+  console.log('  Set one:    remits-cli agent repos --account-id <id> --directory <path>');
+  console.log('  Remove one: remits-cli agent repos --account-id <id> --forget');
+  console.log('  Rescan:     remits-cli agent repos --rescan');
 }
 
 async function agentReleaseCommand(flags) {
@@ -6038,19 +8496,40 @@ async function agentReleaseCommand(flags) {
     return;
   }
   const local = listLocalAgents().find((entry) => entry.agentId === agentId) || {};
+
+  // Stop the supervisor BEFORE deregistering. The other order is a race the supervisor wins: it sees
+  // registered:false, concludes its record expired, and re-registers the session we just retired.
+  // Its own SIGTERM handler kills any workers and drops their claims, so this is a clean stop.
+  let workersStopped = 0;
+  const daemonPid = local.daemonPid && processIsAlive(local.daemonPid)
+    ? local.daemonPid
+    : findAgentDaemonPid(agentId);
+  if (daemonPid) {
+    workersStopped = listWorkers(agentId).length;
+    try { process.kill(daemonPid, 'SIGTERM'); } catch (_) { /* already gone */ }
+  }
+
   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.');
+  if (workersStopped) {
+    console.log('Stopped ' + workersStopped + ' running ticket worker(s); their claims were released so');
+    console.log('another agent can pick the work up.');
+  }
 }
 
 async function agentCommand(flags, subcommand) {
   switch (subcommand) {
     case 'register': return agentRegisterCommand(flags);
+    case 'serve': case 'start': return agentServeCommand(flags);
+    case 'workers': return agentWorkersCommand(flags);
     case 'status': return agentStatusCommand(flags);
     case 'work': return agentWorkCommand(flags);
     case 'list': case 'ls': return agentListCommand(flags);
+    case 'map': case 'work-map': case 'workmap': return agentWorkMapCommand(flags);
+    case 'repos': case 'repo': return agentReposCommand(flags);
     case 'release': case 'deregister': case 'stop': return agentReleaseCommand(flags);
     case 'heartbeat-daemon': return agentHeartbeatDaemonCommand(flags);
     default:
@@ -6062,8 +8541,23 @@ async function agentCommand(flags, subcommand) {
 function printAgentHelp() {
   console.log('Usage: remits-cli agent <subcommand>');
   console.log('');
+  console.log('  serve [--worker-agent claude|codex|gemini] [--max-concurrent N] [--mode edit|investigate]');
+  console.log('      Run this in a PLAIN TERMINAL TAB — that tab becomes the agent host. It returns');
+  console.log('      immediately; a background supervisor launches ONE fresh headless agent process per');
+  console.log('      routed ticket, in that account\'s repo, and that process exits when the ticket is');
+  console.log('      done. Nothing accumulates context across tickets, so no session needs clearing.');
+  console.log('      Closing the tab stops the agent.');
+  console.log('');
+  console.log('      --worker-agent picks WHICH AI does the work. Without it: whatever agent this');
+  console.log('      session is running (when you start it from inside one), else your');
+  console.log('      `remits-cli config set --agent NAME` default. It prints which it chose and why.');
+  console.log('      --mode investigate runs workers read-only (no file edits).');
+  console.log('');
+  console.log('  workers [--json]                     What this session is running right now.');
+  console.log('');
   console.log('  register [--label NAME] [--data-mode test|prod] [--base-url URL]');
-  console.log('      Make THIS terminal session available to work support tickets. Runs from ANY');
+  console.log('      Presence only — make THIS session routable without starting anything. Use it when a');
+  console.log('      human, or the agent in this very tab, will work the tickets by hand. Runs from ANY');
   console.log('      directory — it registers for every account repo indexed on this machine that your');
   console.log('      user can reach, so you do not have to be inside a particular repo. Defaults to the');
   console.log('      production platform and the prod lane, because a support agent works real tickets.');
@@ -6078,6 +8572,15 @@ function printAgentHelp() {
   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('  map  [--account-ids 1,4] [--json]    Who is EDITING which repository right now.');
+  console.log('      One agent at a time may edit an account\'s repo (the edit lease); everyone else');
+  console.log('      investigates read-only. Check this before starting work that changes files.');
+  console.log('  repos [--rescan] [--json]            WHERE each account is checked out on this machine —');
+  console.log('      the one fact the platform cannot supply, and what decides the directory a ticket');
+  console.log('      worker is launched into. Flags anything that is not a git checkout (an unpacked');
+  console.log('      export looks identical to the scanner) and any account claimed by two checkouts.');
+  console.log('      Correct it with --account-id <id> --directory <path>, or --account-id <id> --forget');
+  console.log('      to make that account\'s tickets park instead of being worked somewhere wrong.');
   console.log('  release                              Deregister this session immediately.');
   console.log('');
   console.log('  After `register`, the other subcommands need no flags: they reuse the platform, lane');
@@ -6502,24 +9005,31 @@ function printComponentsHelp(subcommand) {
     return;
   }
   if (subcommand === 'stage' || subcommand === 'push') {
-    console.log('Usage: remits-cli components stage [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--json|--verbose]');
+    console.log('Usage: remits-cli components stage [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--changed-only] [--data-mode test|prod] [--json|--verbose]');
     console.log('');
     console.log('Stages local component files into the Redis staging cache. It never writes the database or git.');
     console.log('Terminal output separates local working-tree component deltas from the full materialized staging cache count.');
+    console.log('');
+    console.log('  --workspace NAME   stage into an isolated lane on this branch (see `remits-cli workspace`).');
+    console.log('  --changed-only     stage only the components this working tree edited, and do NOT reconcile');
+    console.log('                     (entries for untouched components are left alone rather than deleted).');
     return;
   }
   if (subcommand === 'status') {
-    console.log('Usage: remits-cli components status [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE --component-id ID] [--json|--verbose]');
+    console.log('Usage: remits-cli components status [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--component-type TYPE --component-id ID] [--json|--verbose]');
     console.log('');
     console.log('Shows staged entries and whether this checkout resolves/writes trunk or a variant branch.');
+    console.log('Also lists every OTHER staging lane on this branch for this account/user, so you can see');
+    console.log('whether another agent is staging alongside you.');
     return;
   }
   if (subcommand === 'clear') {
-    console.log('Usage: remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
+    console.log('Usage: remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
     console.log('');
     console.log('Clears staged Redis entries without touching the database or git.');
     console.log('Use --component-type with --component-id when the id could exist in multiple component families.');
     console.log('Use --all for the temporary-experiment cleanup flow.');
+    console.log('--all is scoped to YOUR workspace lane; it never clears another lane on the same branch.');
     return;
   }
   if (subcommand === 'commit') {
@@ -6530,6 +9040,9 @@ function printComponentsHelp(subcommand) {
     return;
   }
   console.log('Usage: remits-cli components <stage|status|clear|sync|commit|promotion|branches|branch>');
+  console.log('');
+  console.log('All staging subcommands accept --workspace NAME to isolate a lane on the same branch,');
+  console.log('so several agents can iterate at once. See: remits-cli workspace --help');
   console.log('  remits-cli components stage [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--json|--verbose]');
   console.log('  remits-cli components status [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE --component-id ID] [--json|--verbose]');
   console.log('  remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
@@ -6576,8 +9089,16 @@ function printToolHelp() {
   console.log('Usage: remits-cli tool --name <toolName> [--base-url URL] [--account-id ID] [--branch BRANCH] [--input "{...}"|--input-file file.json] [--data-mode test|prod] [--variant-branch NAME|none] [--timeout-ms 60000] [--async true --wait true]');
   console.log('       remits-cli tool status --call-id <callId> [--base-url URL] [--account-id ID] [--data-mode test|prod]');
   console.log('');
+  console.log('Hierarchy scope (read/discovery tools) — you do NOT need the owning child account id:');
+  console.log('  --scope self|children|hierarchy   expand from the repo account when searching');
+  console.log('  --target-account-id ID            the exact account to act on (required by writes)');
+  console.log('  --account-ids 1,2,3               an explicit bounded list of owner accounts');
+  console.log('  --anchor-account-id ID            disambiguate the path for a multi-parent account');
+  console.log('  These are merged into --input; a value already in --input wins.');
+  console.log('');
   console.log('Examples:');
   console.log('  remits-cli tool --name mcp_firestore_search --input-file query.json --data-mode prod');
+  console.log('  remits-cli tool --name mcp_firestore_search --input \'{"collection":"statements","documentId":"1234"}\' --scope children');
   console.log('  remits-cli tool --name mcp_run_action --input \'{"accountId":49,"actionId":200,"executionMode":"async"}\' --data-mode prod');
   console.log('');
   console.log('For mcp_run_action and mcp_run_agent, prefer the tool\'s own executionMode:"async" and poll with that tool\'s controlAction:"status".');
@@ -6623,7 +9144,7 @@ async function main() {
   try { updateAccountRepoIndex(process.cwd()); } catch (_) { /* not in account repo */ }
   // 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' || command === 'agent';
+  const isLifecycleCmd = command === 'listen' || command === 'start' || command === 'stop' || command === 'status' || command === 'whoami' || command === 'agent' || command === 'ticket';
   const isHelpCmd = !command || command === 'help' || command === '--help' || wantsHelp;
   if (!wantsJson && !isHelpCmd && !isLifecycleCmd && !isListenerRunning()) {
     try {
@@ -6654,6 +9175,7 @@ async function main() {
     console.log('  remits-cli agent work [--wait SECONDS]                              # 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 map [--account-ids 1,4] [--json]                   # who is EDITING what, where, right now');
     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');
@@ -6663,11 +9185,12 @@ async function main() {
     console.log('  remits-cli data-mode [set test|prod]');
     console.log('  remits-cli install --skills [--target codex|claude|gemini|all] [--overwrite true]');
     console.log('  remits-cli tools [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--variant-branch NAME|none]');
-    console.log('  remits-cli tool --name <toolName> [--base-url URL] [--branch BRANCH] [--input \"{...}\"|--input-file file.json] [--data-mode test|prod] [--variant-branch NAME|none] [--timeout-ms 60000] [--async true --wait true]');
+    console.log('  remits-cli tool --name <toolName> [--base-url URL] [--branch BRANCH] [--input \"{...}\"|--input-file file.json] [--data-mode test|prod] [--scope self|children|hierarchy] [--target-account-id ID] [--account-ids 1,2,3] [--variant-branch NAME|none] [--timeout-ms 60000] [--async true --wait true]');
     console.log('  remits-cli tool status --call-id <callId> [--base-url URL] [--account-id ID] [--data-mode test|prod]');
-    console.log('  remits-cli components stage [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--json|--verbose]');
-    console.log('  remits-cli components status [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE --component-id ID] [--json|--verbose]');
-    console.log('  remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
+    console.log('  remits-cli workspace [show|use <name>|use --auto|clear]        # isolate staging when several agents share a repo');
+    console.log('  remits-cli components stage [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--changed-only] [--data-mode test|prod] [--json|--verbose]');
+    console.log('  remits-cli components status [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--component-type TYPE --component-id ID] [--json|--verbose]');
+    console.log('  remits-cli components clear [--base-url URL] [--account-id ID] [--branch BRANCH] [--workspace NAME] [--component-type TYPE] [--component-id ID] [--all] [--json|--verbose]');
     console.log('  remits-cli components sync [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary]');
     console.log('  remits-cli components commit [--message \"msg\"] [--allow-empty true|false] [--skip-git true|false] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones]');
     console.log('  remits-cli components promotion [<branch>] [--json] [--no-fail]  # promotion readiness + ordered next steps');
@@ -6688,6 +9211,34 @@ async function main() {
     process.exit(0);
   }
 
+  if (wantsHelp && (command === 'workspace' || command === 'ws')) {
+    console.log('Usage: remits-cli workspace [show | use <name> | use --auto | clear]');
+    console.log('');
+    console.log('A WORKSPACE is an optional second isolation axis for staging, alongside the git branch.');
+    console.log('Staging is keyed by (account, cli user, branch, workspace) — and account and user are fixed');
+    console.log('for a given repo, so without a workspace the branch is the ONLY axis. That is why two coding');
+    console.log('agents in two worktrees of the same branch overwrite each other: `components stage` uploads');
+    console.log('the whole repo and replaces the lane wholesale.');
+    console.log('');
+    console.log('A workspace isolates staging WITHOUT changing anything else:');
+    console.log('  - a commit still targets the same branch and the same owner account');
+    console.log('  - the run still resolves whatever committed ComponentVariant branch the account subscribes to');
+    console.log('  - only which staged entries shadow them changes');
+    console.log('');
+    console.log('Typical setup, one worktree per agent, all on the same branch:');
+    console.log('  git worktree add ../ms-agent-a forked');
+    console.log('  cd ../ms-agent-a && remits-cli workspace use --auto');
+    console.log('  remits-cli components stage          # isolated lane; nobody else sees it');
+    console.log('  remits-cli test run --test 42        # resolves this lane over the forked variants');
+    console.log('  remits-cli token --path /page/x      # its own browser token, in this lane');
+    console.log('');
+    console.log('Precedence: --workspace  >  REMITS_WORKSPACE  >  .remits-cli/workspace  >  shared default lane');
+    console.log('Use --no-workspace on a single command to target the shared lane without clearing the file.');
+    console.log('');
+    console.log('`.remits-cli/workspace` is per-checkout and gitignored, so a worktree keeps its own lane.');
+    process.exit(0);
+  }
+
   if (wantsHelp && command === 'test') {
     printTestHelp();
     process.exit(0);
@@ -6813,11 +9364,25 @@ async function main() {
     return;
   }
 
+  if (command === 'ticket') {
+    if (wantsHelp || !subcommand) {
+      printTicketHelp();
+      process.exit(0);
+    }
+    await ticketCommand(args, subcommand);
+    return;
+  }
+
   if (command === 'install') {
     await installSkillsCommand(args);
     return;
   }
 
+  if (command === 'workspace' || command === 'ws') {
+    await workspaceCommand(args);
+    return;
+  }
+
   if (command === 'test' && subcommand === 'run') {
     await testCommand(args);
     return;