@remits/remits-cli 0.1.146 → 0.1.149

package/index.js

@@ -4,18 +4,18 @@
 ## Table of Contents
 
 - L22  Runtime Bootstrap And Shared State
-- L123  Sessions, Account Resolution, And Production Guards
-- L615  Local State, Workspaces, And Verification Evidence
-- L2652  Account Repos, Guide Sync, And Platform Repo
-- L3460  Component Discovery And HTTP Logging
-- L4107  Skill Delivery And TOC Resolution
-- L4417  Auth And Component Staging
-- L5032  Component Summaries, Status, And Sync Gates
-- L7332  Branches, Promotion, Commit, And Test Runs
-- L9421  Tokens, Tools, Verification, And Config
-- L10848  Service Dashboard And WebSocket Listener
-- L13313  Agent And Ticket Workflows
-- L16908  Help, Auto Update, And Command Dispatch
+- L124  Sessions, Account Resolution, And Production Guards
+- L621  Local State, Workspaces, And Verification Evidence
+- L2659  Account Repos, Guide Sync, And Platform Repo
+- L3499  Component Discovery And HTTP Logging
+- L4225  Skill Delivery And TOC Resolution
+- L4540  Auth And Component Staging
+- L5172  Component Summaries, Status, And Sync Gates
+- L7473  Branches, Promotion, Commit, And Test Runs
+- L9562  Tokens, Tools, Verification, And Config
+- L10989  Service Dashboard And WebSocket Listener
+- L13467  Agent And Ticket Workflows
+- L17602  Help, Auto Update, And Command Dispatch
 */
 
 /*
@@ -49,6 +49,7 @@ const SESSIONS_FILE = path.join(SESSION_DIR, 'sessions.json');
 const CONFIG_FILE = path.join(SESSION_DIR, 'config.json');
 const LISTENER_PID_FILE = path.join(SESSION_DIR, 'listener.pid');
 const ACTIVITY_LOG_FILE = path.join(SESSION_DIR, 'activity.log');
+const GUIDES_CACHE_FILE = path.join(SESSION_DIR, 'guides-cache.json');
 const SKILL_SOURCE_DIR = path.join(__dirname, 'skills', 'remits-cli');
 const SKILL_SOURCE_FILE = path.join(SKILL_SOURCE_DIR, 'SKILL.md');
 const SKILL_REFERENCES_DIRNAME = 'references';
@@ -154,6 +155,11 @@ function parseArgs(argv) {
   return out;
 }
 
+// A flag's text, or '' — a bare `--role` with no value parses as `true`, which is not a value.
+function textFlag(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
 function flagEnabled(value) {
   return value === true || value === 'true' || value === '1' || value === 'yes';
 }
@@ -634,6 +640,7 @@ function localStatePaths(cwd) {
     sharedDir: path.join(base, 'shared'),
     toolsDir: path.join(base, 'shared', 'tools'),
     workstreamsDir: path.join(base, 'shared', 'workstreams'),
+    componentStageCacheFile: path.join(base, 'shared', 'component-stage-cache.json'),
     sessionsDir: path.join(actorDir, 'sessions'),
     toolResponsesDir: path.join(actorDir, 'tool-responses'),
     verificationDir: path.join(actorDir, 'verification'),
@@ -2805,6 +2812,31 @@ function writeGuidePayloadIntoRepo(repoDir, payload) {
 // invocation that touches multiple repos only fetches guides once.
 let GUIDES_PAYLOAD_CACHE = null;
 
+function readGuidesPayloadCache(cacheKey) {
+  try {
+    if (!fs.existsSync(GUIDES_CACHE_FILE)) return null;
+    const cached = JSON.parse(fs.readFileSync(GUIDES_CACHE_FILE, 'utf8'));
+    if (!cached || cached.key !== cacheKey || !cached.payload || !cached.guideHash) return null;
+    return cached;
+  } catch (_) {
+    return null;
+  }
+}
+
+function writeGuidesPayloadCache(cacheKey, payload) {
+  if (!payload || !payload.guideHash) return;
+  try {
+    atomicWriteFile(GUIDES_CACHE_FILE, JSON.stringify({
+      key: cacheKey,
+      guideHash: payload.guideHash,
+      payload,
+      updatedAt: new Date().toISOString()
+    }, null, 2));
+  } catch (_) {
+    // Best-effort: the in-process cache still covers this invocation.
+  }
+}
+
 async function fetchGuidesPayload(cwd, ctx) {
   const baseUrl = normalizeBaseUrl((ctx && ctx.baseUrl) || DEFAULT_BASE_URL);
   const token = ctx && ctx.session && ctx.session.token;
@@ -2815,21 +2847,28 @@ async function fetchGuidesPayload(cwd, ctx) {
   if (GUIDES_PAYLOAD_CACHE && GUIDES_PAYLOAD_CACHE.key === cacheKey) {
     return GUIDES_PAYLOAD_CACHE.payload;
   }
+  const diskCache = readGuidesPayloadCache(cacheKey);
   const api = buildAxios(baseUrl, token);
   let data = null;
   try {
     data = await loggedPost(api, cwd, '/cli/guides', {
       token,
-      accountId: (ctx && ctx.accountId) || undefined
+      accountId: (ctx && ctx.accountId) || undefined,
+      guideHash: diskCache && diskCache.guideHash ? diskCache.guideHash : undefined
     }).then((r) => r.data);
   } catch (_) {
     // Best-effort: never fail a command because guides could not be fetched.
     return null;
   }
+  if (data && data.notModified && diskCache && diskCache.payload) {
+    GUIDES_PAYLOAD_CACHE = { key: cacheKey, payload: diskCache.payload };
+    return diskCache.payload;
+  }
   if (!data || !data.success) {
     return null;
   }
   GUIDES_PAYLOAD_CACHE = { key: cacheKey, payload: data };
+  writeGuidesPayloadCache(cacheKey, data);
   return data;
 }
 
@@ -3672,6 +3711,79 @@ function collectComponents(cwd) {
   return canonicalized.components;
 }
 
+const STAGE_CONTENT_FIELDS = ['source', 'prompt', 'html', 'javascript', 'schema', 'inputSchema', 'previewData', 'messages'];
+
+function componentStageCacheKey(baseUrl, accountId, branchName, workspace, dataMode) {
+  return [normalizeBaseUrl(baseUrl || DEFAULT_BASE_URL), accountId || '', branchName || '', workspace || '', normalizeDataMode(dataMode)].join('|');
+}
+
+function readComponentStageCache(cwd) {
+  const file = localStatePaths(cwd).componentStageCacheFile;
+  try {
+    if (!fs.existsSync(file)) return {};
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeComponentStageCache(cwd, cache) {
+  try {
+    atomicWriteFile(localStatePaths(cwd).componentStageCacheFile, JSON.stringify(cache || {}, null, 2));
+  } catch (_) {
+    // Best-effort. A missed cache only means the next stage sends full content.
+  }
+}
+
+function slimComponentsForStage(cwd, components, world) {
+  const cache = readComponentStageCache(cwd);
+  const worldKey = componentStageCacheKey(world.baseUrl, world.accountId, world.branchName, world.workspace, world.dataMode);
+  const worldCache = cache[worldKey] && typeof cache[worldKey] === 'object' ? cache[worldKey] : {};
+  let omittedComponents = 0;
+  let omittedFields = 0;
+  let omittedBytes = 0;
+  const slim = (components || []).map((component) => {
+    const identity = stageIdentityKey(component);
+    const cached = worldCache[identity];
+    if (!cached || cached.hash !== component.hash) {
+      return component;
+    }
+    const omitted = [];
+    const next = Object.assign({}, component);
+    for (const field of STAGE_CONTENT_FIELDS) {
+      if (typeof next[field] === 'string') {
+        omitted.push(field);
+        omittedBytes += Buffer.byteLength(next[field], 'utf8');
+        delete next[field];
+      }
+    }
+    if (omitted.length) {
+      next.omittedContentFields = omitted;
+      omittedComponents += 1;
+      omittedFields += omitted.length;
+      return next;
+    }
+    return component;
+  });
+  return { components: slim, stats: { omittedComponents, omittedFields, omittedBytes } };
+}
+
+function rememberSuccessfulComponentStage(cwd, components, world) {
+  const cache = readComponentStageCache(cwd);
+  const worldKey = componentStageCacheKey(world.baseUrl, world.accountId, world.branchName, world.workspace, world.dataMode);
+  const worldCache = {};
+  for (const component of components || []) {
+    if (!component || !component.hash) continue;
+    worldCache[stageIdentityKey(component)] = {
+      hash: component.hash,
+      updatedAt: new Date().toISOString()
+    };
+  }
+  cache[worldKey] = worldCache;
+  writeComponentStageCache(cwd, cache);
+}
+
 function componentPathInfo(cwd, filePath) {
   const mapping = {
     schemas: 'schema',
@@ -3868,6 +3980,12 @@ function buildAxios(baseUrl, token, timeoutMs = 60000) {
   // diagnostics it is missing exist, and every output improvement lands invisibly.
   const cliVersion = readCliVersion();
   if (cliVersion) headers['X-Remits-Cli-Version'] = cliVersion;
+  // A worker's run identity rides on every call, so a verb whose payload does not repeat it (stage, commit,
+  // a tool) is still attributed to the run. The ROLE is deliberately not sent: the platform reads it from
+  // the session's registration, where the user's permission to declare it was checked.
+  if (process.env.REMITS_AGENT_ID) headers['X-Remits-Agent-Id'] = process.env.REMITS_AGENT_ID;
+  if (process.env.REMITS_WORKER_RUN_ID) headers['X-Remits-Run-Id'] = process.env.REMITS_WORKER_RUN_ID;
+  if (process.env.REMITS_SUPPORT_TICKET_ID) headers['X-Remits-Ticket-Id'] = process.env.REMITS_SUPPORT_TICKET_ID;
   return axios.create({ baseURL: baseUrl, timeout: parsePositiveInt(timeoutMs, 60000), headers });
 }
 
@@ -4274,16 +4392,21 @@ function resolveSkillTargets(target) {
     gemini: {
       skillPath: path.join(home, '.gemini', 'skills', 'remits-cli.md'),
       referencesDir: path.join(home, '.gemini', 'skills', 'remits-cli', SKILL_REFERENCES_DIRNAME)
+    },
+    antigravity: {
+      skillPath: path.join(home, '.gemini', 'config', 'skills', 'remits-cli', 'SKILL.md'),
+      referencesDir: path.join(home, '.gemini', 'config', 'skills', 'remits-cli', SKILL_REFERENCES_DIRNAME)
     }
   };
 
   if (value === 'all') {
     return Object.entries(targets);
   }
-  if (!targets[value]) {
-    throw new Error('Unknown --target value: ' + target + ' (expected codex|claude|gemini|all)');
+  const resolved = value === 'agy' ? 'antigravity' : value;
+  if (!targets[resolved]) {
+    throw new Error('Unknown --target value: ' + target + ' (expected codex|claude|gemini|antigravity|all)');
   }
-  return [[value, targets[value]]];
+  return [[resolved, targets[resolved]]];
 }
 
 function listSkillReferenceSources() {
@@ -4737,6 +4860,7 @@ async function pushComponentsCommand(flags) {
     packetType: 'stage',
     world: { repoAccountId: accountId, accountId, executionAccountId: accountId, dataMode, branchName, workspace }
   }, { command: 'components stage' });
+  const slimStage = slimComponentsForStage(cwd, components, { baseUrl, accountId, branchName, workspace, dataMode });
   const stagePayload = {
     token: session.token,
     accountId,
@@ -4768,13 +4892,20 @@ async function pushComponentsCommand(flags) {
     baseSha: safeGitValue(cwd, 'git rev-parse HEAD') || undefined,
     // Kept for a platform that predates stageMode. Same meaning it always had.
     replace: !changedOnly,
-    components
+    components: slimStage.components,
+    omittedContentStats: slimStage.stats
   };
 
   let response;
   try {
     response = await stageOrRefuse(api, cwd, stagePayload);
   } catch (err) {
+    if (err && err.responseBody && err.responseBody.code === 'missing_omitted_content' &&
+        stagePayload.components !== components) {
+      stagePayload.components = components;
+      stagePayload.omittedContentStats = Object.assign({}, slimStage.stats, { retriedFull: true });
+      response = await stageOrRefuse(api, cwd, stagePayload);
+    } else {
     // A REFUSED stage is evidence too. Recording it only on the success path is how a lane ends up with
     // an envelope that says nothing happened between two packets, when in fact a stage was attempted and
     // the platform rejected it. The packet is best-effort: a failing stage must surface the STAGE error,
@@ -4803,6 +4934,7 @@ async function pushComponentsCommand(flags) {
       console.error('Could not record the refused-stage verification packet: ' + packetError.message);
     }
     throw err;
+    }
   }
   response.changedFromWorkingTree = changedFromWorkingTree || [];
   response.changedFromWorkingTreeAvailable = changedFromWorkingTree !== null;
@@ -4810,12 +4942,14 @@ async function pushComponentsCommand(flags) {
   response.unrepresentableChanges = unstageable;
   response.componentDiscoveryWarnings = componentDiscoveryWarnings;
   response.localState = localStateSummary(cwd, flags);
+  response.omittedContentStats = stagePayload.omittedContentStats || slimStage.stats;
   if (response.success === false) {
     // A 200 that says `success:false`. The 422 path throws out of stageOrRefuse above and never lands
     // here, so this stays as the belt-and-braces case — print whatever detail came with it first.
     printCompileValidation(response.compileValidation, { stderr: true });
     throw new Error(response.message || 'Server stage failed');
   }
+  rememberSuccessfulComponentStage(cwd, components, { baseUrl, accountId, branchName, workspace, dataMode });
 
   await appendVerificationPacket(api, cwd, session, accountId, verification.evidenceFlags, {
     type: 'stage',
@@ -4993,6 +5127,12 @@ async function stageOrRefuse(api, cwd, payload) {
   } catch (err) {
     const body = err && err.response && err.response.data;
     const status = err && err.response && err.response.status;
+    if (status === 409 && body && body.code === 'missing_omitted_content') {
+      const retryable = new Error(body.message || 'Server needs full component bodies for this staging lane.');
+      retryable.responseBody = body;
+      retryable.status = status;
+      throw retryable;
+    }
     if (status === 409 && body && body.message) {
       if (body.editLease) {
         console.error('Edit lease: ' + describeRunLocation(body.editLease));
@@ -6239,7 +6379,8 @@ async function syncComponentsCommand(rawFlags) {
   const dataMode = resolveDataMode(flags, session);
   const forceTombstones = flagEnabled(flags['force-tombstones']) || flagEnabled(flags.forceTombstones);
   const dryRun = flagEnabled(flags['dry-run']) || flagEnabled(flags.dryRun);
-  const api = buildAxios(baseUrl, session.token);
+  const timeoutMs = parsePositiveInt(flags['timeout-ms'] || flags.timeoutMs, 60000);
+  const api = buildAxios(baseUrl, session.token, timeoutMs);
   // Aligned for the same reason a stage is: the server's plan names a `new_` component by its sidecar
   // `name:`, and the changed set would otherwise name it by its filename and the gate would refuse it.
   const changedFromWorkingTree = alignChangedSetWithComponents(changedComponentsFromWorkingTree(cwd), collectComponentsForIdentity(cwd));
@@ -11669,6 +11810,54 @@ function compactSupportTicketRow(row) {
   };
 }
 
+function supportTicketQueueScopeSet(queue) {
+  return new Set((queue && queue.searchedAccounts || [])
+    .map((entry) => String(entry.accountId || entry.accountScope || ''))
+    .filter(Boolean));
+}
+
+function independentSupportTicketQueues(queues) {
+  const scoped = (queues || []).map((queue) => supportTicketQueueScopeSet(queue));
+  return (queues || []).filter((queue, i) => {
+    if (!scoped[i].size) {
+      return true;   // nothing reported: cannot prove overlap, so keep it and report honestly below
+    }
+    return !(queues || []).some((other, j) => {
+      if (i === j || !scoped[j].size) return false;
+      const contained = [...scoped[i]].every((id) => scoped[j].has(id));
+      if (!contained) return false;
+      // Identical scopes: keep the earlier one, drop the later, or both would drop each other.
+      const identical = scoped[i].size === scoped[j].size;
+      return identical ? j < i : true;
+    });
+  });
+}
+
+function supportTicketCompartmentGroups(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) => {
+    const independent = independentSupportTicketQueues(group.queues);
+    const ticketsById = {};
+    for (const queue of independent) {
+      for (const ticket of queue.tickets || []) {
+        const id = String(ticket.ticketId || ticket.id || '');
+        if (!id || ticketsById[id]) continue;
+        ticketsById[id] = { ...ticket, queueAccountId: queue.accountId, baseUrl: queue.baseUrl,
+                            dataMode: queue.dataMode, compartment: group.compartment };
+      }
+    }
+    return { ...group, independent, tickets: Object.values(ticketsById) };
+  });
+}
+
 /**
  * The support-ticket queue for one authenticated session.
  *
@@ -11853,44 +12042,9 @@ async function collectAgentSnapshot() {
  * </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);
+  return supportTicketCompartmentGroups(queues).map((group) => {
+    const independent = group.independent;
+    const tickets = group.tickets;
 
     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);
@@ -12855,7 +13009,7 @@ async function handleCliCloneRequest(client, baseUrl, topic, accountIds, userIds
       console.warn('[cli_clone_request] Guide sync failed:', gErr.message);
     }
 
-    // 4. Install / refresh agent skills for Claude, Codex, Gemini
+    // 4. Install / refresh agent skills for Claude, Codex, Gemini, Antigravity
     try {
       syncInstalledSkills('all');
     } catch (_) {}
@@ -14056,6 +14210,8 @@ async function agentRegisterCommand(flags, options = {}) {
       'the pid whose exit should end this agent session.');
   }
   const explicitId = (flags['agent-id'] || flags.agentId || process.env.REMITS_AGENT_ID || '').trim();
+  const explicitRole = textFlag(flags.role) || textFlag(options.serve && options.serve.role) || textFlag(process.env.REMITS_AGENT_ROLE);
+  const explicitPersona = textFlag(flags.persona) || textFlag(options.serve && options.serve.persona) || textFlag(process.env.REMITS_AGENT_PERSONA);
   // Adopt a previous registration only for THIS terminal. Matching on (cwd, anchorPid) alone was enough
   // to let an unrelated record be adopted whenever two registrations shared an anchor.
   const existingId = explicitId ||
@@ -14066,6 +14222,8 @@ async function agentRegisterCommand(flags, options = {}) {
   const api = buildAxios(baseUrl, session.token, 15000);
   const payload = {
     agentId: existingId || undefined,
+    role: explicitRole || explicitPersona || undefined,
+    persona: explicitPersona || undefined,
     label: flags.label || agentLabelDefault(anchor, cwd),
     agentType: flags.agent || getPreferredAgent(),
     cliVersion: readCliVersion(),
@@ -14110,6 +14268,8 @@ async function agentRegisterCommand(flags, options = {}) {
     cwd,
     baseUrl,
     dataMode,
+    role: response.role || payload.role || null,
+    persona: response.persona || payload.persona || null,
     // The accounts the platform ACCEPTED, so `agent list` can scope itself to the work this session
     // can actually be routed rather than to whichever session happened to be most recent.
     accountIds: response.accountIds || [],
@@ -14133,6 +14293,8 @@ async function agentRegisterCommand(flags, options = {}) {
       entry.mode = options.serve.mode;
       entry.serves = options.serve.serves || [];
       entry.maxConcurrent = options.serve.maxConcurrent;
+      entry.role = options.serve.role || entry.role;
+      entry.persona = options.serve.persona || entry.persona;
     }
     rememberLocalAgent(entry);
   }
@@ -14145,6 +14307,9 @@ async function agentRegisterCommand(flags, options = {}) {
   const accepted = response.accountIds || [];
   console.log('Registered as a support agent: ' + response.agentId);
   console.log('  label      ' + payload.label);
+  if (response.role || payload.role) {
+    console.log('  role       ' + (response.role || payload.role) + (response.persona ? '  (persona: ' + response.persona + ')' : ''));
+  }
   console.log('  platform   ' + baseUrl);
   console.log('  data lane  ' + dataMode + (dataMode === 'prod' ? '  (live support tickets)' : '  (fixtures only)'));
   console.log('  accounts   ' + accepted.length + ' account(s) this session can be routed work for');
@@ -14166,6 +14331,9 @@ async function agentRegisterCommand(flags, options = {}) {
     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);
+    if (serve.role) {
+      console.log('  role       ' + serve.role + (serve.persona && serve.persona !== serve.role ? '  (persona: ' + serve.persona + ')' : ''));
+    }
     console.log('  capacity   ' + serve.maxConcurrent + ' ticket(s) at a time');
     console.log('  serves     ' + ((serve.serves && serve.serves.length)
       ? serve.serves.join(', ') + '  (only these workstreams are routed here, and only these are swept)'
@@ -14214,6 +14382,12 @@ async function agentServeCommand(flags) {
   const mode = String(flags.mode || (flagEnabled(flags['investigate-only']) ? 'investigate' : 'edit'))
     .toLowerCase() === 'investigate' ? 'investigate' : 'edit';
   const serves = parseServedWorkstreams(flags.serves);
+  const role = textFlag(flags.role) || textFlag(flags.persona) || textFlag(process.env.REMITS_AGENT_ROLE);
+  const persona = textFlag(flags.persona) || textFlag(process.env.REMITS_AGENT_PERSONA);
+  if (role || persona) {
+    console.log('');
+    console.log('Serving as role: ' + (role || persona) + (persona && persona !== role ? ' (persona: ' + persona + ')' : ''));
+  }
   if (serves.length) {
     console.log('');
     console.log('Serving workstreams: ' + serves.join(', '));
@@ -14259,6 +14433,8 @@ async function agentServeCommand(flags) {
       workerAgentWhy: choice.why,
       mode,
       serves,
+      role: role || persona || null,
+      persona: persona || null,
       maxConcurrent: Math.max(1, parsePositiveInt(flags['max-concurrent'], 1))
     }
   });
@@ -14368,6 +14544,12 @@ function startAgentHeartbeatDaemon(entry, serve = null) {
     '--base-url', entry.baseUrl,
     '--cwd', entry.cwd
   ];
+  if (entry.role) {
+    args.push('--role', entry.role);
+  }
+  if (entry.persona) {
+    args.push('--persona', entry.persona);
+  }
   if (serve) {
     args.push(
       '--serve', 'true',
@@ -14381,6 +14563,12 @@ function startAgentHeartbeatDaemon(entry, serve = null) {
     if (serve.serves && serve.serves.length) {
       args.push('--serves', serve.serves.join(','));
     }
+    if (serve.role && !entry.role) {
+      args.push('--role', serve.role);
+    }
+    if (serve.persona && !entry.persona) {
+      args.push('--persona', serve.persona);
+    }
   }
   const child = spawn(process.execPath, args, { detached: true, stdio: 'ignore', env: { ...process.env } });
   child.unref();
@@ -14389,6 +14577,8 @@ function startAgentHeartbeatDaemon(entry, serve = null) {
     anchorPid: entry.anchorPid,
     heartbeatPid: child.pid,
     serving: !!serve,
+    role: entry.role || (serve ? serve.role : null),
+    persona: entry.persona || (serve ? serve.persona : null),
     workerAgent: serve ? serve.workerAgent : null,
     mode: serve ? serve.mode : null,
     maxConcurrent: serve ? serve.maxConcurrent : null
@@ -14869,6 +15059,8 @@ async function agentHeartbeatDaemonCommand(flags) {
   process.env.REMITS_AGENT_ANCHOR_PID = String(anchorPid);
 
   const serving = flagEnabled(flags.serve);
+  const role = textFlag(flags.role) || textFlag(process.env.REMITS_AGENT_ROLE);
+  const persona = textFlag(flags.persona) || textFlag(process.env.REMITS_AGENT_PERSONA);
   const ctx = {
     agentId,
     cwd,
@@ -14878,6 +15070,8 @@ async function agentHeartbeatDaemonCommand(flags) {
     mode: String(flags.mode || 'edit').toLowerCase() === 'investigate' ? 'investigate' : 'edit',
     serves: parseServedWorkstreams(flags.serves),
     maxConcurrent: Math.max(1, parsePositiveInt(flags['max-concurrent'], 1)),
+    role: role || persona || null,
+    persona: persona || null,
     runId: 'run-' + Date.now().toString(36)
   };
   const inFlight = new Map();
@@ -15035,6 +15229,8 @@ async function agentHeartbeatDaemonCommand(flags) {
             'agent-id': agentId,
             'base-url': context.baseUrl,
             'max-concurrent': String(ctx.maxConcurrent),
+            role: ctx.role || undefined,
+            persona: ctx.persona || undefined,
             json: 'true'
           },
           // Re-register with THIS supervisor's declared bound and queues. The platform treats an absent
@@ -15042,14 +15238,21 @@ async function agentHeartbeatDaemonCommand(flags) {
           // here: this path runs precisely because the record EXPIRED, so there is nothing left to be
           // unchanged from, and a specialised machine would come back as a generalist that can edit.
           { spawnHeartbeat: false,
-            serve: { mode: ctx.mode, serves: ctx.serves, maxConcurrent: ctx.maxConcurrent } }
+            serve: { mode: ctx.mode, serves: ctx.serves, maxConcurrent: ctx.maxConcurrent, role: ctx.role, persona: ctx.persona } }
         ).catch((err) => {
           appendGlobalActivityLog('agent', 'heartbeat.reregister_failed',
             { agentId, error: describeError(err) }, 'error');
         });
       }
     } catch (err) {
-      appendGlobalActivityLog('agent', 'heartbeat.failed', { agentId, error: describeError(err) }, 'error');
+      // A refusal is the platform saying this user may no longer run this session as declared (a role,
+      // workstream or autonomy was revoked). Recorded as itself so it is not read as a network blip.
+      const body = err && err.response && err.response.data;
+      if (err && err.response && err.response.status === 403 && body && body.refused) {
+        appendGlobalActivityLog('agent', 'serve.refused', { agentId, message: body.message }, 'error');
+      } else {
+        appendGlobalActivityLog('agent', 'heartbeat.failed', { agentId, error: describeError(err) }, 'error');
+      }
     }
 
     const interval = !serving
@@ -15077,6 +15280,9 @@ async function agentStatusCommand(flags) {
   if (flags.ticket || flags['ticket-id']) update.ticketId = String(flags.ticket || flags['ticket-id']);
   if (flags.step) update.step = String(flags.step);
   if (flags.detail) update.detail = String(flags.detail);
+  if (flags.role || flags.persona) {
+    throw new Error('A session\'s role is fixed when it registers. Re-register with `remits-cli agent register --role ROLE`.');
+  }
 
   // Reporting a ticket without a state is unambiguous: you are working it.
   if (update.ticketId && !update.state) update.state = 'working';
@@ -15098,6 +15304,7 @@ async function agentStatusCommand(flags) {
   // `||` binds looser than `+`, so writing this as one expression prints only the state and silently
   // drops the ticket and activity — the two things the caller just set.
   const parts = [agent.state || 'idle'];
+  if (agent.role) parts.push('role: ' + agent.role);
   if (agent.ticketId) parts.push('ticket ' + agent.ticketId);
   if (agent.activity) parts.push(agent.activity);
   console.log(parts.join('  '));
@@ -15428,6 +15635,336 @@ async function ticketCommand(flags, subcommand) {
   }
 }
 
+function csvFlag(value) {
+  if (!value) return undefined;
+  const parts = Array.isArray(value) ? value : [value];
+  const values = parts.flatMap((part) => String(part).split(',').map((v) => v.trim()).filter(Boolean));
+  return values.length ? values : undefined;
+}
+
+function buildTicketQueueRequestPayload(flags, accountId, dataMode, defaultLimit = 25) {
+  return {
+    accountId,
+    dataMode,
+    statuses: csvFlag(flags.status || flags.statuses),
+    priorities: csvFlag(flags.priority || flags.priorities),
+    types: csvFlag(flags.type || flags.types),
+    sources: csvFlag(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,
+    implementationAccountId: flags['implementation-account-id'] || flags.implementationAccountId,
+    plannedIn: flags['planned-in'] || flags.plannedIn,
+    boardStage: flags['board-stage'] || flags.boardStage,
+    size: flags.size,
+    blockedBy: flags['blocked-by'] || flags.blockedBy,
+    rank: flags.rank,
+    minRank: flags['min-rank'] || flags.minRank,
+    maxRank: flags['max-rank'] || flags.maxRank,
+    search: flags.search || flags.q,
+    // Every one of these reads a field the platform already mirrored and already projected, and that
+    // no surface could ask about. `syncState` in particular is how a broken integration is found:
+    // a failed sync retries forever, so it sits in pendingSync looking exactly like a healthy one.
+    syncStates: csvFlag(flags['sync-state'] || flags.syncState),
+    overdue: flagEnabled(flags.overdue) || undefined,
+    relatedTo: flags['related-to'] || flags.relatedTo,
+    duplicateOf: flags['duplicate-of'] || flags.duplicateOf,
+    causedBy: flags['caused-by'] || flags.causedBy,
+    hasCause: flagEnabled(flags['has-cause'] || flags.hasCause) || undefined,
+    dueBefore: flags['due-before'] || flags.dueBefore,
+    dueAfter: flags['due-after'] || flags.dueAfter,
+    requiresRepositoryWork: firstDefined(flags['repo-work'], flags['requires-repository-work']),
+    // "Which tickets has the fleet already tried and handed back." A mirrored field with no filter is a
+    // mirrored field nobody can act on — the same defect awaitingResponse and externalSyncState each had.
+    minAutonomousRuns: parsePositiveInt(flags['min-runs'] || flags.minRuns, 0) || undefined,
+    sortBy: flags['sort-by'] || flags.sortBy,
+    sortDirection: flags['sort-direction'] || flags.sortDirection,
+    includeChildren: flags['include-children'] === 'false' ? false : undefined,
+    limit: parsePositiveInt(flags.limit, defaultLimit)
+  };
+}
+
+function ticketActivityMs(ticket) {
+  for (const value of [
+    ticket && ticket.updatedAt,
+    ticket && ticket.updated,
+    ticket && ticket.lastActivityAt,
+    ticket && ticket.activityAt,
+    ticket && ticket.claimedAt,
+    ticket && ticket.assignedAt,
+    ticket && ticket.createdAt
+  ]) {
+    const parsed = Date.parse(value || '');
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+
+function ticketQueueLocalFilter(flags) {
+  const inactiveDays = parsePositiveInt(firstDefined(
+    flags['inactive-days'], flags.inactiveDays, flags['stale-days'], flags.staleDays
+  ), 0);
+  if (inactiveDays) {
+    const cutoffMs = Date.now() - inactiveDays * 24 * 60 * 60 * 1000;
+    return {
+      type: 'inactive-days',
+      cutoffMs,
+      description: 'inactive for at least ' + inactiveDays + ' day(s)',
+      inactiveDays
+    };
+  }
+
+  const before = firstDefined(flags['updated-before'], flags.updatedBefore, flags['inactive-before'], flags.inactiveBefore);
+  if (before) {
+    const cutoffMs = Date.parse(String(before));
+    if (!Number.isFinite(cutoffMs)) {
+      throw new Error('--updated-before expects an ISO date/time or YYYY-MM-DD.');
+    }
+    return {
+      type: 'updated-before',
+      cutoffMs,
+      description: 'updated before ' + new Date(cutoffMs).toISOString(),
+      updatedBefore: new Date(cutoffMs).toISOString()
+    };
+  }
+  return null;
+}
+
+function decorateTicketQueueRows(tickets) {
+  const nowMs = Date.now();
+  return (tickets || []).map((ticket) => {
+    const touchedMs = ticketActivityMs(ticket);
+    return {
+      ...ticket,
+      inactiveDays: Number.isFinite(touchedMs) ? Math.floor((nowMs - touchedMs) / (24 * 60 * 60 * 1000)) : null
+    };
+  });
+}
+
+function recomputeTicketQueueCounts(tickets) {
+  const counts = {
+    total: (tickets || []).length,
+    routed: 0,
+    unrouted: 0,
+    assigned: 0,
+    unassigned: 0,
+    awaitingResponse: 0,
+    needsHuman: 0
+  };
+  for (const ticket of tickets || []) {
+    if (ticket.routedAgentId || ticket.routedAgentLabel) counts.routed += 1;
+    else counts.unrouted += 1;
+    if (ticket.assignedTo) counts.assigned += 1;
+    else counts.unassigned += 1;
+    if (ticket.awaitingResponseSince) counts.awaitingResponse += 1;
+    if (ticket.needsHuman || ticket.autonomousRunLimitReached || ticket.humanRequired) counts.needsHuman += 1;
+  }
+  return counts;
+}
+
+function withTicketQueueLocalFilters(response, flags) {
+  const localFilter = ticketQueueLocalFilter(flags);
+  if (!localFilter) return response;
+  const originalTickets = Array.isArray(response && response.tickets) ? response.tickets : [];
+  const tickets = originalTickets.filter((ticket) => {
+    const touchedMs = ticketActivityMs(ticket);
+    return Number.isFinite(touchedMs) && touchedMs < localFilter.cutoffMs;
+  });
+  return {
+    ...(response || {}),
+    tickets,
+    count: tickets.length,
+    totalCount: tickets.length,
+    totalCountBeforeLocalFilters: response && response.totalCount != null ? response.totalCount : originalTickets.length,
+    localFilters: {
+      inactiveBefore: new Date(localFilter.cutoffMs).toISOString(),
+      description: localFilter.description,
+      pageScoped: true
+    },
+    counts: recomputeTicketQueueCounts(tickets)
+  };
+}
+
+async function fetchTicketQueueForAccount(context, accountId, flags, defaultLimit) {
+  const response = await buildAxios(context.baseUrl, context.session.token, 30000)
+    .post('/cli/tickets', buildTicketQueueRequestPayload(flags, accountId, context.dataMode, defaultLimit))
+    .then((r) => r.data);
+  const tickets = Array.isArray(response && response.tickets) ? decorateTicketQueueRows(response.tickets) : [];
+  return withTicketQueueLocalFilters({
+    ...(response || {}),
+    baseUrl: context.baseUrl,
+    accountId,
+    dataMode: (response && response.dataMode) || context.dataMode,
+    compartment: context.baseUrl + ' · ' + ((response && response.dataMode) || context.dataMode) + ' lane',
+    tickets,
+    searchedAccounts: (response && response.accounts) || []
+  }, flags);
+}
+
+function globalTicketQueueAccountEntries(flags, context) {
+  const ids = csvFlag(flags['account-ids'] || flags.accountIds);
+  const wanted = ids ? new Set(ids.map((id) => String(Number(id))).filter((id) => id !== 'NaN')) : null;
+  const byId = {};
+  for (const entry of listAccountRepoEntries(readAccountRepoIndex())) {
+    const id = Number(entry.accountId);
+    if (!Number.isFinite(id) || id <= 0) continue;
+    if (wanted && !wanted.has(String(id))) continue;
+    if (!byId[String(id)]) byId[String(id)] = { ...entry, accountId: id };
+  }
+  if (!Object.keys(byId).length && context && context.accountId) {
+    byId[String(context.accountId)] = {
+      accountId: Number(context.accountId),
+      name: (context.session && context.session.account && context.session.account.name) || null,
+      source: 'session'
+    };
+  }
+  const breadth = (entry) => {
+    const type = String(entry.type || '').toUpperCase();
+    if (type === 'PLATFORM') return 0;
+    if (type === 'PRODUCT') return 1;
+    return 2;
+  };
+  return Object.values(byId).sort((a, b) => breadth(a) - breadth(b) || Number(a.accountId) - Number(b.accountId));
+}
+
+function aggregateGlobalTicketQueues(queues) {
+  const compartments = supportTicketCompartmentGroups(queues);
+  const tickets = compartments.flatMap((group) => group.tickets.map((ticket) => ({
+    ...ticket,
+    compartment: group.compartment
+  })));
+  return {
+    compartments: compartments.map((group) => ({
+      compartment: group.compartment,
+      baseUrl: group.baseUrl,
+      dataMode: group.dataMode,
+      queueCount: group.independent.length,
+      overlappingQueuesDropped: group.queues.length - group.independent.length,
+      scopeUnknown: group.independent.some((queue) => !(queue.searchedAccounts || []).length),
+      retrievedCount: group.tickets.length,
+      accounts: group.independent.map((queue) => ({
+        accountId: queue.accountId,
+        open: Number(queue.totalCount || 0),
+        scanned: (queue.searchedAccounts || []).length
+      }))
+    })),
+    tickets
+  };
+}
+
+function printTicketQueueRows(tickets) {
+  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.inactiveDays != null ? 'inactive ' + t.inactiveDays + 'd' : '',
+      t.awaitingResponseSince ? 'WAITING ON A HUMAN' : '',
+      t.autonomousRuns > 1 ? 'run ' + t.autonomousRuns + ' by workers' : '',
+      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('   '));
+  }
+}
+
+async function ticketGlobalQueueCommand(flags) {
+  const local = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, local);
+  const entries = globalTicketQueueAccountEntries(flags, context);
+  if (!entries.length) {
+    throw new Error('ticket queue --all-accounts needs indexed account repos. Run `remits-cli agent repos --rescan`.');
+  }
+
+  const queues = [];
+  const errors = [];
+  const defaultLimit = parsePositiveInt(flags.limit, 500);
+  const concurrency = Math.min(Math.max(parsePositiveInt(flags.concurrency, 4), 1), 8);
+  let cursor = 0;
+  async function worker() {
+    while (cursor < entries.length) {
+      const entry = entries[cursor++];
+      try {
+        const queue = await fetchTicketQueueForAccount(context, Number(entry.accountId), flags, defaultLimit);
+        queues.push({
+          ...queue,
+          accountName: entry.name || queue.accountName || null
+        });
+      } catch (err) {
+        errors.push({
+          accountId: Number(entry.accountId),
+          accountName: entry.name || null,
+          message: describeError(err)
+        });
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, entries.length) }, () => worker()));
+
+  const aggregate = aggregateGlobalTicketQueues(queues);
+  const tickets = decorateTicketQueueRows(aggregate.tickets)
+    .sort((a, b) => (ticketActivityMs(b) || 0) - (ticketActivityMs(a) || 0));
+  const counts = recomputeTicketQueueCounts(tickets);
+  const response = {
+    success: queues.length > 0,
+    partial: errors.length > 0,
+    global: true,
+    baseUrl: context.baseUrl,
+    dataMode: context.dataMode,
+    accountCount: entries.length,
+    queueCount: queues.length,
+    errorCount: errors.length,
+    totalCount: tickets.length,
+    counts,
+    localFilters: queues.find((queue) => queue.localFilters)?.localFilters || undefined,
+    compartments: aggregate.compartments,
+    accountErrors: errors,
+    tickets
+  };
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  if (!tickets.length) {
+    console.log('No tickets match across ' + entries.length + ' indexed account queue(s). [' +
+      context.dataMode + ' lane]');
+    if (errors.length) {
+      console.log(errors.length + ' account queue(s) could not be read; use --json for details.');
+    }
+    return;
+  }
+  console.log(tickets.length + ' unique ticket(s) across ' + queues.length + '/' + entries.length +
+    ' account queue(s) — ' + (counts.unrouted || 0) + ' unrouted, ' + (counts.unassigned || 0) +
+    ' unassigned, ' + (counts.awaitingResponse || 0) + ' waiting on a human' +
+    ((counts.needsHuman || 0) ? ', ' + counts.needsHuman + ' NEEDS A PERSON' : '') +
+    '   [' + context.dataMode + ' lane]');
+  if (response.localFilters) {
+    console.log('  local filter: ' + response.localFilters.description +
+      ' (applied to retrieved rows; raise --limit if a root queue was truncated)');
+  }
+  if (errors.length) {
+    console.log('  ' + errors.length + ' account queue(s) could not be read; use --json for details.');
+  }
+  console.log('');
+  printTicketQueueRows(tickets);
+}
+
 /**
  * The ticket queue — what else is open, and what it looks like as a whole.
  *
@@ -15441,6 +15978,10 @@ async function ticketCommand(flags, subcommand) {
  * was the local dashboard.</p>
  */
 async function ticketQueueCommand(flags) {
+  if (flagEnabled(flags['all-accounts']) || flagEnabled(flags.allAccounts) || flagEnabled(flags.global)) {
+    return ticketGlobalQueueCommand(flags);
+  }
+
   const local = listLocalAgents()[0] || null;
   const context = agentSessionFor(flags, local);
   const accountId = Number(flags['account-id'] || flags.accountId || context.accountId);
@@ -15448,46 +15989,7 @@ async function ticketQueueCommand(flags) {
     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,
-      // Every one of these reads a field the platform already mirrored and already projected, and that
-      // no surface could ask about. `syncState` in particular is how a broken integration is found:
-      // a failed sync retries forever, so it sits in pendingSync looking exactly like a healthy one.
-      syncStates: csv(flags['sync-state'] || flags.syncState),
-      overdue: flagEnabled(flags.overdue) || undefined,
-      relatedTo: flags['related-to'] || flags.relatedTo,
-      duplicateOf: flags['duplicate-of'] || flags.duplicateOf,
-      causedBy: flags['caused-by'] || flags.causedBy,
-      hasCause: flagEnabled(flags['has-cause'] || flags.hasCause) || undefined,
-      dueBefore: flags['due-before'] || flags.dueBefore,
-      dueAfter: flags['due-after'] || flags.dueAfter,
-      // "Which tickets has the fleet already tried and handed back." A mirrored field with no filter is a
-      // mirrored field nobody can act on — the same defect awaitingResponse and externalSyncState each had.
-      minAutonomousRuns: parsePositiveInt(flags['min-runs'] || flags.minRuns, 0) || undefined,
-      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);
+  const response = await fetchTicketQueueForAccount(context, accountId, flags, 25);
 
   if (flagEnabled(flags.json)) {
     console.log(JSON.stringify(response, null, 2));
@@ -15512,30 +16014,12 @@ async function ticketQueueCommand(flags) {
       'and are no longer offered to workers.');
     console.log('  Find them: remits-cli ticket queue --min-runs 1 --unassigned    (then answer, reopen, or route one by hand)');
   }
-  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' : '',
-      t.autonomousRuns > 1 ? 'run ' + t.autonomousRuns + ' by workers' : '',
-      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.localFilters) {
+    console.log('  local filter: ' + response.localFilters.description +
+      ' (applied to retrieved rows; raise --limit if the queue was truncated)');
   }
+  console.log('');
+  printTicketQueueRows(tickets);
   if (response.totalCount > tickets.length) {
     console.log('');
     console.log('  showing ' + tickets.length + ' of ' + response.totalCount + ' — raise --limit to see more');
@@ -15690,12 +16174,16 @@ async function resolveTicketAccountId(context, ticketId) {
 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('  queue [--account-id ID|--all-accounts] [--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('      --all-accounts scans indexed account repos, includes descendants, drops overlapping');
+  console.log('      child queues, and keeps per-account read failures in --json instead of aborting.');
+  console.log('      Add --account-ids 4,11 to narrow a sweep, or --inactive-days N /');
+  console.log('      --updated-before YYYY-MM-DD to list stale cleanup candidates.');
   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('      --overdue lists tickets past a due time their account committed to; --sort-by due');
@@ -15827,8 +16315,10 @@ function describeAgentScope(record) {
   if (!record) return null;
   const serves = Array.isArray(record.serves) ? record.serves.filter(Boolean) : [];
   const readOnly = record.mode === 'investigate' || record.canEdit === false;
-  if (!serves.length && !readOnly) return null;
+  const role = record.role || record.persona;
+  if (!serves.length && !readOnly && !role) return null;
   const parts = [];
+  if (role) parts.push('role: ' + role + (record.persona && record.persona !== role ? ' [' + record.persona + ']' : ''));
   parts.push(serves.length ? 'serves ' + serves.join(', ') : 'serves every workstream');
   parts.push(readOnly ? 'investigate only (never edits or stages)' : 'may edit');
   return parts.join('  ·  ');
@@ -16594,6 +17084,203 @@ async function agentReleaseCommand(flags) {
   }
 }
 
+async function agentPruneWorktreesCommand(flags) {
+  const dryRun = flagEnabled(flags['dry-run']) || flagEnabled(flags.dryRun);
+  const force = flagEnabled(flags.force);
+  const accountIdFilter = flags['account-id'] ? Number(flags['account-id']) : null;
+
+  try { updateAccountRepoIndex(process.cwd()); } catch (_) {}
+  try { discoverAccountRepos(); } catch (_) {}
+
+  const candidateDirs = new Set();
+  const cwdIdentity = accountCheckoutIdentity(process.cwd());
+  if (fs.existsSync(process.cwd()) &&
+      (!accountIdFilter || (cwdIdentity && cwdIdentity.accountId === accountIdFilter))) {
+    candidateDirs.add(path.resolve(process.cwd()));
+  }
+  try {
+    for (const entry of listAccountRepoEntries(readAccountRepoIndex())) {
+      if (entry && entry.directory && fs.existsSync(entry.directory)) {
+        if (accountIdFilter && Number(entry.accountId) !== accountIdFilter) {
+          continue;
+        }
+        candidateDirs.add(path.resolve(entry.directory));
+      }
+    }
+  } catch (_) {}
+
+  const workerStore = readWorkerStore();
+  const isTicketActive = (ticketId) => {
+    if (!ticketId) return false;
+    for (const agentWorkers of Object.values(workerStore.agents || {})) {
+      const worker = agentWorkers[ticketId];
+      if (worker && worker.pid && processIsAlive(worker.pid)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const results = [];
+  for (const baseDir of candidateDirs) {
+    const worktreeRoot = path.join(baseDir, '.remits-cli', TICKET_WORKTREE_DIRNAME);
+    if (!fs.existsSync(worktreeRoot)) {
+      continue;
+    }
+    let subdirs = [];
+    try {
+      subdirs = fs.readdirSync(worktreeRoot, { withFileTypes: true });
+    } catch (_) {
+      continue;
+    }
+
+    for (const dirent of subdirs) {
+      if (!dirent.isDirectory()) continue;
+      const folderName = dirent.name;
+      const worktreePath = path.join(worktreeRoot, folderName);
+      const ticketId = folderName.startsWith('ticket-') ? folderName.replace(/^ticket-/, '') : folderName;
+
+      if (isTicketActive(ticketId)) {
+        results.push({
+          baseDir,
+          worktreePath,
+          ticketId,
+          status: 'skipped',
+          reason: 'active_worker_process'
+        });
+        continue;
+      }
+
+      // Safety is decided from what git ANSWERS, never from its silence: a worktree git cannot report on
+      // is left alone, because removing it is the one outcome that cannot be undone.
+      let isDirty = false;
+      let unreachable = false;
+      try {
+        // Inside the launch checkout, a directory that is NOT its own worktree answers with the PARENT
+        // repository's status — a clean answer about the wrong tree.
+        const topLevel = execSync('git rev-parse --show-toplevel', { cwd: worktreePath, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        if (fs.realpathSync(topLevel) !== fs.realpathSync(worktreePath)) {
+          results.push({ baseDir, worktreePath, ticketId, status: 'skipped', reason: 'not_a_worktree' });
+          continue;
+        }
+        const status = execSync('git status --porcelain', { cwd: worktreePath, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        isDirty = status.length > 0;
+        // Commits no branch, tag or remote-tracking ref holds — a worker on a detached HEAD that committed
+        // and never pushed. Removing the worktree removes the only name they have, and --force does not
+        // override this: those commits are work, not scratch.
+        const orphaned = execSync('git rev-list --max-count=1 HEAD --not --branches --tags --remotes',
+          { cwd: worktreePath, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        unreachable = orphaned.length > 0;
+      } catch (_) {
+        results.push({ baseDir, worktreePath, ticketId, status: 'skipped', reason: 'git_status_unreadable' });
+        continue;
+      }
+
+      if (unreachable) {
+        results.push({ baseDir, worktreePath, ticketId, status: 'skipped', reason: 'unpushed_commits' });
+        continue;
+      }
+
+      if (isDirty && !force) {
+        results.push({
+          baseDir,
+          worktreePath,
+          ticketId,
+          status: 'skipped',
+          reason: 'uncommitted_changes'
+        });
+        continue;
+      }
+
+      if (dryRun) {
+        results.push({
+          baseDir,
+          worktreePath,
+          ticketId,
+          status: 'would_prune',
+          dirty: isDirty
+        });
+        continue;
+      }
+
+      let removed = false;
+      let error = null;
+      try {
+        execSync('git worktree remove --force ' + shellQuote(worktreePath), { cwd: baseDir, stdio: ['ignore', 'ignore', 'ignore'] });
+        removed = true;
+      } catch (_) {}
+
+      if (fs.existsSync(worktreePath)) {
+        try {
+          fs.rmSync(worktreePath, { recursive: true, force: true });
+          removed = true;
+        } catch (err) {
+          error = describeError(err);
+        }
+      }
+
+      try {
+        execSync('git worktree prune', { cwd: baseDir, stdio: ['ignore', 'ignore', 'ignore'] });
+      } catch (_) {}
+
+      if (removed) {
+        results.push({
+          baseDir,
+          worktreePath,
+          ticketId,
+          status: 'pruned',
+          dirty: isDirty
+        });
+      } else {
+        results.push({
+          baseDir,
+          worktreePath,
+          ticketId,
+          status: 'failed',
+          error: error || 'Could not remove directory'
+        });
+      }
+    }
+
+    try {
+      execSync('git worktree prune', { cwd: baseDir, stdio: ['ignore', 'ignore', 'ignore'] });
+    } catch (_) {}
+  }
+
+  if (flagEnabled(flags.json)) {
+    console.log(JSON.stringify({ dryRun, results }, null, 2));
+    return;
+  }
+
+  if (!results.length) {
+    console.log('No ticket worktrees found to prune.');
+    return;
+  }
+
+  const pruned = results.filter((r) => r.status === 'pruned' || r.status === 'would_prune');
+  const skipped = results.filter((r) => r.status === 'skipped');
+  const failed = results.filter((r) => r.status === 'failed');
+
+  console.log((dryRun ? 'DRY RUN: ' : '') + 'Worktree prune results:');
+  for (const item of results) {
+    const label = item.status === 'pruned' ? 'PRUNED'
+      : item.status === 'would_prune' ? 'WOULD PRUNE'
+      : item.status === 'skipped' ? 'SKIPPED (' + item.reason + ')'
+      : 'FAILED (' + (item.error || 'unknown') + ')';
+    console.log('  [' + label + '] ' + item.worktreePath + ' (ticket ' + item.ticketId + ')');
+  }
+  console.log('');
+  console.log('Summary: ' + pruned.length + ' ' + (dryRun ? 'eligible' : 'pruned') + ', ' +
+    skipped.length + ' skipped, ' + failed.length + ' failed.');
+  if (skipped.some((s) => s.reason === 'uncommitted_changes')) {
+    console.log('Tip: pass --force to remove worktrees with uncommitted changes.');
+  }
+  if (skipped.some((s) => s.reason === 'unpushed_commits')) {
+    console.log('Worktrees holding commits no branch or remote has are never removed. Push them, or give');
+    console.log('them a branch (git -C <worktree> branch <name>), then prune again.');
+  }
+}
+
 async function agentCommand(flags, subcommand) {
   switch (subcommand) {
     case 'register': return agentRegisterCommand(flags);
@@ -16606,6 +17293,7 @@ async function agentCommand(flags, subcommand) {
     case 'inspect': case 'activity': return activityInspectCommand(flags);
     case 'repos': case 'repo': return agentReposCommand(flags);
     case 'release': case 'deregister': case 'stop': return agentReleaseCommand(flags);
+    case 'prune-worktrees': case 'prune': return agentPruneWorktreesCommand(flags);
     case 'heartbeat-daemon': return agentHeartbeatDaemonCommand(flags);
     default:
       printAgentHelp();
@@ -16616,14 +17304,17 @@ 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('        [--serves support,incident,sdlc]');
+  console.log('  serve [--worker-agent claude|codex|gemini] [--role ROLE] [--persona PERSONA]');
+  console.log('        [--max-concurrent N] [--mode edit|investigate] [--serves support,incident,sdlc]');
   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('      --role / --persona declares the session\'s operational role (e.g. developer, triage,');
+  console.log('      release_manager) — opaque names your OPERATIONS remits-policy rules match. Fixed for the');
+  console.log('      life of the session, and limited by your user\'s allowedAgentRoles.');
   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.');
@@ -16638,7 +17329,7 @@ function printAgentHelp() {
   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] [--serves a,b]');
+  console.log('  register [--label NAME] [--role ROLE] [--data-mode test|prod] [--base-url URL] [--serves a,b]');
   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');
@@ -16666,6 +17357,9 @@ function printAgentHelp() {
   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('  prune-worktrees [--account-id ID] [--dry-run] [--force] [--json]');
+  console.log('      Safely removes stale or finished ticket worktrees in .remits-cli/ticket-worktrees.');
+  console.log('      Skips worktrees for active workers and uncommitted changes (unless --force).');
   console.log('  release                              Deregister this session immediately.');
   console.log('');
   console.log('  After `register`, the other subcommands need no flags: they reuse the platform, lane');
@@ -17106,7 +17800,7 @@ function printComponentsHelp(subcommand) {
     return;
   }
   if (subcommand === 'sync') {
-    console.log('Usage: remits-cli components sync [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--create-variant-branch] [--summary] [--json]');
+    console.log('Usage: remits-cli components sync [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--create-variant-branch] [--summary] [--timeout-ms 60000] [--json]');
     console.log('       remits-cli components sync doctor [--json]');
     console.log('');
     console.log('On trunk this reconciles the pushed repository into live component rows.');
@@ -17216,7 +17910,7 @@ function printComponentsHelp(subcommand) {
   console.log('  remits-cli components lanes [--base-url URL] [--account-id ID] [--wait-change [--lane-id ID] [--timeout 600]] [--json]');
   console.log('  remits-cli components entries --lane-id ID [--base-url URL] [--account-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 components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary]');
+  console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000]');
   console.log('  remits-cli components commit [--yes] [--safe] [--message|-m "msg"] [--allow-empty true|false] [--skip-git true|false] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--json [--summary]]');
   console.log('');
   console.log('  --force-tombstones applies only on non-trunk variant syncs, when a missing trunk');
@@ -17457,7 +18151,7 @@ async function main() {
   // then ran `remits-cli agent serve` from a plain tab (the documented way to work tickets, explicitly
   // "no need to be in an account repo") kept the PREVIOUS skill on disk indefinitely: a stale index
   // pointing at reference files that the upgrade had just renamed or removed. Reading and comparing the
-  // whole corpus across all three agent targets measures ~3ms, so there is nothing to save by guarding it.
+  // whole corpus across all four agent targets measures ~3ms, so there is nothing to save by guarding it.
   try { syncInstalledSkills(); } catch (_) { /* best-effort */ }
 
   // Best-effort: update account-repo index whenever running from inside a remits repo
@@ -17512,7 +18206,7 @@ async function main() {
     console.log('  remits-cli guides sync [--all] [--base-url URL] [--json]       # refresh front-stage guides');
     console.log('  remits-cli listen [stop|status] [--foreground true]  # compatibility alias');
     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 install --skills [--target codex|claude|gemini|antigravity|all] [--overwrite true]');
     console.log('  remits-cli tools [--base-url URL] [--account-id ID] [--as-account ID] [--branch BRANCH] [--data-mode test|prod] [--variant-branch NAME|none]');
     console.log('  remits-cli tool --name <toolName> [--base-url URL] [--account-id ID] [--as-account ID] [--target-account ID] [--branch BRANCH] [--input \"{...}\"|--input-file file.json] [--data-mode test|prod] [--scope self|children|hierarchy] [--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]');
@@ -17525,7 +18219,7 @@ async function main() {
     console.log('  remits-cli components lanes [--base-url URL] [--account-id ID] [--json]');
     console.log('  remits-cli components entries --lane-id ID [--base-url URL] [--account-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 [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary]');
+    console.log('  remits-cli components sync [--safe] [--base-url URL] [--account-id ID] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--dry-run] [--summary] [--timeout-ms 60000]');
     console.log('  remits-cli components commit [--yes] [--safe] [--message|-m \"msg\"] [--allow-empty true|false] [--skip-git true|false] [--branch BRANCH] [--data-mode test|prod] [--force-tombstones] [--json [--summary]]');
     console.log('  remits-cli components promotion [<branch>] [--json] [--no-fail]  # promotion readiness + ordered next steps');
     console.log('  remits-cli components branches [--json]                     # committed branch variants for this account');