@manyoars/oars 0.5.4 → 0.5.5

package/README.md

@@ -82,7 +82,7 @@ oars card --month                # the last 30 days as a picture: oars-card-mont
 oars card --year --out me.png    # the last 365 days, saved as me.png and me.svg
 ```
 
-`oars card` makes a share-ready card of your own week (the default, the last 7 days), month, or year across every harness, read from the local session store only. It shows your sessions and active days, the harnesses and models you used, tokens by model, tool calls, failed calls and how many were followed by a different next step, how often an edit was verified, commits and how many survived, and cost only where the harness recorded one. A count under the same floor `oars sessions books` uses prints `too few`. The depositor row reads `ashore: run oars pool login` until you sign in; signed in, it reads the number of weeks in which this machine sent a deposit, from the local sent record, and says it is this machine's.
+`oars card` makes a share-ready card of your own week (the default, the last 7 days), month, or year across every harness, read from the local session store only. It shows your sessions and active days, the harnesses and models you used, tokens by model, tool calls, failed calls and how many were followed by a different next step, how often an edit was verified, commits and how many survived, and cost only where the harness recorded one. A count under the same floor `oars sessions books` uses prints `too few`. The depositor row reads `ashore: run oars pool join` until you sign in; signed in, it reads the number of weeks in which this machine sent a deposit, from the local sent record, and says it is this machine's.
 
 Once a week, the first command you run in a terminal on or after Friday prints one line to stderr, `Your week: N sessions, M strokes. \`oars card --text\` for the table.`, never with `--json`, from a hook, from the MCP server, from a recall, from `oars sessions try`, or from `oars card` itself, and only when the week has a session. About one install in ten never sees it; `card-line.json` in the session store folder records the week and whether it was `shown`, `held`, or `not_due`, and `card-line-id` holds the id the holdback hashes, copied once from the telemetry install id when there is one, else random, so the arm never changes.
 
@@ -207,12 +207,12 @@ Replay is local and read-only on your transcripts; it writes `crossings.jsonl` a
 
 ### pool
 
-`oars pool` uses the Many Oars pool, `https://pool.manyoars.com`, which is live and open for deposits, or a pool server you name with `--server <url>` or `OARS_POOL_URL`. Every other command works without it.
+`oars pool` uses the Many Oars pool, `https://pool.manyoars.com`, which is live and open by covenant (a deposit needs the covenant read and accepted first), or a pool server you name with `--server <url>` or `OARS_POOL_URL`. Every other command works without it.
 
-- `oars pool join --provider github|google --harness-version <version> [--harness <name>]` is the first way in: it signs you in, prepares your deposit, prints what would be sent with each field's rule, sends it, and fetches your first bundle, in one run. It is the five commands below in order, with the same prompts and the same checks, and one plain line says what each step is doing. If a step stops, it prints that step's own error and names the command to run again; running `oars pool join` again skips what already stands (a held sign-in, a prepared batch, a batch already sent). The commands below do the same step by step.
+- `oars pool join [--provider github|google] [--plan] [--accept-covenant <version>] [--in-eu-eea-uk <yes|no>] [--harness-version <version> [--harness <name>]]` is the first way in, from an empty store to a first send in one run. Its steps, in order: `signin` (`login`), `region` (at a terminal, for an account that has not accepted, "Are you in the EU, the EEA, or the UK?" is asked plainly and the answer goes with the acceptance; `--in-eu-eea-uk` answers it), `terms` (your exclusion term file, made empty for you to edit when it is missing, since oars adds no term for you; the run waits for Enter at a terminal and stops with the file's path off one), `batch` (`deposit`), `outbox` (`outbox --explain`, printed before anything is sent), `covenant` (the screen `deposit --send` shows; you type its phrase, and no flag or variable does it for you: off a terminal the run stops with `covenant_not_accepted`, and `--accept-covenant` only names the version expected), and `send` (`deposit --send <hash>` for each batch not yet sent). With `--harness-version` it then fetches that bundle, as `fetch` does. If a step stops, it prints that step's own error and names the command to run again; running `oars pool join` again skips what already stands (a held sign-in, terms in the file, a prepared batch, an accepted covenant, a batch already sent). `oars pool join --plan --json` prints `{ok, plan, server, steps: [{step, state, needs_person}]}` for the seven steps and `raw`, with `state` `done` or `pending` and `needs_person` true for `covenant` and `raw`, the two a person does themselves, and for `region` and `terms` while they are pending and no `--in-eu-eea-uk` flag or term in the file answers them; it reads the sign-in, the term file, the outbox, and (when signed in) the covenant, and signs in to nothing, writes nothing, and sends nothing. Each step leaves one `join-step` telemetry event (docs/telemetry.md). The commands below do the same step by step.
 - `oars pool login --provider github|google` asks the pool to start the provider's device flow, prints the user code and link, and polls the pool until you approve (a failed poll is retried with a longer wait until the code expires; the output names the exclusion-terms file when there is none, and the first `pool deposit` needs it); with `--verbose`, every request prints before it is sent. The pool holds the OAuth client and its secret, so the CLI needs no client ID or secret, and the provider's tokens never reach this machine.
 - `oars pool logout` revokes this machine's credential at the pool, then removes the local sign-in. If the pool cannot be reached it still removes the local sign-in and says the credential was not revoked there.
-- `oars pool deposit` writes a batch of session skeletons (a closed list of fields, each value redacted first; a host is hashed by the pool on arrival) to an outbox for each session that passes your folder allowlist and the exclusion check and whose last line is over 6 hours old, and stops: no session data is sent. `--send <hash>` sends one batch that `outbox` printed and that is unchanged on disk, once this account has accepted the pool covenant (a person types the phrase the covenant screen states, at a terminal; `--accept-covenant <version>` only names the version expected and accepts nothing; the screen then asks "Are you in the EU, the EEA, or the UK? (yes/no)" and sends the answer, and `--in-eu-eea-uk <yes|no>` answers it without asking; while the pool is closed to those regions a yes, or a request from them, is refused with `region_closed` and nothing is accepted); before that it reads the covenant, sends no batch, and exits 3 with `covenant_not_accepted`. A hash that was never shown, or a batch that changed, is refused before any request. The detached sender is the other sender: after the pool says your account accepted its covenant, it sends new batches, and raw copies only if you said yes to the raw prompt (`oars pool raw --consent yes`, answered by typing the phrase `I consent to sending raw copies` at a terminal; a yes also tells the pool, and `--consent no` tells it to stop accepting raw copies, whatever a later request states (a machine that held a yes and is signed out exits nonzero: the pool was not told), and the pool's nightly job then erases the raw copies it already holds, starting that night; a large account can take more than one night). With no sign-in, no acceptance, or an unreachable server it sends nothing.
+- `oars pool deposit` writes a batch of session skeletons (a closed list of fields, each value redacted first; a host is hashed by the pool on arrival) to an outbox for each session that passes your folder allowlist and the exclusion check and whose last line is over 6 hours old, and stops: no session data is sent. `--send <hash>` sends one batch that `outbox` printed and that is unchanged on disk, once this account has accepted the pool covenant (a person types the phrase the covenant screen states, at a terminal; `--accept-covenant <version>` only names the version expected and accepts nothing; the screen then asks "Are you in the EU, the EEA, or the UK? (yes/no)" and sends the answer, and `--in-eu-eea-uk <yes|no>` answers it without asking; while the pool is closed to those regions a yes, or a request from them, is refused with `region_closed` and nothing is accepted); before that it reads the covenant, sends no batch, and exits 3 with `covenant_not_accepted`. A hash that was never shown, or a batch that changed, is refused before any request. `--send-all` sends, in order and one batch at a time, every batch that `outbox` printed and that is unchanged, under the same covenant rule, except that a never-accepted account is refused, on a terminal too, with the `--send <hash>` command that shows the screen (it cannot be combined with `--send`, `--accept-covenant`, or `--in-eu-eea-uk`); a batch never printed or changed is skipped and counted, never sent. A batch already in `sent.log` is not sent again, so a run that stops (the first failed batch ends it, after up to three tries on a 429 or a 5xx, with the sent, skipped, failed, and left counts and a non-zero exit) is continued by running the same command again. It prints one progress line per 100 batches and a final count line, never a session's content. The detached sender is the other sender: after the pool says your account accepted its covenant, it sends new batches, and raw copies only if you said yes to the raw prompt (`oars pool raw --consent yes`, answered by typing the phrase `I consent to sending raw copies` at a terminal; a yes also tells the pool, and `--consent no` tells it to stop accepting raw copies, whatever a later request states (a machine that held a yes and is signed out exits nonzero: the pool was not told), and the pool's nightly job then erases the raw copies it already holds, starting that night; a large account can take more than one night). With no sign-in, no acceptance, or an unreachable server it sends nothing.
 - `deposit`, `outbox`, `export`, and `fetch` need `oars pool login` first; without it they exit 3 and name the server.
 - `oars pool coverage [--org-size <band>] [--repo-visibility public|private|unknown]` sets the two coverage bands only you can state, read locally and never from the network; an unset band goes on the wire as `unknown`.
 - `oars pool export --out <folder> [--raw]` saves a copy of what the pool holds about your account (GDPR Articles 15(3) and 20), as JSON, one file a page, readable by you only. It covers your account row (with your raw consent record), when your sign-ins end (never the credential), your covenant acceptances, your machines (without their keys, with the day of each one's last deposit and its key days), your repository keys, your deposit hours, your deposits as they now read (with the machine, host class, and launcher each came from, and the host class and launcher the batch claimed), your raw ledger, your staged deposit parts, your erasure audit rows, and your telemetry days. `--raw` also saves each raw transcript you deposited that has not been erased, checked against its hash. It needs `oars pool login`, writes nothing to the pool, prints what it saved, and exits nonzero naming any page or object that failed; a rerun overwrites the same files. Totals the pool derives from many accounts are not yours to export and are not in it.

package/dist/cli.js

@@ -19,7 +19,7 @@ import { githubVisibility, poolEnroll, poolMachineRevoke, poolMachines } from '.
 import { runNetGit } from './sessions/machine-hold.js';
 import { holdPull } from './sessions/machine-pull.js';
 import { runGit } from './sessions/survival.js';
-import { poolCoverage, poolDeposit, poolExport, poolFetch, poolJoin, poolLogin, poolLogout, poolOutbox, poolProve, poolRaw, poolRemove } from './sessions/pool-command.js';
+import { poolCoverage, poolDeposit, poolExport, poolFetch, poolInvite, poolJoin, poolLogin, poolLogout, poolOutbox, poolProve, poolRaw, poolRemove } from './sessions/pool-command.js';
 import { telemetryOff, telemetryOn, telemetryReport, telemetryShow, telemetryStatus } from './telemetry/command.js';
 import { cardLine } from './sessions/card-line.js';
 import { recordCrash } from './telemetry/crash.js';
@@ -504,18 +504,20 @@ const buildProgram = (deps, observed) => {
     const serverHelp = 'the pool server, https or plain http to localhost (default: OARS_POOL_URL, else https://pool.manyoars.com)';
     pool
         .command('join')
-        .description('run login, deposit, outbox --explain, deposit --send, and fetch in one command. Run it again after a stop to continue from there')
+        .description('your first deposit in one command: sign in, answer the region question, name the terms to keep out, see the batch, type the covenant phrase yourself, and send. Run it again after a stop to continue at the first step not done')
+        .option('--plan', 'print each step and whether it stands (needs_person marks the covenant phrase and the raw prompt, and the region question and term file while nothing answers them), and do nothing else: no sign-in, no file, no send')
         .option('--provider <name>', 'github or google, for the sign-in step (not needed once signed in)')
         .option('--verbose', 'print each sign-in request, headers and body, to stderr before it is sent (a credential shows as its size)')
         .option('--accept-covenant <version>', 'name the covenant version you expect, as deposit --send takes it: on a terminal the screen is shown and you type its phrase yourself, and off a terminal this is refused')
         .option('--in-eu-eea-uk <yes|no>', 'answer "Are you in the EU, the EEA, or the UK?" when you accept, as deposit --send takes it')
         .option('--harness <name>', 'the harness whose bundle to fetch (default: the one your local store holds the most sessions of, claude-code when none leads)')
-        .requiredOption('--harness-version <version>', 'the public harness version whose bundle to fetch, as fetch takes it')
+        .option('--invite <code>', 'an invite code a founding or standing member gave you (oars pool invite makes one): used once, right after sign-in, and a run repeated after it skips it')
+        .option('--harness-version <version>', 'with this, fetch the public bundle for that harness version after the send, as fetch takes it; without it nothing is fetched')
         .option(serverOption, serverHelp)
         .action(async (_options, command) => {
         const options = command.optsWithGlobals();
         const json = flag(options, 'json');
-        emit(deps, json, await poolJoin(deps, { server: text(options, 'server'), provider: text(options, 'provider'), verbose: flag(options, 'verbose'), acceptCovenant: text(options, 'acceptCovenant'), inEuEeaUk: text(options, 'inEuEeaUk'), harness: text(options, 'harness'), harnessVersion: text(options, 'harnessVersion') ?? '', json }));
+        emit(deps, json, await poolJoin(deps, { server: text(options, 'server'), provider: text(options, 'provider'), verbose: flag(options, 'verbose'), acceptCovenant: text(options, 'acceptCovenant'), inEuEeaUk: text(options, 'inEuEeaUk'), harness: text(options, 'harness'), harnessVersion: text(options, 'harnessVersion'), invite: text(options, 'invite'), json, plan: flag(options, 'plan') }));
     });
     pool
         .command('logout')
@@ -581,14 +583,15 @@ const buildProgram = (deps, observed) => {
     });
     pool
         .command('deposit')
-        .description('write a batch to the outbox for each session that passes the folder allowlist and the exclusion check, and stop: no session data is sent, and only counts print. --send <hash> sends one batch that oars pool outbox printed and that is unchanged, once this account has accepted the pool covenant')
+        .description('write a batch to the outbox for each session that passes the folder allowlist and the exclusion check, and stop: no session data is sent, and only counts print. --send <hash> sends one batch that oars pool outbox printed and that is unchanged, and --send-all sends every such batch, once this account has accepted the pool covenant')
         .option('--accept-covenant <version>', 'name the covenant version you expect, with --send: on a terminal the screen is shown and you type its phrase yourself, and off a terminal this is refused')
         .option('--in-eu-eea-uk <yes|no>', 'answer "Are you in the EU, the EEA, or the UK?" when you accept, with --send; without it a person is asked, with or without --accept-covenant. While the pool is closed to those regions, yes is refused')
         .option('--send <hash>', 'the SHA-256 of a batch that oars pool outbox printed')
+        .option('--send-all', 'send, in order, every batch that oars pool outbox printed and that is unchanged, one at a time, under the same covenant rule as --send, except that a never-accepted account is refused, on a terminal too, with the --send <hash> command that shows the screen; a batch never printed or changed is skipped and counted. A batch that fails (after up to three tries on 429 and 5xx) stops the run with the counts and a non-zero exit; run it again to send what is left, since a batch already sent is never sent twice. Not with --send')
         .option(serverOption, serverHelp)
         .action(async (_options, command) => {
         const options = command.optsWithGlobals();
-        emit(deps, flag(options, 'json'), await poolDeposit(deps, { server: text(options, 'server'), acceptCovenant: text(options, 'acceptCovenant'), inEuEeaUk: text(options, 'inEuEeaUk'), send: text(options, 'send') }));
+        emit(deps, flag(options, 'json'), await poolDeposit(deps, { server: text(options, 'server'), acceptCovenant: text(options, 'acceptCovenant'), inEuEeaUk: text(options, 'inEuEeaUk'), send: text(options, 'send'), sendAll: flag(options, 'sendAll') }));
     });
     pool
         .command('raw')
@@ -628,6 +631,14 @@ const buildProgram = (deps, observed) => {
         const options = command.optsWithGlobals();
         emit(deps, flag(options, 'json'), await poolRemove(deps, hash, { server: text(options, 'server'), restore: flag(options, 'restore') }));
     });
+    pool
+        .command('invite')
+        .description('make one invite code to vouch for a person and print it once with the line they run to join (oars pool join --invite): a founding or standing account holds three open codes at most; needs oars pool login')
+        .option(serverOption, serverHelp)
+        .action(async (_options, command) => {
+        const options = command.optsWithGlobals();
+        emit(deps, flag(options, 'json'), await poolInvite(deps, { server: text(options, 'server') }));
+    });
     pool
         .command('prove')
         .description('prove you control your pool account with your sign-in, and print the account and the time the pool stored, to send to the operator who asked for proof before acting on your request (GDPR Article 12(6)); for a closed account, run login instead')
@@ -770,7 +781,7 @@ const isSessionsTry = (observed) => observed.path.join(' ') === 'sessions try';
 /** The weekly card line (`sessions/card-line.ts`): stderr only, never an error, never a change to the exit code. */
 const weeklyLine = (argv, deps, observed) => deps.sessions === undefined
     ? Promise.resolve('not_due')
-    : cardLine({ storeDir: deps.sessions.storeDir, telemetryDir: deps.telemetry?.dir, now: deps.now(), tty: deps.sessions.stderr?.isTTY === true, argv, path: observed.path, flags: observed.flags, stderr: deps.io.stderr });
+    : cardLine({ storeDir: deps.sessions.storeDir, telemetryDir: deps.telemetry?.dir, now: deps.now(), tty: deps.sessions.stderr?.isTTY === true, argv, path: observed.path, flags: observed.flags, stderr: deps.io.stderr, env: deps.env });
 /** Runs one invocation (`argv` without the node and script entries) and returns the exit code. Telemetry records it afterward and cannot change it. */
 export const run = async (argv, deps) => {
     const observed = { path: [], flags: [] };

package/dist/club.d.ts

@@ -12,6 +12,8 @@ export declare const clubJoin: (deps: RunDeps, code: string, options: Options &
 }) => Promise<Outcome>;
 /** `oars club leave <club>`: the row leaves every view at once. */
 export declare const clubLeave: (deps: RunDeps, club: string, options: Options) => Promise<Outcome>;
+/** What the club shows a member with no counting week, and where to go from it. */
+export declare const ASHORE_CLUB_LINE = "ashore: run oars pool join to start rowing.";
 /** `oars club show <club>`: the board, to its members only. */
 export declare const clubShow: (deps: RunDeps, club: string, options: Options) => Promise<Outcome>;
 /** `oars board`: the open board. It is public, so it needs no sign-in. */

package/dist/club.js

@@ -1,6 +1,7 @@
 // `oars club` and `oars board` (t1091): the commands over the pool's board routes (docs/pool.md, "Boards"). A club shares counts with the people who hold its code; the open board is public. Joining is a person at a terminal who reads the pool's consent text and types yes, the way the covenant is accepted: a flag or a script on stdin is not that person.
 import { createHash } from 'node:crypto';
 import { CliError, exitCodeForProblem, ExitCode } from './errors.js';
+import { crewMarkText } from './sessions/crew-mark.js';
 import { ask, isTerminal, lineFrom, poolServer, runtimeOf } from './sessions/pool-command.js';
 import { isObject, loadSignIns, numberIn, textIn } from './sessions/pool-replica.js';
 const CREATE = 'club-create';
@@ -101,16 +102,21 @@ const rowsOf = (body) => {
     for (const member of Array.isArray(members) ? members : []) {
         if (!isObject(member))
             continue;
-        rows.push({ place: numberIn(member, 'place') ?? rows.length + 1, nickname: textIn(member, 'nickname') ?? '', ashore: Reflect.get(member, 'ashore') === true, weeksRowing: numberIn(member, 'weeksRowing') ?? 0, activeDays: numberIn(member, 'activeDays') ?? 0, sessions: numberIn(member, 'sessions') ?? 0, strokesThisWeek: numberIn(member, 'strokesThisWeek') ?? 0 });
+        rows.push({ place: numberIn(member, 'place') ?? rows.length + 1, nickname: textIn(member, 'nickname') ?? '', ashore: Reflect.get(member, 'ashore') === true, crewNumber: numberIn(member, 'crewNumber'), weeksRowing: numberIn(member, 'weeksRowing') ?? 0, activeDays: numberIn(member, 'activeDays') ?? 0, sessions: numberIn(member, 'sessions') ?? 0, strokesThisWeek: numberIn(member, 'strokesThisWeek') ?? 0 });
     }
     return rows;
 };
+/** What the club shows a member with no counting week, and where to go from it. */
+export const ASHORE_CLUB_LINE = 'ashore: run oars pool join to start rowing.';
 /** The board as lines, in the pool's order: a member with no counting week is "ashore" and has no numbers. */
 const tableOf = (rows) => {
-    const head = ['#', 'nickname', 'weeks rowing', 'active days', 'sessions', 'strokes this week'];
-    const body = rows.map((row) => [String(row.place), row.nickname, ...(row.ashore ? ['ashore', '', '', ''] : [String(row.weeksRowing), String(row.activeDays), String(row.sessions), String(row.strokesThisWeek)])]);
+    // The crew column appears only when a row carries a number, and it holds that row's own mark: nothing here counts the crew.
+    const crewed = rows.some((row) => row.crewNumber !== undefined);
+    const head = ['#', 'nickname', ...(crewed ? ['crew'] : []), 'weeks rowing', 'active days', 'sessions', 'strokes this week'];
+    const body = rows.map((row) => [String(row.place), row.nickname, ...(crewed ? [row.crewNumber === undefined ? '' : crewMarkText(row.crewNumber)] : []), ...(row.ashore ? ['ashore', '', '', ''] : [String(row.weeksRowing), String(row.activeDays), String(row.sessions), String(row.strokesThisWeek)])]);
     const widths = head.map((title, at) => Math.max(title.length, ...body.map((line) => (line[at] ?? '').length)));
-    return [head, ...body].map((line) => line.map((cell, at) => cell.padEnd(widths[at] ?? 0)).join('  ').trimEnd()).join('\n');
+    const table = [head, ...body].map((line) => line.map((cell, at) => cell.padEnd(widths[at] ?? 0)).join('  ').trimEnd()).join('\n');
+    return rows.some((row) => row.ashore) ? `${table}\n${ASHORE_CLUB_LINE}` : table;
 };
 /** `oars club show <club>`: the board, to its members only. */
 export const clubShow = async (deps, club, options) => {

package/dist/sessions/archive.js

@@ -1,4 +1,4 @@
-// oars' own raw archive (Matt 2026-11-01, retention point 4c): every deposited transcript is hard-linked under `<store>/raw/`, so the
+// oars' own raw archive (owner ruling 2026-11-01, retention point 4c): every deposited transcript is hard-linked under `<store>/raw/`, so the
 // raw behind the log outlives the harness's cleanup without a second copy on disk while both exist. Across volumes, where a hard link
 // cannot reach, it is copied. Local only: nothing here is ever shared.
 import { copyFile, link, mkdir, rm, stat } from 'node:fs/promises';

package/dist/sessions/card-command.d.ts

@@ -1,9 +1,9 @@
 import type { Outcome } from '../cli.js';
 import { type CardPeriod } from './card.js';
 import type { SessionsDeps } from './command.js';
-export declare const ASHORE = "ashore: run oars pool login";
+export declare const ASHORE = "ashore: run oars pool join";
 /**
- * The depositor row. Signed out it points at `oars pool login`; signed in it counts the weeks (Monday-start, UTC) in which this machine's sent record holds a deposit,
+ * The depositor row. Signed out it points at `oars pool join`, the one command from nothing to a first deposit; signed in it counts the weeks (Monday-start, UTC) in which this machine's sent record holds a deposit,
  * labeled as this machine's because the record is local. It reads two local files and makes no network call; a sign-in file or pool address that cannot be read is
  * signed out, since a share card must not fail on it.
  */

package/dist/sessions/card-command.js

@@ -10,23 +10,24 @@ import { poolServer } from './pool-command.js';
 import { outboxFolder } from './pool-outbox.js';
 import { loadSignIns } from './pool-replica.js';
 import { sentLog } from './pool-sent.js';
+import { crewMarkText, crewNumberOf } from './crew-mark.js';
 import { loadStore } from './store.js';
 import { readSurvival } from './survival.js';
-export const ASHORE = 'ashore: run oars pool login';
+export const ASHORE = 'ashore: run oars pool join';
 const DAY = 86_400_000;
 const WEEK = 7 * DAY;
 /** 1970-01-01 was a Thursday, so this is the Monday before it: weeks counted from here start on a Monday, UTC. */
 const FIRST_MONDAY = -3 * DAY;
 /**
- * The depositor row. Signed out it points at `oars pool login`; signed in it counts the weeks (Monday-start, UTC) in which this machine's sent record holds a deposit,
+ * The depositor row. Signed out it points at `oars pool join`, the one command from nothing to a first deposit; signed in it counts the weeks (Monday-start, UTC) in which this machine's sent record holds a deposit,
  * labeled as this machine's because the record is local. It reads two local files and makes no network call; a sign-in file or pool address that cannot be read is
  * signed out, since a share card must not fail on it.
  */
 export const depositorLine = async (storeDir, env, now) => {
     try {
         const server = poolServer(env, 'card');
-        const signedIn = (await loadSignIns(storeDir, 'card')).some((entry) => entry.server === server && entry.expiresAt > now);
-        if (!signedIn)
+        const signedIn = (await loadSignIns(storeDir, 'card')).find((entry) => entry.server === server && entry.expiresAt > now);
+        if (signedIn === undefined)
             return ASHORE;
         const weeks = new Set();
         for (const at of (await sentLog(outboxFolder(storeDir, server))).values()) {
@@ -34,7 +35,8 @@ export const depositorLine = async (storeDir, env, now) => {
             if (!Number.isNaN(time))
                 weeks.add(Math.floor((time - FIRST_MONDAY) / WEEK));
         }
-        return `weeks rowing (this machine): ${String(weeks.size)}`;
+        const crew = await crewNumberOf(storeDir, server, signedIn.account);
+        return `weeks rowing (this machine): ${String(weeks.size)}${crew === undefined ? '' : ` · ${crewMarkText(crew)}`}`;
     }
     catch (error) {
         if (error instanceof CliError)

package/dist/sessions/card-line.d.ts

@@ -5,8 +5,10 @@ export declare const HELD_PERCENT = 10;
 export declare const isoWeekOf: (now: number) => string;
 /** Friday, Saturday, or Sunday local time: the ISO week's last three days, so a first command on or after Friday 00:00 is in the week it counts. */
 export declare const fridayOrLater: (now: number) => boolean;
-/** The week's text. Singular at one; nothing else (no install, star, or link words). */
-export declare const cardLineText: (sessions: number, strokes: number) => string;
+/** The line a person with no pool sign-in also reads: the one command that takes them from nothing to a first deposit. */
+export declare const ASHORE_LINE = "Ashore: `oars pool join` takes you to your first deposit.";
+/** The week's text. Singular at one; ashore, the join line follows. Nothing else (no install, star, or link words). */
+export declare const cardLineText: (sessions: number, strokes: number, ashore?: boolean) => string;
 /** Stable per install: the first four bytes of a SHA-256 of the id, taken mod 100, under the holdback percent. */
 export declare const isHeld: (id: string) => boolean;
 export interface CardLineInput {
@@ -20,6 +22,8 @@ export interface CardLineInput {
     path: readonly string[];
     flags: readonly string[];
     stderr: (text: string) => void;
+    /** The run's environment, for the pool address the sign-in is looked up under; absent reads the process's. */
+    env?: NodeJS.ProcessEnv | undefined;
 }
 /** A hook, the MCP server, a recall, `sessions try`, `--json`, or `oars card` itself: the line never goes there. */
 export declare const quiet: (input: Pick<CardLineInput, "argv" | "path" | "flags">) => boolean;

package/dist/sessions/card-line.js

@@ -6,6 +6,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isHook } from '../telemetry/observe.js';
 import { cardOf } from './card.js';
+import { ASHORE, depositorLine } from './card-command.js';
 import { mkdirOwnerOnly, writeOwnerOnly } from './owner-only.js';
 import { loadStore } from './store.js';
 import { readSurvival } from './survival.js';
@@ -28,8 +29,10 @@ export const fridayOrLater = (now) => {
     const day = new Date(now).getDay();
     return day === 0 || day >= FRIDAY;
 };
-/** The week's text. Singular at one; nothing else (no install, star, or link words). */
-export const cardLineText = (sessions, strokes) => `Your week: ${String(sessions)} ${sessions === 1 ? 'session' : 'sessions'}, ${String(strokes)} ${strokes === 1 ? 'stroke' : 'strokes'}. \`oars card --text\` for the table.\n`;
+/** The line a person with no pool sign-in also reads: the one command that takes them from nothing to a first deposit. */
+export const ASHORE_LINE = 'Ashore: `oars pool join` takes you to your first deposit.';
+/** The week's text. Singular at one; ashore, the join line follows. Nothing else (no install, star, or link words). */
+export const cardLineText = (sessions, strokes, ashore = false) => `Your week: ${String(sessions)} ${sessions === 1 ? 'session' : 'sessions'}, ${String(strokes)} ${strokes === 1 ? 'stroke' : 'strokes'}. \`oars card --text\` for the table.${ashore ? ` ${ASHORE_LINE}` : ''}\n`;
 const readTrimmed = async (file) => {
     try {
         return (await readFile(file, 'utf8')).trim();
@@ -96,7 +99,7 @@ export const cardLine = async (input) => {
         const arm = held ? 'held' : 'shown';
         await mark(input.storeDir, week, arm);
         if (!held)
-            input.stderr(cardLineText(card.sessions, card.strokes));
+            input.stderr(cardLineText(card.sessions, card.strokes, (await depositorLine(input.storeDir, input.env ?? process.env, input.now)) === ASHORE));
         return arm;
     }
     catch {

package/dist/sessions/cell-increments.d.ts

@@ -36,6 +36,13 @@ export interface Increments {
     motifs: Motif[];
     strata: Map<string, StratumRow>;
 }
+/** What `cellsOf` does to a store, as calls: `add` one run at a time, then `finish` once. */
+export interface CellsFold {
+    add: (store: Store) => void;
+    finish: () => CellSet;
+}
+/** `cellsOf` as a fold: each `add` floors one run and tallies it, whole and marginal, and `finish` merges the two. Runs come in the whole store's row order. */
+export declare const cellsFold: (graph?: RecallGraph) => CellsFold;
 /**
  * Rule 5: exact tokens and durations never reach `index`. A cell counts a bucketed value as the bucket's lowest value, so a derivation reads only what a deposit carries, and a
  * summed window is a sum of those. A value already at a bucket's floor stays there, which is why a skeleton's store and a local store of the same session derive the same cells.

package/dist/sessions/cell-increments.js

@@ -2,7 +2,7 @@
 // increments with `incrementsOf`, and a local read derives its cells with `cellsOf` over the store it holds, projected the way a deposit projects it (`projectedStore`). Both end in the
 // one `cellsOf`, so a session gives the same cells at the pool and on the machine. This file reads no file system: the pool's Worker bundles it.
 import { ARG_CLASSES, CHANGE_KINDS } from './call-shape.js';
-import { bucketFields, deriveCells, ENVIRONMENT_BUCKET, EXPOSURE_CODES, exposureOfCell, isEnvironmentCell } from './cells.js';
+import { bucketFields, cellFold, ENVIRONMENT_BUCKET, EXPOSURE_CODES, exposureOfCell, isEnvironmentCell } from './cells.js';
 import { bucketOf, floorOf, OTHER, OPEN_GATE, projectedSteps, wireChange, wireFeatures, wireKeys, wireValues } from './pool-wire.js';
 import { NO_RECALLS } from './recall-consequence.js';
 import { USAGE_FIELDS, harnessOf } from './schema.js';
@@ -40,21 +40,36 @@ const marginalSteps = (step) => {
 };
 /** The tools of a store as one-step calls, one per flag and per pull: read at window length 1, each is one marginal cell. */
 const marginalStore = (store) => ({ ...store, tools: store.tools.flatMap((tool) => (tool.steps ?? []).flatMap(marginalSteps).map((marginal) => ({ ...tool, steps: [marginal] }))) });
+/** `cellsOf` as a fold: each `add` floors one run and tallies it, whole and marginal, and `finish` merges the two. Runs come in the whole store's row order. */
+export const cellsFold = (graph = NO_RECALLS) => {
+    const whole = cellFold(graph);
+    const marginal = cellFold(graph);
+    const add = (store) => {
+        const floored = flooredStore(store);
+        whole.add({ ...floored, tools: floored.tools.map((tool) => (tool.steps === undefined ? tool : { ...tool, steps: tool.steps.map(withoutLists) })) });
+        // Only the one-step named motifs of the marginal pass that hold a shell identity (a recall step the graph places there has none, and `whole` already counts it) are kept at the finish: its prompts, its shape motifs, and its longer windows repeat or splice what `whole` holds.
+        marginal.add(marginalStore(floored));
+    };
+    const finish = () => {
+        const wholeSet = whole.finish();
+        const marginalSet = marginal.finish();
+        const named = new Set(marginalSet.motifs.filter(({ level, steps }) => level === 'named' && steps.length === 1 && steps[0]?.identity !== null).map(({ motifId }) => motifId));
+        const motifs = new Map([...wholeSet.motifs, ...marginalSet.motifs.filter(({ motifId }) => named.has(motifId))].map((motif) => [motif.motifId, motif]));
+        const order = (x, y) => (x < y ? -1 : x > y ? 1 : 0);
+        const cells = [...wholeSet.cells, ...marginalSet.cells.filter(({ motifId }) => named.has(motifId))].sort((x, y) => order(x.motifId, y.motifId) || order(x.frameBucket, y.frameBucket) || order(x.grain, y.grain) || order(x.day, y.day) || EXPOSURE_CODES[exposureOfCell(x)] - EXPOSURE_CODES[exposureOfCell(y)]);
+        return { cells, motifs: [...motifs.values()].sort((x, y) => order(x.motifId, y.motifId)) };
+    };
+    return { add, finish };
+};
 /**
  * Rule 5: exact tokens and durations never reach `index`. A cell counts a bucketed value as the bucket's lowest value, so a derivation reads only what a deposit carries, and a
  * summed window is a sum of those. A value already at a bucket's floor stays there, which is why a skeleton's store and a local store of the same session derive the same cells.
  * Rules 1 and 2: a window names a shell step by its program and subcommand alone, and each flag and each pull of it adds a one-step cell of its own.
  */
 export const cellsOf = (store, graph = NO_RECALLS) => {
-    const floored = flooredStore(store);
-    const whole = deriveCells({ ...floored, tools: floored.tools.map((tool) => (tool.steps === undefined ? tool : { ...tool, steps: tool.steps.map(withoutLists) })) }, graph);
-    // Only the one-step named motifs of the marginal pass that hold a shell identity (a recall step the graph places there has none, and `whole` already counts it): its prompts, its shape motifs, and its longer windows repeat or splice what `whole` holds.
-    const marginal = deriveCells(marginalStore(floored), graph);
-    const named = new Set(marginal.motifs.filter(({ level, steps }) => level === 'named' && steps.length === 1 && steps[0]?.identity !== null).map(({ motifId }) => motifId));
-    const motifs = new Map([...whole.motifs, ...marginal.motifs.filter(({ motifId }) => named.has(motifId))].map((motif) => [motif.motifId, motif]));
-    const order = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-    const cells = [...whole.cells, ...marginal.cells.filter(({ motifId }) => named.has(motifId))].sort((a, b) => order(a.motifId, b.motifId) || order(a.frameBucket, b.frameBucket) || order(a.grain, b.grain) || order(a.day, b.day) || EXPOSURE_CODES[exposureOfCell(a)] - EXPOSURE_CODES[exposureOfCell(b)]);
-    return { cells, motifs: [...motifs.values()].sort((a, b) => order(a.motifId, b.motifId)) };
+    const fold = cellsFold(graph);
+    fold.add(store);
+    return fold.finish();
 };
 /**
  * A local store with each shell step read as a deposit reads it (`projectedSteps`), so its named motifs are the ones the pool holds, and each call's key names as the wire sends them (`wireKeys`), so its shape cells are too.

package/dist/sessions/cells.d.ts

@@ -134,6 +134,13 @@ export interface CellSet {
     cells: Cell[];
     motifs: Motif[];
 }
+/** The tally half of `deriveCells`: `add` one run of sessions, then `finish`. */
+export interface CellFold {
+    add: (store: Store) => void;
+    finish: () => CellSet;
+}
+/** `deriveCells` as a fold: each `add` tallies one run of sessions into the same tallies, and `finish` sorts them. The runs must come in the order the whole store holds its rows, so sums of floats match. */
+export declare const cellFold: (graph?: RecallGraph) => CellFold;
 export declare const deriveCells: (store: Store, graph?: RecallGraph) => CellSet;
 export declare const serializeCells: (cells: readonly Cell[]) => string;
 /** What every read of one derive pass reads, and the snapshot it answers from. */