flowviant 0.52.0 → 0.54.0

package/README.md

@@ -1,15 +1,18 @@
 # flowviant
 
-Run your own [Claude Code](https://claude.com/claude-code) as headless build agents for [Flowviant](https://flowviant.com). You manage a team of agents in the app; this daemon runs them on your machine, on your own credentials — Flowviant never sees your Claude or GitHub logins.
+Run your own coding CLIs as build agents for [Flowviant](https://flowviant.com) — [Claude Code](https://claude.com/claude-code), Codex or Antigravity, on your own credentials. This daemon holds your sessions, keeps a worktree per tab, and ships branches on your word. Flowviant never sees your Claude, Codex or GitHub logins.
 
 ```bash
-npx flowviant login      # approve the code in Flowviant → connected
-npx flowviant            # run your fleet
+npx flowviant@latest login   # approve the code in Flowviant → connected
 ```
 
+Login keeps going straight into the daemon — there is no second command to run.
+
 ## What it does
 
-You create named agents in Flowviant and dispatch work to them. This daemon, running on a machine you control, gives each agent its own git worktree and drives **your** locally-authenticated `claude` to do the work — it claims a task, works it, captures evidence for each acceptance criterion, opens a pull request, and routes any question it can't answer back to you as a blocker. You review and merge in the app.
+A Flowviant project has ONE machine, and this is it: one box, running one Claude (or Codex, or Antigravity) account, serving the whole team's sessions so nobody has to set up their own. Solo and team are the same architecture at N=1 and N>1.
+
+You work in the **Workbench**, where your sessions are TABS — each one a held context plus a persistent git worktree on its own `session/<id>` branch. The browser is a terminal projected onto this machine, so you reach the same session from any device. When you say ship, the tab merges its own branch into base with `--no-ff` — no squash, so the commit shas the work reported still exist on main.
 
 Because it drives the CLIs you're already logged into, **the cost is yours** (your Claude subscription, your GitHub) and **the daemon never handles a credential** — it shells out to tools you authenticated yourself.
 
@@ -17,9 +20,9 @@ Because it drives the CLIs you're already logged into, **the cost is yours** (yo
 
 On the machine that runs the daemon:
 
-- **[Claude Code](https://claude.com/claude-code)** installed and signed in (`claude`)
-- **[GitHub CLI](https://cli.github.com)** authenticated (`gh auth login`) — for opening PRs
+- **at least one coding CLI** installed and signed in — [Claude Code](https://claude.com/claude-code) (`claude`), Codex (`codex`) or Antigravity (`agy`)
 - **git**, and **Node 20+**
+- **[GitHub CLI](https://cli.github.com)** (`gh`) — optional; the daemon offers to fetch an isolated copy, and `flowviant gh-auth` signs it in
 - run it from inside the git repository you want worked
 
 ## Connecting
@@ -27,53 +30,44 @@ On the machine that runs the daemon:
 The easy way — device login, like `gh auth login`:
 
 ```bash
-npx flowviant login
+npx flowviant@latest login
 ```
 
-It shows a short code; enter it in Flowviant under **Agents → Connect a machine**. The credential is stored at `~/.flowviant/credentials.json`, and from then on `npx flowviant` just runs.
+It shows a short code. Open your project's **Workbench** in Flowviant and enter the code where it offers to connect a machine. The credential is stored at `~/.flowviant/credentials.json`, and from then on `npx flowviant@latest` just runs.
 
-Prefer an explicit token? Create a fleet credential in the app and pass it directly:
+Prefer an explicit token? Create a machine credential in the app and pass it directly:
 
 ```bash
-FLOWVIANT_FLEET=fva_… npx flowviant
+FLOWVIANT_FLEET=fva_… npx flowviant@latest
 ```
 
-## Live mode (the default)
-
-Each task runs a **persistent** Claude session you can talk to mid-task from the app: the agent streams its work into the task's conversation, you `@`-mention it to steer or answer questions, and it resumes in place. Blockers park the session at zero cost until you answer. When it finishes, it posts a delivery card (summary + checklist self-report) in the thread — a human confirms done by merging there.
+Launch with `@latest` so each start pulls the newest published version — a bare `npx flowviant` can reuse a stale cache. A running daemon also self-updates at startup and when idle (`FLOWVIANT_NO_UPDATE=1` makes it nag-only; `flowviant update` updates now).
 
-Prefer the legacy one-shot poll mode (no streaming, no previews)? Escape hatch:
+## Sessions
 
-```bash
-FLOWVIANT_POLL=1 npx flowviant
-```
+Each tab in the Workbench is a persistent Claude session with its own worktree, and it stays where you left it — the branch outlives the tab. The daemon runs each turn in event mode and relays what the CLI is printing (thinking, reads, greps, commands) back to the tab, reports the worktree's branch and diffstat after every turn, and fetches a commit's patch when you click a sha in the app.
 
-### Live previews
+Nothing starts work except you opening a tab and typing in it.
 
-For UI/API tasks, the daemon can start the branch's dev server in the agent's worktree and open a [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) quick tunnel so you can drive the real running change during review — no Cloudflare account needed (it's auto-fetched if missing). Configure it once per repo, or let it infer common setups:
+## Sharing a preview
 
-```json
-// .flowviant/preview.json
-{ "ui": { "cmd": "npm run dev", "port": 5173 } }
-```
+You run your dev server yourself, in the session's own worktree, exactly as you would in any terminal. The daemon NOTICES the listening port; ask for a share in the app and it puts a [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) quick tunnel in front of it (auto-fetched if missing, pinned and checksummed) behind a **mandatory password gate**. Flowviant stores only the tunnel URL; your browser talks to it directly.
 
-Flowviant only stores the tunnel URL; your browser talks to it directly.
+The daemon never executes anything the repository declares. An earlier version read a `.flowviant/preview.json` from the branch and spawned the command it named — that start path was removed in 0.53.0 and is not coming back; see the header of `bin/lib/preview.mjs` for exactly what it did, so nobody rebuilds it.
 
 ## Modes
 
 | Env | What runs |
 | --- | --- |
-| _(stored login)_ or `FLOWVIANT_FLEET` | **Fleet daemon** — one worktree + worker per agent on your roster, managed in the app |
-| `FLOWVIANT_TOKEN` | a single agent in the current checkout |
-| `FLOWVIANT_TOKENS=a,b,c` | a static fleet, one worktree each |
+| _(stored login)_ or `FLOWVIANT_FLEET` | **the daemon** — the project's machine, serving its sessions |
 | `FLOWVIANT_SAFE=1` | restrict the toolset instead of running unattended |
 
 ## Security posture
 
-Every project member with edit access can run turns on this machine —
-Workbench tabs and @-dispatches both execute a coding agent with the daemon's
-own OS permissions. Membership is the consent boundary, the same trust plane
-as the shared repository: invite people you would give a shell to.
+Every project member with edit access can run turns on this machine — a
+Workbench tab executes a coding agent with the daemon's own OS permissions.
+Membership is the consent boundary, the same trust plane as the shared
+repository: invite people you would give a shell to.
 
 Two knobs bound the blast radius, and both are worth setting on a shared box:
 

package/bin/cli.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 /**
- * flowviant — run your own Claude Code as headless Flowviant build agents.
+ * flowviant — run your own coding CLI (Claude Code, Codex, Antigravity) as the
+ * machine behind a Flowviant project.
  *
  * ONE mode, one credential:
  *
- *   FLOWVIANT_FLEET=fft_…   npx flowviant@latest  # the fleet daemon
+ *   FLOWVIANT_FLEET=fva_…   npx flowviant@latest  # the machine daemon
  *
  * `FLOWVIANT_TOKEN` (one worker, current checkout) and `FLOWVIANT_TOKENS` (a
  * comma list, one worktree each) stood beside it until 2026-08-19. Both ran the
@@ -19,28 +20,32 @@
  * on its own — at startup and when idle — so it stays current without restarts
  * (FLOWVIANT_NO_UPDATE=1 makes it nag-only; `flowviant update` updates now).
  *
- * Fleet daemon: install ONCE with a fleet credential, then manage everything
- * from Flowviant. The daemon polls GET /api/v2/fleet/agents, reconciles one
- * persistent git worktree + worker loop per roster agent, rotates each worker's
- * short-lived MCP token, and only spawns Claude when an agent has work. Add/remove
- * agents in the app — the daemon picks up the change on its next poll. Each worker
- * claims its work, resets its worktree to base per task (fresh Claude conversation),
- * opens one PR per intent, and routes questions back as blockers.
+ * The daemon: install ONCE with a machine credential, then work entirely from
+ * Flowviant. It polls GET /api/v2/fleet/agents, and the roster hands it the
+ * project's SESSIONS — the Workbench's tabs. Each session gets one persistent
+ * git worktree on its own `session/<id>` branch, held across turns (never reset
+ * to base: the branch outlives the tab). A turn spawns the session's CLI with a
+ * short-lived per-session MCP token, relays what it prints back to the tab,
+ * reports the worktree's branch and diffstat when it settles, and answers the
+ * odd side job the roster carries — a commit's patch, a preview share, a wiki
+ * regen. When you say ship, the daemon merges that branch into base `--no-ff`.
  *
  * Env:
- *   FLOWVIANT_TOKEN / FLOWVIANT_TOKENS / FLOWVIANT_FLEET  (one of) credentials.
+ *   FLOWVIANT_FLEET     the machine credential (or use `flowviant login`).
  *   FLOWVIANT_API_URL   default https://api.flowviant.com/api/v2
  *   FLOWVIANT_MCP_URL   default <API_URL>/mcp
  *   FLOWVIANT_FLEET_URL default <API_URL>/fleet/agents
- *   POLL_SECONDS        gap between turns while waiting on a blocker (default 20)
- *   IDLE_SECONDS        gap between work checks when idle (default 30)
- *   RECONCILE_SECONDS   fleet roster poll cadence (default 10)
+ *   RECONCILE_SECONDS   roster poll cadence (default 10)
  *   FLOWVIANT_SAFE=1    restrict the toolset instead of running unattended.
  *
- * Requires the `claude` CLI (and `gh` for PRs) on PATH; run from inside the git
- * repo you want worked. Fleet & static-fleet modes also require `git`.
+ * Requires one of `claude` / `codex` / `agy` on PATH, plus `git`; run from
+ * inside the git repo you want worked. `gh` is optional.
  *
- * Implementation lives in ./lib/: config, ui, claude, git, fleet, single.
+ * Implementation lives in ./lib/: config, ui, preflight, install, update,
+ * instance, login, mcp-cli; fleet (the roster loop) and work (session turns);
+ * claude + runtimes + prompts + stream (spawning a CLI and reading its events);
+ * git + worktreeDiff + patch; localSessions, listeners, preview + authproxy;
+ * env + env-cli + vault, resources, deploy, shot.
  */
 import { FLEET_TOKEN } from './lib/config.mjs';
 import { runFleetDaemon } from './lib/fleet.mjs';
@@ -132,9 +137,9 @@ if (process.argv[2] === 'clean') {
 }
 
 // `flowviant shot <url>` — capture a headless-browser screenshot of a running
-// page. Build agents shell out to this to attach REAL visual evidence to the
-// delivery card. Self-contained + graceful (no browser → exit 1, agent falls
-// back to text evidence); needs no credential, so it runs before the auth gate.
+// page. A session's agent shells out to this to SEE the change it just made.
+// Self-contained + graceful (no browser → exit 1, and the agent carries on in
+// text); needs no credential, so it runs before the auth gate.
 if (process.argv[2] === 'shot') {
   const { runShot } = await import('./lib/shot.mjs');
   await runShot(process.argv.slice(3));
@@ -145,8 +150,9 @@ if (process.argv[2] === 'shot') {
 // are sealed to the project pubkey ON THIS MACHINE (same write-only crypto as
 // the browser); `show` decrypts locally — it only works on an ENROLLED machine.
 // `flowviant mcp` — connect YOUR Claude to Flowviant so you can file work from
-// the terminal. Mints a `cli` credential: a separate principal from the build
-// workers, with only the management tools and no way to claim or ship work.
+// the terminal. Mints a `cli` credential: a separate principal from the
+// per-session tokens, with only the management tools and no way to work or ship
+// a card.
 if (process.argv[2] === 'mcp') {
   const { runMcpCommand } = await import('./lib/mcp-cli.mjs');
   await runMcpCommand(process.argv.slice(3));
@@ -164,7 +170,7 @@ if (!FLEET_TOKEN) {
     'error: no credential found. Easiest:\n' +
       '  flowviant login      (approve in the app — recommended)\n' +
       'Or set:\n' +
-      '  FLOWVIANT_FLEET=fft_…   (fleet token, manage machines in Flowviant)'
+      '  FLOWVIANT_FLEET=fva_…   (machine token, from the app)'
   );
   process.exit(1);
 }

package/bin/lib/authproxy.mjs

@@ -1,44 +1,124 @@
 /**
- * Opt-in basic-auth reverse proxy for previews (`.flowviant/preview.json`
- * "auth": true). The public tunnel is otherwise a capability URL — anyone with
- * it reaches the running app. This gates it: cloudflared → this proxy → dev
- * server, with a generated password the app surfaces to the reviewer.
+ * The password gate in front of a shared preview. cloudflared → this proxy →
+ * the dev server the DRIVER started in their own worktree.
  *
- * Minimal + dependency-free: forwards HTTP, and pipes WS upgrades (HMR) — the
+ * MANDATORY, not opt-in (2026-08-21). It was `.flowviant/preview.json`
+ * "auth": true, defaulting OFF, and its caller logged "tunneling WITHOUT a
+ * password" to a console nobody reads and opened the tunnel anyway. A tunnel
+ * publishes a worktree holding the project's materialized dev secrets; there is
+ * no honest default but closed. `startAuthProxy` returning null now means the
+ * share is ABORTED and the machine says why.
+ *
+ * Minimal and dependency-free: forwards HTTP, and pipes WS upgrades (HMR) — the
  * browser re-sends the cached Basic-auth header on same-origin upgrades, so HMR
- * still authenticates. If a proxy request fails the page just 502s; it never
- * touches the default (no-auth) preview path.
+ * still authenticates.
+ *
+ * Three things this file gets wrong easily, all of them fixed here and all of
+ * them worth keeping fixed:
+ *  - the credential must NOT reach the origin. `headers: req.headers` forwarded
+ *    `authorization` verbatim, handing the gate password to whatever code the
+ *    branch happens to be running. It is stripped now.
+ *  - the comparison is over a secret, so it is constant-time over a digest
+ *    rather than `===` over a string.
+ *  - `stop()` was a bare `server.close()`, which refuses NEW connections and
+ *    leaves live ones alone — so a held HMR websocket kept the page alive for
+ *    the one most-engaged viewer after teardown. Live sockets are tracked and
+ *    destroyed.
  */
 
 import { createServer, request } from 'node:http';
-import { randomBytes } from 'node:crypto';
+import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
+
+/** Failed attempts before the proxy stops answering at all. A quick tunnel's
+ *  hostname is unguessable, so this is not the primary control — it is what
+ *  turns a discovered URL from an offline guessing target into a visible,
+ *  self-closing incident. */
+const MAX_FAILED = 25;
+
+const digest = (s) => createHash('sha256').update(String(s)).digest();
+
+/** Constant-time over sha256 digests, so length never leaks and a missing
+ *  header costs the same as a wrong one. */
+function sameSecret(a, b) {
+  try {
+    return timingSafeEqual(digest(a ?? ''), digest(b ?? ''));
+  } catch {
+    return false;
+  }
+}
 
-/** Start the proxy in front of a dev server on `targetPort`. Resolves
- *  { port, user, password, stop }. Binds loopback only (cloudflared connects
- *  locally); the password is what gates the public tunnel. */
-export function startAuthProxy({ targetPort, log }) {
+/**
+ * Start the gate in front of a dev server on `targetPort`. Resolves
+ * { port, user, password, stop } — or NULL, which the caller must treat as a
+ * hard failure. Binds loopback only; cloudflared connects locally, and the
+ * password is what gates the public hostname.
+ *
+ * `onAbuse` fires once, after MAX_FAILED rejected attempts, so the caller can
+ * tear the whole share down rather than leaving a URL under attack.
+ */
+export function startAuthProxy({ targetPort, log, onAbuse }) {
   const user = 'preview';
-  const password = randomBytes(9).toString('base64url'); // ~12 url-safe chars
+  // 24 bytes → 32 url-safe chars. It was 9 bytes, chosen when this was an
+  // opt-in convenience; it is the only thing between a public hostname and a
+  // worktree now.
+  const password = randomBytes(24).toString('base64url');
   const expected = 'Basic ' + Buffer.from(`${user}:${password}`).toString('base64');
-  const authed = (req) => req.headers['authorization'] === expected;
 
-  const forwardOpts = (req) => ({
-    host: '127.0.0.1',
-    port: targetPort,
-    method: req.method,
-    path: req.url,
-    headers: req.headers,
-  });
+  let failed = 0;
+  let abused = false;
+  const authed = (req) => {
+    if (abused) return false;
+    if (sameSecret(req.headers['authorization'], expected)) {
+      failed = 0;
+      return true;
+    }
+    // A bare GET with no header is the browser's first move on every load, and
+    // it is answered with a 401 challenge — it is not an attempt.
+    if (req.headers['authorization']) failed += 1;
+    if (failed >= MAX_FAILED && !abused) {
+      abused = true;
+      log?.(`preview gate: ${failed} failed attempts — closing the share.`);
+      try {
+        onAbuse?.();
+      } catch {
+        /* the caller's teardown is best-effort */
+      }
+    }
+    return false;
+  };
+
+  // The gate credential is OURS and stops here. Everything else is passed
+  // through untouched: the origin is the driver's own dev server and rewriting
+  // its request would be us editing their app's input.
+  const forwardOpts = (req) => {
+    const headers = { ...req.headers };
+    delete headers.authorization;
+    delete headers['proxy-authorization'];
+    return {
+      host: '127.0.0.1',
+      port: targetPort,
+      method: req.method,
+      path: req.url,
+      headers,
+    };
+  };
+
+  const challenge = (res) => {
+    res.writeHead(401, {
+      'WWW-Authenticate': 'Basic realm="Flowviant preview"',
+      'Content-Type': 'text/plain',
+      // A preview is a moving target by definition; nothing about it should sit
+      // in a cache the viewer cannot see.
+      'Cache-Control': 'no-store',
+    });
+    res.end('This preview is password-protected. Enter the password shown in Flowviant.');
+  };
+
+  // Every live socket, so stop() can actually end the ones already talking.
+  const sockets = new Set();
 
   const server = createServer((req, res) => {
-    if (!authed(req)) {
-      res.writeHead(401, {
-        'WWW-Authenticate': 'Basic realm="Flowviant preview"',
-        'Content-Type': 'text/plain',
-      });
-      res.end('This preview is password-protected. Enter the password shown in Flowviant.');
-      return;
-    }
+    if (!authed(req)) return challenge(res);
     const proxyReq = request(forwardOpts(req), (proxyRes) => {
       res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
       proxyRes.pipe(res);
@@ -50,8 +130,13 @@ export function startAuthProxy({ targetPort, log }) {
     req.pipe(proxyReq);
   });
 
+  server.on('connection', (socket) => {
+    sockets.add(socket);
+    socket.on('close', () => sockets.delete(socket));
+  });
+
   // WS upgrade (HMR). The browser resends the Basic-auth header on same-origin
-  // upgrades, so we can gate it too, then pipe the two sockets together.
+  // upgrades, so we gate it too, then pipe the two sockets together.
   server.on('upgrade', (req, socket, head) => {
     if (!authed(req)) {
       socket.write('HTTP/1.1 401 Unauthorized\r\nWWW-Authenticate: Basic realm="Flowviant preview"\r\n\r\n');
@@ -65,6 +150,8 @@ export function startAuthProxy({ targetPort, log }) {
       if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
       proxySocket.pipe(socket);
       socket.pipe(proxySocket);
+      sockets.add(proxySocket);
+      proxySocket.on('close', () => sockets.delete(proxySocket));
       proxySocket.on('error', () => socket.destroy());
       socket.on('error', () => proxySocket.destroy());
     });
@@ -74,10 +161,12 @@ export function startAuthProxy({ targetPort, log }) {
   });
 
   return new Promise((resolve) => {
-    server.on('error', () => resolve(null)); // couldn't bind → caller falls back to no proxy
+    // Could not bind → the caller ABORTS the share. There is no no-proxy path
+    // to fall back to any more.
+    server.on('error', () => resolve(null));
     server.listen(0, '127.0.0.1', () => {
       const port = server.address().port;
-      log?.(`auth proxy on :${port} — preview is password-gated`);
+      log?.(`preview gate on :${port}`);
       resolve({
         port,
         user,
@@ -88,6 +177,16 @@ export function startAuthProxy({ targetPort, log }) {
           } catch {
             /* already closed */
           }
+          // close() only stops NEW connections. An open HMR socket would keep
+          // serving the viewer who is still looking at it.
+          for (const s of sockets) {
+            try {
+              s.destroy();
+            } catch {
+              /* already gone */
+            }
+          }
+          sockets.clear();
         },
       });
     });

package/bin/lib/config.mjs

@@ -1,5 +1,6 @@
 /** Parsed configuration: env vars, CLI flags, and the chosen credentials. */
 
+import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -43,11 +44,6 @@ function argFlag(name) {
   return i >= 0 ? process.argv[i + 1] : undefined;
 }
 
-/** A bare boolean flag (no value follows it). */
-function hasFlag(name) {
-  return process.argv.includes(name);
-}
-
 const API_BASE = process.env.FLOWVIANT_API_URL || 'https://api.flowviant.com/api/v2';
 export const MCP_URL = process.env.FLOWVIANT_MCP_URL || `${API_BASE}/mcp`;
 export const FLEET_URL = process.env.FLOWVIANT_FLEET_URL || `${API_BASE}/fleet/agents`;
@@ -148,25 +144,24 @@ export const AUTO_UPDATE = process.env.FLOWVIANT_NO_UPDATE !== '1';
 // path (one-shot `claude -p` turns) survives behind FLOWVIANT_POLL=1 as the
 // escape hatch; FLOWVIANT_LIVE=1 is still honored for old scripts.
 export const LIVE = process.env.FLOWVIANT_POLL !== '1';
+// Sent on the daemon's own HTTP calls so Cloudflare Bot Fight Mode doesn't 403
+// them (Node's default UA is treated as a bot). Claude Code sends its own UA.
+export const USER_AGENT = `flowviant/${VERSION}`;
+
 /**
- * Does this machine accept PATCHES — commits cherry-picked straight into your
- * working checkout, with no PR and no review?
+ * WHICH DAEMON PROCESS this is — not which credential.
  *
- * Patch placement is chosen by a model, and any teammate who @mentions one of
- * your agents can trigger it, so whether it happens at all belongs to whoever
- * owns the checkout. Turning it off does not lose the work: the task falls back
- * to branch placement and arrives as a PR like anything else.
+ * Two daemons legitimately share one fleet token (that is exactly what
+ * `machineDaemonsDisagree` reports, and the instance lock added in 0.51.2
+ * cannot see a peer OLDER than itself). So the token cannot identify a lease
+ * holder, and anything that must be done exactly once needs this instead.
  *
- * On by default — the guard that actually protects you (never touching a file
- * you have uncommitted edits in) is enforced at apply time, and the whole point
- * of patches is to spare you a review cycle for a nine-character diff.
- * `--no-patches` or FLOWVIANT_PATCHES=0 to refuse them.
+ * Regenerated every start, deliberately: a daemon that restarted is a daemon
+ * that lost whatever it was holding, and a stale lease should not follow it
+ * back. Sent on the poll as `di`; its ABSENCE is what an older daemon looks
+ * like, and the server hands preview work to nobody who cannot name themselves.
  */
-export const ALLOW_PATCHES =
-  !hasFlag('--no-patches') && process.env.FLOWVIANT_PATCHES !== '0';
-// Sent on the daemon's own HTTP calls so Cloudflare Bot Fight Mode doesn't 403
-// them (Node's default UA is treated as a bot). Claude Code sends its own UA.
-export const USER_AGENT = `flowviant/${VERSION}`;
+export const DAEMON_INSTANCE = randomBytes(12).toString('hex');
 
 // The ONE credential. `tokens` (FLOWVIANT_TOKEN / FLOWVIANT_TOKENS / --token /
 // --tokens) stood beside it and carried WORKER tokens into the pre-daemon loop;