@ucsandman/legcli 0.13.1 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,120 @@
 # Changelog
 
+## 0.15.0 (2026-09-18)
+
+A second login keeps the conversation, and the runtime does less work per
+minute.
+
+- **A hand-off to your other claude login keeps the conversation.** `leg
+  accounts add claude <name>` now junctions Claude Code's `projects` store
+  into the account beside the harness directories, so the second login sees
+  the same conversations and the same auto-memory as the first. At a weekly
+  or Fable wall the terminal moves to that login with `claude --resume <id>`
+  under its `CLAUDE_CONFIG_DIR` and no bundle prompt, and the timeline says
+  `claude/fable → claude/work (kept the conversation)`. One rule decides it
+  for the terminal and for the board's picker (`keepsConversation` in
+  `src/usage.mjs`): a same-login downshift, or another login whose home can
+  see the transcript file, checked at the switch. An account made by an
+  older Leg gets the junction the next time it starts. `leg history` lists a
+  junctioned store once. codex still takes the bundle across logins.
+- **`leg digest`: what happened while you were away.** The default window is
+  8 hours (`--since 2d`, `--since 30m`, an ISO time; `--json`; `GET
+  /api/digest?since=` on the board, owner only). The first line is the volume
+  it was read from, then what needs you (a live terminal waiting on a
+  question, a card parked for a human, a failed card, a lost terminal, in
+  that order), then one block per repository with every terminal, card and
+  landing that moved and the events worth a line, and last the walls
+  standing now. Read only, over the records already on disk; a window with
+  nothing in it says so with its counts.
+- **The runtime does less work per minute, measured before and after.** A
+  profiler (`fs` and `child_process` counters plus `--cpu-prof`) sat on every
+  path first; the numbers are medians on one Windows 11 box, Node 24, with a
+  fake agent, an isolated `LEG_HOME` and a board on 4800–4899, and every
+  change carries a test that was seen failing without it.
+  - `leg --version` and every other command loaded 68 modules before `main()`
+    ran. `bin/leg.mjs` now imports each command group inside its own branch,
+    `src/limits.mjs` loads its fixture tree on first use, and the launcher
+    asks a new leaf (`src/scheduler-status.mjs`) whether the scheduler runs
+    instead of pulling in the orchestrator. `leg --version`: 127 → 52 ms
+    wall, 79 → 0 ms CPU after Node's own boot, 254 → 4 fs calls, 68 → 1
+    project module; `leg sessions ls` 116 → 75 ms; `leg card ls` 117 → 70 ms
+    (`test/cli-lazy.test.mjs`).
+  - An idle terminal spawned 59.5 git processes a minute (six per poll round)
+    and blocked its own event loop 4.4–10.3 s of every minute doing it. One
+    `git status --porcelain=v2 --branch` (`src/git.mjs`) now carries the
+    head, the branch, the dirty list and the upstream's own ahead count:
+    10.9 git processes a minute, 2.1 s of git wall time, terminal CPU 1.7 →
+    0.1 s a minute (`test/git-status.test.mjs`, `test/attach-perf.test.mjs`).
+  - The first `leg <agent>` of the day waited for the board it had just
+    started (polling `/api/health` for about a second) before the agent got
+    its first instruction. The agent starts at once and the wait runs behind
+    it; a session that exits within a second still claims the board's
+    pidfile before it goes. Time to the agent on that launch: 1,220 → 261 ms.
+  - The two-minute bundle checkpoint ran the python CLI synchronously inside
+    the poll tick, freezing limit detection and every board button for as
+    long as it took (up to its 120 s timeout). It runs beside the tick now,
+    one at a time, and the hand-off save waits for a checkpoint still
+    writing.
+  - `installedAgents()` ran `<agent> --version` for every agent on `PATH` at
+    every launch (an 8 s budget each); the answer is kept for a day in
+    `$LEG_HOME/installed.json`, keyed by the resolved bin. A `LEG_<AGENT>_BIN`
+    override is never cached.
+  - An idle board with 43 terminals and one page open rebuilt the whole
+    sessions view every 10 s whether or not a byte had changed: 7,294 fs
+    calls, 8 git processes and 1.1 CPU seconds a minute for nothing. The
+    health tick now asks the same stat fingerprint the watcher asks, runs the
+    liveness pass itself (a runner that died moves no file), and pushes only
+    when the answer changed; a card that starts or stops waiting on a human
+    forces the one push the fingerprint cannot see. Idle: 7,294 → 4,824 fs
+    calls, 8.2 → 0 git processes, 1.14 → 0.54 CPU seconds and 6 → 0 sessions
+    pushes a minute (what remains is the liveness pass and the scheduler's
+    own tick). One
+    sessions view also read the usage files 143 times (once per rung per
+    terminal, then again for capacity and the accounts panel) and probed three
+    paths per terminal for a synthesis file; one reader per view and one
+    `readdir` per checkout: `/api/sessions` 53 → 34 ms, 511 → 212 fs calls per
+    answer, and each row drops seven runner-bookkeeping fields nothing on the
+    board read (8% off every push; `GET /api/sessions/<id>` keeps the whole
+    record).
+  - A cold `/api/worktrees` ran up to forty git processes on the board's one
+    event loop: 9–25 s in which no stylesheet, click or SSE frame was served.
+    The list is gathered through `execFile`, four at a time, one refresh per
+    query, and a caller that arrives while a refresh runs gets the last list.
+    Worst `/api/health` during a cold call: 11.8 → 3.2 s; the rest is the
+    history index's synchronous `listHistory`, still open. `/api/trunk`
+    (polled every 2 s by the floor) is cached 15 s and cleared by any card
+    change or landing: 27.5 → 0.5 ms. A terminal's detail drawer ran one `git
+    ls-files` per file it touched every 3 s; one process for the list: 1,247 →
+    305 ms.
+  - `updateSession` takes the lock budget `run.json` already had (250 tries, a
+    10 s steal) instead of running unlocked after 1.2 s; `control.json` is
+    cleared under its lock at exit; `src/handoff.mjs` takes `scrub` from
+    `src/redact.mjs` instead of the card runner; the 12-leg stop names the
+    bundle and `leg resume` instead of promising a hand-off a fresh launch
+    never performed.
+- **The README's hand-off step 3 said one bundle per leg.** The code has
+  written one bundle per session, updated in place, since 0.2.0; the sentence
+  now says so. `docs/concepts.md` and the `src/sessions.mjs` header also said
+  the runner was the only writer of `session.json`; the usage poller, the
+  claude hooks and a board action patch it too, under one lock, and both now
+  say that.
+
+## 0.14.0 (2026-09-18)
+
+The 14-day trial is back.
+
+- **Free for 14 days, no key, no card.** The first `leg <agent>` on a machine
+  starts a 14-day trial with every gate open, Team's `leg share` included, and
+  records it in `$LEG_HOME/trial.json`. `leg license status` shows the days
+  left without starting the clock. After the trial, or with a refused key once
+  it is over, a session exits 4 with the price and the 30-day guarantee, which
+  stays as the second net after buying. Deleting the file resets the clock,
+  which is the known limit of an offline trial and is accepted. The license
+  agreement gains the trial clause; the site, README, support page and
+  `llms.txt` say "free for 14 days" where they said "no trial".
+- **The README stops calling the repository private.** It has been public at
+  github.com/ucsandman/legcli; two sentences still said otherwise.
+
 ## 0.13.1 (2026-09-18)
 
 A one-line fix in the terminal and the marketing site brought up to what 0.13.0 does.

package/LICENSE

@@ -9,6 +9,8 @@ install or use Leg.
 
 1. License. When you buy a license we grant you a non-exclusive,
    non-transferable license to install and use Leg as follows.
+   Trial: before buying, one person may install and use Leg to evaluate it
+   for 14 days from its first use on a machine, on the Team terms below.
    Personal: one named person, on any number of machines that person uses.
    Team: one named person per seat purchased. A Team license also covers use
    of the shared board (leg share) by the people holding seats. A Personal

package/README.md

@@ -23,7 +23,7 @@ files and regions). `leg claude --model opus` is
 1. **A board.** Opened once in your browser, reused after that. Every Leg
    session in every terminal is a row on it, and the row's register reads
    status, repo on branch, uncommitted and unpushed counts, agent and model,
-   and how long it has been quiet: `waiting on you  baton on main  dirty 3
+   and how long it has been quiet: `waiting on you  leg on main  dirty 3
    ahead 2  claude/fable`. Under that come the prompt, the one thing worth
    knowing, the files it is touching and the usage bucket that will stop it.
    Capacity is one strip at the top rather than a region, with the login
@@ -138,8 +138,8 @@ agent name passes straight through (`leg codex -m gpt-5.3-codex-spark`,
 through unchanged, and your settings file is never edited: Leg's hooks ride
 in a separate per-session `--settings` file.
 
-The source repository is private. Leg is commercial, source-available
-software: every `.mjs` file that runs is in the package you just installed, at
+Leg is commercial, source-available software, and the source is on
+[GitHub](https://github.com/ucsandman/legcli): every `.mjs` file that runs is in the package you just installed, at
 `$(npm root -g)/legcli/src`, and the license lets you read it and modify
 your own copy. There is nothing compiled, minified or bundled to see through.
 
@@ -179,12 +179,20 @@ presenting it as current.
 3. **Bundle.** Leg writes structured notes (task, the last messages from the
    transcript, `git diff --stat`, dirty files, files edited this session, recent
    commits, why it stopped) and runs `context-handoff-bundle save --repo-local`
-   with one slug per leg; each save writes its own timestamped bundle next to
-   the last one. A checkpoint of the same bundle is taken every two minutes
-   while the session is active. If the session maintained `.leg/SYNTHESIS-<session-id>.md`,
+   with one slug per session, updated in place (`--update <slug>`) at every
+   checkpoint, about every two minutes while the session is active, and at
+   every warning, limit and hand-off. If the session maintained `.leg/SYNTHESIS-<session-id>.md`,
    Leg inlines it into the resume file as a `## Synthesis` section ahead of the raw dump.
-4. **Switch.** The agent process is stopped, the terminal is restored, and the
-   next option starts in the same terminal with a short pointer prompt:
+4. **Switch.** The agent process is stopped and the terminal is restored. Two
+   claude destinations keep the conversation itself instead of the bundle: a
+   weaker model on the same login (`claude --resume <id> --model <alias>`),
+   and another claude login you added with `leg accounts add`, which sees the
+   same transcript through the `projects` junction the account carries
+   (`claude --resume <id>` under that login's `CLAUDE_CONFIG_DIR`). A weekly
+   or Fable wall on one login then continues on the other with the
+   conversation it already had, and the timeline says `kept the
+   conversation`. Every other rung starts in the same terminal with a short
+   pointer prompt:
    read `.leg/RESUME-<session-id>.md` (the `context-handoff-bundle load`
    output, the `## Synthesis` section if present, and the reason for the switch),
    check `git status` and `git diff`, continue, do not ask the human to restate
@@ -361,6 +369,23 @@ it prints how much it read beside the answer (`14 terminals and 3 cards, 812
 events read`) so an empty trail cannot be mistaken for a quiet week. Owner
 only: the trail names repositories and people.
 
+### What happened while you were away
+
+`leg digest` (default window 8 hours; `--since 2d`, `--since 30m`, or an ISO
+time; `--json` for the record; `GET /api/digest?since=` on the board, owner
+only) is the trail read the other way round: grouped by repository, what
+needs you first. The first line is the volume it was read from (`3
+terminals, 2 cards, 1 landing, 412 events read (66 sessions and 9 cards on
+disk)`), then `needs you`: a live terminal waiting on a question, a card
+parked for a human, a card that failed, a terminal that was lost, in that
+order and each with how long ago. Then one block per repository: every
+terminal that moved in the window with its login and model, state, turns,
+files, commits ahead and the events worth a line (a wall, a hand-off and
+whether it kept the conversation, an all-out wait, the end), every card with
+its last event, every landing with who pressed Land, and last the walls
+standing right now with their reset times. Nothing new is recorded; a window
+with nothing in it says so with its counts.
+
 ## The board
 
 `leg <agent>` opens it; `leg open` reopens it; `leg down` stops it.
@@ -445,19 +470,30 @@ matrix (which agents list, show messages, continue) and every file read are in
 
 Optional. `leg accounts add claude work` creates
 `~/.leg/accounts/claude/work`, junctions your `hooks`, `skills`, `agents`,
-`commands`, `plugins`, `rules`, `scripts`, `output-styles` and `tools` into it,
-copies `settings.json`, `CLAUDE.md` and the status-line scripts (refreshed from
-your real `~/.claude` before every launch), and prints one line to paste:
+`commands`, `plugins`, `rules`, `scripts`, `output-styles`, `tools` and
+`projects` into it, copies `settings.json`, `CLAUDE.md` and the status-line
+scripts (refreshed from your real `~/.claude` before every launch), and prints
+one line to paste:
 
 ```
 $env:CLAUDE_CONFIG_DIR='C:\Users\you\.leg\accounts\claude\work'; claude auth login
 ```
 
+`projects` is Claude Code's conversation store, so the second login sees the
+same conversations and the same auto-memory as the first, and a hand-off from
+one login to the other keeps the conversation: the terminal moves to `work`
+with `claude --resume <id>` and no bundle prompt. That is the whole point of a
+second 20x login when the Fable or the weekly window on the first one is out.
+An account made by an older Leg gets the junction the next time it starts.
+Claude Code writes that directory; Leg only reads it.
+
 Same for codex (`CODEX_HOME`; `config.toml`, `AGENTS.md`, `skills`, `prompts`,
-`rules`, `plugins`, `agents`, `hooks`, `memories` shared). agy 1.2.0 has no
-config-directory override, so it stays one account. Only the login lives in
-the account directory; `leg accounts rm` removes the junctions and the
-directory and never touches your real home.
+`rules`, `plugins`, `agents`, `hooks`, `memories` shared; a codex hand-off
+still takes the bundle, because `codex resume` under a second `CODEX_HOME`
+has not been observed). agy 1.2.0 has no config-directory override, so it
+stays one account. Only the login lives in the account directory;
+`leg accounts rm` removes the junctions and the directory and never touches
+your real home.
 
 The terms, as published (effective dates below):
 
@@ -537,6 +573,8 @@ leg history [ls] [--provider p] [--repo r] [--search q] [--managed|--external] [
                                      every conversation on this machine, Leg's own and the agents' own (read only)
 leg history show <id> [--messages n] [--json] | continue <id> [agent args…] | refresh [--full] | providers
 leg worktrees [--repo <path>] [--no-dirty] [--json]   every checkout: git's, Leg's, the conversations' (read only)
+leg digest [--since 8h|2d|<iso>] [--json]   what happened while you were away: needs-you first, then every
+                                     terminal, card, landing and wall in the window, by repository (read only)
 leg accounts ls                      logins and their 5h/7d usage
 leg accounts add <claude|codex|grok> <name> | rm <agent> <name> | terms
 leg harness status|inspect|check|explain|history [--json]   the portable harness, read-only
@@ -697,8 +735,8 @@ drift. CI waits for the Ubuntu and Windows test matrix, validates both
 when that version is missing and newer than the stable `latest`. Existing
 versions skip cleanly; older, prerelease, lockstep, and registry-error cases
 fail the job. The npm trusted publisher is bound to `ucsandman/legcli` and
-`.github/workflows/ci.yml` (bind `leg-agents` the same way). The repository
-stays private, so publication uses `--provenance=false`.
+`.github/workflows/ci.yml` (bind `leg-agents` the same way). Publication
+uses `--provenance=false`.
 
 ## Privacy and attribution
 
@@ -714,17 +752,19 @@ Leg is commercial software under the [Leg License Agreement](LICENSE).
 It ships as readable JavaScript so you can see what it does on your machine,
 and you may modify it for your own use, but not redistribute it or work
 around the license check. Versions 0.2.0 and 0.3.0 were published under MIT
-and remain available. The version in this source tree is 0.13.1; see
+and remain available. The version in this source tree is 0.15.0; see
 [npm](https://www.npmjs.com/package/legcli) for published versions and
 [CHANGELOG.md](CHANGELOG.md) for release notes.
 
-Using it needs a license: **Personal, $79 once**, one human on any number of
+The first 14 days are a **free trial**: install it, type `leg claude`, and
+everything in both plans is on, with no key and no card. The clock starts on
+your first session and `leg license status` shows what is left. After that
+it needs a license: **Personal, $79 once**, one human on any number of
 machines, every release for 12 months and the version you have keeps working
 after that; **Team, $12 per seat per month**, Personal plus `leg share` for
 more than one human on the board. Buy at the site, then
-`leg license activate <key>`. There is no trial; there is a **30-day
-money-back guarantee**, so the way to evaluate Leg is to use it on real work
-and ask for a refund if it does not earn its place. A key is a signed token
+`leg license activate <key>`. There is also a **30-day money-back
+guarantee** after buying, no reason required. A key is a signed token
 checked offline with the public key in `src/license.mjs`; only a Team key
 renewal talks to the site. The bare agent CLIs are never affected by any of
 this; only what Leg adds is licensed.