@remits/remits-cli 0.1.109 → 0.1.110

package/index.js

@@ -5617,13 +5617,37 @@ function resolveAgentId(flags, options = {}) {
   );
 }
 
+/**
+ * The host and lane a support agent registers against when it is told nothing.
+ *
+ * An agent works REAL support tickets, and it must be startable from any directory on the machine —
+ * not only from inside an account repo. So it defaults to the platform host the CLI ships with
+ * (`REMITS_BASE_URL` when set) and to the `prod` lane.
+ *
+ * That is a deliberate exception to the CLI's test-first default, which exists to stop a developer
+ * ITERATING from touching live data. Registering presence mutates no business data, and a test-lane
+ * agent is silently useless for support: it registers, appears online, and can never be routed a
+ * production ticket. Ask for `--data-mode test` when you want a fixture agent.
+ */
+function agentDefaults(flags, entry) {
+  return {
+    baseUrl: normalizeBaseUrl(
+      (flags && flags['base-url']) || (entry && entry.baseUrl) || DEFAULT_BASE_URL),
+    dataMode: normalizeDataMode(
+      (flags && (flags['data-mode'] || flags.dataMode)) || (entry && entry.dataMode) || 'prod')
+  };
+}
+
 function agentSessionFor(flags, entry) {
   const cwd = (entry && entry.cwd) || process.cwd();
+  const defaults = agentDefaults(flags, entry);
   const context = resolveSessionContext(cwd, Object.assign({}, flags, {
-    'base-url': (flags && flags['base-url']) || (entry && entry.baseUrl) || undefined
+    'base-url': defaults.baseUrl,
+    'data-mode': defaults.dataMode
   }));
   if (!context.session || !context.session.token) {
-    throw new Error('No authenticated session. Run: remits-cli auth');
+    throw new Error('No authenticated session for ' + defaults.baseUrl +
+      '. Run: remits-cli auth --base-url ' + defaults.baseUrl);
   }
   // resolveSessionContext names it `resolvedBaseUrl` and resolves no data lane, so normalize both here
   // rather than letting each caller re-derive them. Destructuring `{ baseUrl, dataMode }` off it yields
@@ -5631,8 +5655,8 @@ function agentSessionFor(flags, entry) {
   return {
     session: context.session,
     accountId: context.accountId,
-    baseUrl: normalizeBaseUrl(context.resolvedBaseUrl || (entry && entry.baseUrl) || DEFAULT_BASE_URL),
-    dataMode: resolveDataMode(flags, context.session),
+    baseUrl: defaults.baseUrl,
+    dataMode: defaults.dataMode,
     sessionResolutionWarning: context.sessionResolutionWarning
   };
 }
@@ -5712,6 +5736,9 @@ async function agentRegisterCommand(flags, options = {}) {
     cwd,
     baseUrl,
     dataMode,
+    // 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 || [],
     accountId: Number(session.accountId) || null,
     anchorPid: anchor.pid,
     anchorSource: anchor.source,
@@ -5729,19 +5756,31 @@ async function agentRegisterCommand(flags, options = {}) {
     return;
   }
 
-  console.log('Registered agent ' + response.agentId);
+  const accepted = response.accountIds || [];
+  console.log('Registered as a support agent: ' + response.agentId);
   console.log('  label      ' + payload.label);
-  console.log('  data lane  ' + dataMode + (dataMode === 'prod' ? '  (production data)' : ''));
-  console.log('  accounts   ' + (response.accountIds || []).join(', '));
+  console.log('  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');
+  console.log('             ' + accepted.join(', '));
   console.log('  heartbeat  every ' + Math.round(AGENT_HEARTBEAT_INTERVAL_MS / 1000) + 's, anchored to pid ' +
-    anchor.pid + ' (' + anchor.source + ')');
+    anchor.pid + ' (' + anchor.source + '), ends when this session ends');
   if ((response.skippedAccounts || []).length) {
     console.log('  refused    ' + response.skippedAccounts
       .map((entry) => entry.accountId + ' (' + entry.reason + ')').join(', '));
   }
+  if (dataMode !== 'prod') {
+    console.log('');
+    console.log('NOTE: a ' + dataMode + '-lane agent never receives production tickets. Re-register with');
+    console.log('      --data-mode prod to take real support work.');
+  }
   console.log('');
-  console.log('This session is now available for support tickets. Ask for work with:');
-  console.log('  remits-cli agent work');
+  console.log('You are on duty. The support loop, repeated for as long as you are working:');
+  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('  5. remits-cli agent status --state idle    # then go back to step 1');
 }
 
 function readCliVersion() {
@@ -5946,11 +5985,24 @@ async function agentWorkCommand(flags) {
 
 async function agentListCommand(flags) {
   const cwd = process.cwd();
-  const context = agentSessionFor(flags, null);
-  const accountId = resolvePreferredAccountId(cwd, flags, context.session);
-  const response = await buildAxios(context.baseUrl, context.session.token, 15000)
+  const mine = listLocalAgents()[0] || null;
+  const context = agentSessionFor(flags, mine);
+
+  // An explicit --account-id asks about one account. Otherwise, if this machine has a registered
+  // agent, scope to the accounts it was accepted for — the peers it could actually share work with.
+  // Falling back to "whichever session was most recent" answers a question nobody asked.
+  const explicitAccountId = Number(flags && flags['account-id']);
+  const scopedAccountIds = (!Number.isFinite(explicitAccountId) && mine && Array.isArray(mine.accountIds))
+    ? mine.accountIds
+    : null;
+  const accountId = Number.isFinite(explicitAccountId) && explicitAccountId > 0
+    ? explicitAccountId
+    : (scopedAccountIds ? null : resolvePreferredAccountId(cwd, flags, context.session));
+
+  const response = await buildAxios(context.baseUrl, context.session.token, 20000)
     .post('/cli/agents', {
       accountId,
+      accountIds: scopedAccountIds,
       dataMode: context.dataMode,
       all: flagEnabled(flags.all)
     }).then((r) => r.data);
@@ -5959,12 +6011,14 @@ async function agentListCommand(flags) {
     console.log(JSON.stringify(response, null, 2));
     return;
   }
+  const scopeLabel = accountId ? 'account ' + accountId
+    : (scopedAccountIds ? scopedAccountIds.length + ' account(s) this session covers' : 'your accounts');
   const agents = (response && response.agents) || [];
   if (!agents.length) {
-    console.log('No agents are registered for account ' + accountId + ' in the ' + context.dataMode + ' lane.');
+    console.log('No agents are registered for ' + scopeLabel + ' in the ' + context.dataMode + ' lane.');
     return;
   }
-  console.log(agents.length + ' agent(s) available for account ' + accountId + ':');
+  console.log(agents.length + ' agent(s) available across ' + scopeLabel + ':');
   for (const agent of agents) {
     console.log('');
     console.log('  ' + agent.agentId);
@@ -6008,9 +6062,13 @@ async function agentCommand(flags, subcommand) {
 function printAgentHelp() {
   console.log('Usage: remits-cli agent <subcommand>');
   console.log('');
-  console.log('  register [--label NAME] [--data-mode test|prod] [--account-id ID]');
-  console.log('      Make THIS terminal session available to work support tickets. Starts a heartbeat');
-  console.log('      that ends when this session ends, so a closed tab stops receiving work on its own.');
+  console.log('  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('      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.');
+  console.log('      Starts a heartbeat that ends when this session ends, so a closed tab stops');
+  console.log('      receiving work on its own.');
   console.log('');
   console.log('  work [--wait SECONDS] [--json]');
   console.log('      Ask for the tickets routed to this session. With --wait it keeps asking until');
@@ -6021,6 +6079,9 @@ function printAgentHelp() {
   console.log('');
   console.log('  list [--account-id ID] [--json]      Who else is available for an account.');
   console.log('  release                              Deregister this session immediately.');
+  console.log('');
+  console.log('  After `register`, the other subcommands need no flags: they reuse the platform, lane');
+  console.log('  and identity this session registered with.');
 }
 
 async function listenCommand(flags) {
@@ -6589,8 +6650,8 @@ async function main() {
     console.log('  remits-cli auth [--base-url URL] [--account-id ID] [--port 8765] [--data-mode test|prod]');
     console.log('  remits-cli sessions [list|remove] [--account-id ID] [--base-url URL] [--data-mode test|prod]');
     console.log('  remits-cli config [set] [--agent claude|codex|gemini]');
-    console.log('  remits-cli agent register [--label NAME] [--data-mode test|prod]   # make THIS terminal available for tickets');
-    console.log('  remits-cli agent work [--wait SECONDS] [--json]                     # ask for tickets routed to this session');
+    console.log('  remits-cli agent register                                           # become a support agent (any directory, prod by default)');
+    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 release                                            # stop receiving tickets now');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remits/remits-cli",
-  "version": "0.1.109",
+  "version": "0.1.110",
   "description": "Local CLI for auth, component sync, and live test execution against Remits",
   "license": "MIT",
   "private": false,

package/skills/remits-cli/SKILL.md

@@ -20,6 +20,8 @@ description: Use remits-cli for fast branch-scoped component staging, test execu
 - [Required Local Index Reads](#required-local-index-reads)
 - [Big Picture: How remits-cli State Is Organized](#big-picture-how-remits-cli-state-is-organized)
 - [Support Ticket Mental Model](#support-ticket-mental-model)
+  - [You are an agent, and you register yourself](#you-are-an-agent-and-you-register-yourself)
+  - [The loop](#the-loop)
 - [Efficiency Rules](#efficiency-rules)
 - [Account Repository Index](#account-repository-index)
 - [Two Workflows](#two-workflows)
@@ -460,16 +462,21 @@ workflows, and never one product's view of it.
 
 ### You are an agent, and you register yourself
 
-Work reaches you because **this terminal session registered itself as available**:
+**If the user says anything like "register to become a support agent", run exactly this and nothing
+else first:**
 
 ```bash
-remits-cli agent register            # this tab is now a routable agent
-remits-cli agent work                # ask for the tickets routed to it
+remits-cli agent register
 ```
 
-Three tabs running Claude are three agents. Each is independently routable, each reports its own
-activity, and each stops receiving work when its tab closes — a heartbeat process is anchored to the
-session and dies with it, so a crashed agent and a quit agent look identical to the platform.
+No flags, no setup, **no need to be in an account repo** — run it from wherever the session started.
+It registers this terminal for every account repo indexed on this machine that your user can reach,
+against the production platform and the production lane, and prints the accounts it was accepted for.
+It also prints the support loop; follow it.
+
+Three tabs running an agent are three agents. Each is independently routable, each reports its own
+activity, and each stops receiving work when its tab closes — a heartbeat anchored to the session dies
+with it, so a crashed agent and a quit agent look identical to the platform.
 
 **Nothing is pushed at you.** A terminal mid-task cannot receive a push, so delivery is you asking.
 That is why the routing decision is a durable field on the ticket rather than a message: you can
@@ -487,21 +494,35 @@ A ticket routed to you is not yet yours. Claim it with `accept`, and the queue t
 
 ### The loop
 
+After `register`, **no agent command needs a flag** — they reuse the platform, lane and identity this
+session registered with.
+
 ```bash
-remits-cli agent register --label "claude@merchant-statements"
-remits-cli agent work --wait 300                    # blocks until something arrives
+remits-cli agent work --wait 600                    # returns as soon as work arrives
 remits-cli agent status --state working --ticket 22454 --activity "reproducing the upload failure"
-# ... investigate, fix, verify ...
-remits-cli agent status --activity "verifying the fix on localhost"
-# ... then close the ticket lifecycle through mcp_support_ticket ...
-remits-cli agent status --state idle                # ready for the next one
+# ... investigate, fix, verify — keep `status` current as what you are doing changes ...
+# ... close the ticket lifecycle through mcp_support_ticket (accept -> update_status -> complete) ...
+remits-cli agent status --state idle                # then ask for work again
 ```
 
+**Stay on duty.** When `agent work` returns nothing, ask again — do not stop and wait to be
+re-prompted. Registration persists for the life of the session (the heartbeat keeps you visible and
+routable even while you are not polling), but collecting work is something you have to do.
+
 **Report what you are doing.** `agent status` is how an operator watching the dashboard, or another
 agent, knows this session is alive and what it is on. It costs one command and it is the difference
 between a visible queue and a silent one. Update it when you change what you are doing, not on a
 timer.
 
+**Work the ticket in the right repo.** A ticket names its `accountId`, and often an
+`implementationAccountId` — the platform/product account whose repo holds the code. Resolve that to a
+local directory through `~/.remits-cli/account-repos.json` and `cd` there before making changes. You
+registered from anywhere; you do not fix anything from anywhere.
+
+**Lane note:** `register` defaults to the production lane because a support agent works real tickets.
+`--data-mode test` registers a fixture agent instead, which will never be routed a production ticket —
+use it only when you are deliberately testing the routing itself.
+
 ### Seeing the queue as a human does
 
 `remits-cli start` opens a browser control center showing the same facts you are acting on: which
@@ -2750,19 +2771,27 @@ so in its own output; when a test run genuinely needs prod data, pass the flag.
 independent of everything else — no background service is required, and every tab is its own agent.
 
 ```bash
-remits-cli agent register            # this session is now routable
+remits-cli agent register            # this session is now routable — no flags, any directory
 remits-cli agent work --wait 300     # ask for tickets routed here
 remits-cli agent status --state working --ticket 22454 --activity "reproducing"
-remits-cli agent list                # who else is available for this account
+remits-cli agent list                # who else is available across the accounts you cover
 remits-cli agent release             # stop receiving tickets right now
 ```
 
+**Defaults exist so the user does not have to type them.** With no flags, `register` targets the
+production platform (`REMITS_BASE_URL` when set) and the **prod** lane, and claims every account repo
+indexed on this machine. That is a deliberate exception to the CLI's test-first default: registering
+presence mutates no business data, and a test-lane agent is silently useless for support — it appears
+online and can never be routed a production ticket. Every command after `register` reuses the
+platform, lane and identity it registered with.
+
 ### What registration actually does
 
 - Mints an `agentId` for this session and tells the platform which account repos this machine has
-  checked out. The platform **verifies** those claims against what your user can access and returns
-  the ones it refused, so "I registered but never get tickets for account 52" is answerable from the
-  registration output alone.
+  checked out — read from the machine-wide index (`~/.remits-cli/account-repos.json`), which is why
+  the working directory does not matter. The platform **verifies** those claims against what your user
+  can access and returns the ones it refused, so "I registered but never get tickets for account 52"
+  is answerable from the registration output alone.
 - Starts a small detached heartbeat process **anchored to the agent process that owns this terminal**
   (it walks up the process tree to find `claude`/`codex`/`gemini`, then an interactive shell). When
   that process ends, the heartbeat ends and the session stops being routable within a couple of