Commands

stratless mirror     a free read of you and your AI, changes nothing (--share for a card)
stratless init       keep your history, and build your profile
stratless profile    see the model of you, free and instant
stratless update     read what is new, rebuild and load it
stratless stop       turn it off, and unload the profile
stratless status     its own state, and what it has cost

mirror

$ stratless mirror

  You and your AI, measured

    you and your assistant    5,911 messages · 49 active days
    a median day              123 messages
    span                      2026-06-09 → 2026-07-27 · longest streak 49 days
    how you write             median 17 words · 8% four words or fewer · 42% questions
    what you keep typing      "go" 20× · "continue" 18× · "sure" 11×
    screenshots sent          205
    course corrections        2.49 / 100 messages
    tool declines             51
    friction days             44 of 49 active days
    not counted against you   63 permission stops · 33 system blocks
    busiest repo              stratless · across 6 repos · 50 branches
    tools it ran for you      27,655 calls · Bash 38% · Edit 26%
    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. 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.

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.
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 profile 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.

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

profile

stratless profile

profile is free to look at. It prints the last built profile instantly, at zero spend, under a header that carries the build’s own date and counts. It never builds and never loads: it shows you the current model of you, and it ends by saying honestly whether that profile is loaded into your assistant right now. Building and loading are update’s job.

There is nothing to configure and no flag to pass. If you have not built a profile yet, profile points you at stratless update.

update

stratless update            read what is new, rebuild and load the profile now
stratless update --weekly   auto-rebuild at most once a week (the default)
stratless update --daily    auto-rebuild at most once a day

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 profile. 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 one short call to your own assistant, a few cents; a refresh with nothing new spends nothing at all. 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.

The moments collect every session for free. The cadence governs only how often stratless phones your assistant to score and rewrite, 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 profile 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 profile is written only from what your history supports, and if the writer invents a number that is not in the evidence, or returns anything that does not read like a profile, the build is refused and your old profile stays loaded. Nothing malformed ever loads.

Two knobs, both optional: STRATLESS_SYNTH_EVERY changes how many new moments trigger a background rebuild (25 by default); STRATLESS_SYNTH_MODEL picks the model that writes the profile.

stop

stratless stop

The off switch. If a 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 and the profile is unloaded from your CLAUDE.md. Your HUMAN.md file is left as is; delete it yourself if you want it gone. Being able to shut it up completely, mid-run, is half of why you can trust it.

status

$ stratless status

  stratless status

    after-session refresh   on
    auto-rebuild            weekly · set with `stratless update --daily|--weekly`
    profile loaded          yes  ~/.claude/HUMAN.md

    recent builds
      2026-07-23 12:28 UTC   142 conv · 4,980 moments · 23 categories   (latest)
      2026-07-22 09:14 UTC   138 conv · 4,760 moments · 23 categories

    spend
      total           $0.28  ·  49k tokens  ·  3 calls  on your own claude
      by stage       naming $0.19 · writing $0.09

stratless’s own state: whether the refresh is on, how often it auto-rebuilds, whether your profile is actually loaded — and which build it is, by the file’s own # built stamp; a loaded profile that is older than the latest build gets flagged with the one command that fixes it — when it last built, and what it has spent of your borrowed claude. 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

stratless --version    print the installed version (short: -v)
stratless --help       the command list (also: -h, help)

Output through a pipe, or with NO_COLOR set, carries no color codes, so stratless status | grep loaded 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.