Commands

mirror

$ stratless mirror

  You and your AI, measured

    you and your assistant    6,177 messages · 52 active days
    a median day              122 messages
    span                      2026-06-09 → 2026-07-30 · longest streak 52 days
    how you write             median 17 words · 8% four words or fewer · 42% questions
    what you keep typing      "go" 23× · "continue" 19× · "sure" 11×
    screenshots sent          210
    course corrections        2.44 / 100 messages
    tool declines             57
    friction days             47 of 52 active days
    not counted against you   69 permission stops · 34 system blocks
    busiest repo              stratless · across 6 repos · 52 branches
    tools it ran for you      29,101 calls · Bash 38% · Edit 27%
    work it handed off        636 agent runs · Explore 46% · general-purpose 43%
    skills it loaded          54 times · research 17% · artifact-design 13%
    profile captures          100% of your moments

The measured portrait of you, across every conversation, read straight from your live history. It is pure arithmetic: no model call, no tokens, no setup, and it changes nothing on your machine, so you can run it before you have ever run init. Bare npx stratless (no verb) runs it too. course corrections is how often you cut in to redirect your assistant, per hundred messages you send. what you keep typing is your most-repeated exact messages, quoted back; it exists for your terminal only and never appears on the share card. not counted against you lists the interrupts that are not your friction (permission stops and system blocks), shown so nothing is silently dropped from the count. work it handed off counts the times your assistant gave a piece of the job to another agent instead of doing it itself, and names the kinds it used most; a spawn whose kind the transcript never recorded still counts as a run but is never given a label, and the kinds stay in your terminal, off the share card. It appears only if you delegate at all. skills it loaded counts the packaged procedures your assistant pulled in for a job, and names the ones it used most. It is deliberately phrased from the assistant’s side: a skill enters the record the same way whether you typed its name or your assistant chose it, so the row never claims the reach was yours. Skill names stay in your terminal too. profile captures appears once you have built a profile, and shows how much of you the current build’s patterns cover.

Add --share for a clean, screenshot-ready card of the universal numbers, with any repo name, project name, and anything you ever typed left out, so it is safe to forward.

tune

$ stratless tune

  Your tune — Claude Code pair

  Measured from this record: 8 rituals · 8 lessons · 9 rules · 1 win · 8 arrivals

  The sitting asks your own Claude Code once — about $0.08 of your plan. Proceed? [y/N] y

  5 skills proposed from the evidence

  THE PACK — every entry is a skill file; styles are always-on skills
    ⚙ grep-sed-loop  (occurrences 778 · sessions 234)  new
      Replace the manual grep-sed-grep chase with a single structured search-then-edit pass.
    ⚙ merged-watch-ci  (count 24 · sessions 16)  new
      Treat a merge as the start of a watch obligation, not the end of the task.
    ⚙ double-check-before-done  (count 198)  new
      Verify the actual state of the work before claiming it is done.
    ⚙ plain-answer  (count 224)  new
      Answer meaning-questions in plain direct language first.
    ⚙ terse-imperative  (count 329)  new
      Treat a short imperative as full authorization and reply with action.

  writes to ~/.claude/skills · nothing else touched
  every receipt is your own count · remove any time: stratless stop

  Install? [y/N] y

  tune installed. 5 files written.

  Your tune — Codex pair

  Measured from this record: 8 lessons · 1 win

  The sitting asks your own Codex once — about $0.08 of your plan. Proceed? [y/N] n

  nothing asked, nothing spent for this pair.

Measure, report, install — one sitting per pair. Every assistant on your machine gets its own sitting, in sequence, and nothing crosses between them: each pair’s evidence is measured from its own record, consulted by its own assistant on its own plan, and installed through its own tool’s skill door — ~/.claude/skills for Claude Code, ~/.codex/skills for Codex, the same skill format both ways (measured against the live tools). Declining one pair’s spend never touches another’s sitting.

The first movement is free: tune puts five questions to each record — what you do repeatedly (rituals), what went wrong and cost you (lessons), what you keep having to ask for (rules), what you approved fast (wins), what vocabulary newly arrived (arrivals) — all by arithmetic, all before anything is asked or spent. Then it quotes the one paid moment plainly, and only on your yes consults the guide: your own assistant reads the measured evidence and proposes skills. Nothing is asked of you but that yes — the record is the input.

Everything the guide proposes is disposed of by code, not taste. A proposal that cites no evidence dies. A quote that is not verbatim from your own recorded words dies. A numeral in its prose dies — every count you see is stamped by code from the receipts, never written by the model. Rejections are printed with their reasons, never silently dropped. What survives is the report you see above: each skill with the count that earned it, each file path it would write, and one question. The default is no. Nothing lands without a typed yes on a real terminal, and nothing outside the named paths is ever touched.

Skills your own setup already covers are never duplicated — the sitting reads what is installed first, by name and by substance, and marks anything an existing skill of yours already does as kept, naming your skill. Your skills are yours; it never edits or replaces them. Run tune again after an update and the sitting runs on the fresh evidence, showing exactly what changed — new, updated, unchanged — before asking again. Every installed file says in its own text how to remove it — delete the file, or stratless stop removes the whole tune along with everything else.

Both pairs sit today. The Codex delivery leg shipped the way every leg ships — from measurement against the live tool: codex-cli discovers an externally written skill file in ~/.codex/skills immediately, with no approval step, in the same SKILL.md format Claude Code reads.

init

npx stratless init

The one interactive moment. It keeps your history, shows you a free read of yourself, quotes the full build honestly, and takes a single yes or no.

1. It stops the reaper. Claude Code deletes your transcripts after 30 days, per file, so your history rots from the back even in a project you open every day. init sets cleanupPeriodDays to 3650 in ~/.claude/settings.json and copies every transcript it can still reach into ~/.stratless/archive/, out of the cleanup’s way. Whatever has already aged out is gone. This is the only part you cannot do later. Codex has no such timer, so nothing is switched off there; init still keeps its own copy of your rollouts.

   init does this for each assistant it finds on your machine, and only those. One you do not have is left alone entirely: no config file, no hook, nothing.

2. It turns the after-session refresh on. From here, when a session ends, stratless reads what is new in the background and keeps your record’s evidence current. That is on the moment init finishes; stop is the one switch that turns it off.

3. It reads you for free. Before anything costs a cent, init prints what it can already see from the history it just froze, computed with no model call: how much you talk to your assistant, how you write, how often you course-correct it.

4. It quotes the build, then asks once. It shows an honest estimate (moments, dollars, minutes, all on your own claude) and itemizes the one-time engine download (~3MB runtime + ~34MB model), then asks Build your profile now? [y/N]. The default is no. Say yes and it fetches the engine in the foreground and builds now; say no and nothing is spent, nothing is downloaded, the free read stays, and the refresh keeps it current. The paid build never runs without that explicit yes on a real terminal. What it builds is the evidence — the internal, per-pair record of your patterns that the sitting reads; it is never loaded into your assistant.

To undo: set cleanupPeriodDays back to 30, run stratless stop, and delete ~/.stratless/archive/. That is everything it touched.

update

Reads every session that is new since last time, places each new moment against the patterns already found in your own history, and rebuilds the evidence. Placing is free and offline — it runs on the local model, so no matter how much you talked, sorting it costs nothing. Rewriting the file afterwards is free too in the steady state — every row’s wording is voiced once and re-stamped from a cache, so a rebuild only pays (one short call, cents) when your history earns a genuinely new row; a refresh with nothing new spends nothing at all. One more paid moment exists while a record is young: a map built on thin history starts small, and when your history could support roughly double the patterns it supported at the last build, the refresh rebuilds the map — cents, announced in status, covered by the consent you gave at the door. Each rebuild doubles the distance to the next, so they space out on their own and a mature map is never touched. Run by hand in a terminal, it rebuilds now. Run by the after-session refresh, it rebuilds on a cadence: at most once a week by default, or once a day with --daily. update itself always rebuilds immediately, whatever the cadence is set to; the flags only change how often the background refresh acts on its own.

--rebuild is the full cold rebuild, first-class: re-cluster the whole pile, re-name, re-voice — the map re-derived from scratch instead of grown. It prints each built pair’s own estimate first and takes a typed yes on a real terminal before anything is touched; a declined quote changes nothing, and it never runs from the background hook. What it clears is exactly the derived state — your archive, your moments, and the fit ledger all stay — and the ordinary build path then rebuilds from the whole record.

The evidence is internal: it stays in ~/.stratless/, the sitting reads it, and nothing loads it into your assistant. If an older install left a loaded pointer in your CLAUDE.md or AGENTS.md, the next refresh removes it and says so.

The moments collect every session for free. The cadence governs only how often stratless re-scores the pile and re-stamps the file, so a busy week costs the same as a quiet one.

The work runs in one background worker that update wakes and watches. Your terminal is a window onto it, not the engine. On a normal run you notice nothing: the same progress lines, the same closing summary. The difference is at the edges. Press Ctrl-C or close the terminal and the display detaches, but the work finishes anyway, and the evidence lands a few minutes later. There is no daemon; the worker does its bounded job and exits. Sleep pauses it for free, and nothing already scored is ever lost.

Every run that spends closes with its receipt: tokens, the API-equivalent cost, and which models actually ran. status keeps the most recent one, so even the silent after-session refreshes stay accounted for.

A rebuild is a derivation, not an impression. The model supplies wording, while code supplies every count, date, and quantitative receipt. If model-authored wording contains a numeral, or the result does not read like a profile, the build is refused and the previous evidence stands. Nothing malformed is ever written over it.

stop

stratless stop

The off switch. If a verified rebuild is running right now, it is stopped within seconds: spending halts immediately, and nothing paid-for is wasted, since every moment already scored is banked and restarting later re-reads at most one small chunk. Then the after-session refresh is removed, the tune — every minted skill, plus any style blocks and import markers an older install carried — is removed, and any profile pointer an older install left in your CLAUDE.md or AGENTS.md is cleared. Your HUMAN.<assistant>.md files are left as is; delete them yourself if you want them gone.

Before signalling a PID, stop proves that it is the worker recorded by the lock. If that identity cannot be verified—or the lock belongs to a foreground command in another terminal—it refuses to signal the process, names the PID, and exits non-zero. Hooks are still removed and the tune still comes out, but it does not claim stratless is fully off while anything remains alive.

Codex keys hook approval by position. If you added another SessionEnd hook after stratless, removing ours shifts that later hook, so stop warns that Codex will ask you to approve it again. The hook is preserved; only its position and therefore its approval changed.

status

$ stratless status

  stratless status

    after-session refresh   on
    auto-rebuild            weekly · set with `stratless update --daily|--weekly`
    evidence                Claude Code  yes  built 2026-08-09 09:13 UTC · ~/.stratless/HUMAN.claude-code.md
                            Codex        yes  built 2026-08-09 09:13 UTC · ~/.stratless/HUMAN.codex.md
    tune installed          yes  4 skills + 0 styles · refresh: stratless tune

    recent builds
      Claude Code
      2026-08-09 09:13 UTC   161 conv · 6,990 moments · 30 categories   (latest)
      2026-08-08 08:39 UTC   161 conv · 6,984 moments · 30 categories
      Codex
      2026-08-09 09:13 UTC   9 conv · 255 moments · 3 categories   (latest)

    spend
      total          $2.09  ·  427k tokens  ·  92 calls  on your own assistants
      by stage       naming $0.62 · writing $1.02 · patch voicing $0.10 · consult $0.16

stratless’s own state: whether the refresh is on, how often it auto-rebuilds, which build each pair’s evidence carries — by the file’s own # built stamp — what a sitting has installed, when it last built, and what it has spent of your borrowed claude. The evidence line names each assistant on your machine separately, because each pair keeps its own file: if you run one assistant you see one row and are never told about a tool you do not use; if you run two, a pair with no evidence yet says so rather than one pair answering for both. The tune installed line counts what is actually on disk, by the mint mark in the files themselves. Tokens come first, because a subscription spends quota, not dollars; the dollar figure is the API-equivalent, labelled as exactly that and split by stage. The meter also confesses its blind spots: if a call ever runs on a fallback model, or a cache file on disk is damaged, status says so rather than showing a confident number. Every line is read locally; plain status is fully offline and spends nothing.

Add --check and it makes exactly one announced request to the npm registry to tell you whether a newer version exists: you ask, it checks, on screen. Beyond your own claude, the only other thing that ever touches the network is the one-time engine download at init (runtime + model, itemized), which you are asked about before it happens. See Privacy.

Global flags

Output through a pipe, or with NO_COLOR set, carries no color codes, so stratless status | grep evidence gives you clean text. An unknown flag or a stray argument stops with a loud error and a did-you-mean, never a silent misfire. stratless profile and stratless mcp retired when the profile became internal evidence; typing either points you at the sitting rather than erroring.