transcripto 0.1.4__tar.gz → 0.1.5__tar.gz

{transcripto-0.1.4/transcripto.egg-info → transcripto-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.4
+Version: 0.1.5
 Summary: Search everything your coding agents ever did, grade your own prompts, and price your decisions. Local, stdlib-only, your data never leaves the machine.
 Author: Oscar Morke
 License: MIT
@@ -29,7 +29,7 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
-> **which build you got.** `uvx transcripto --version` should print **0.1.3**. If `--version`
+> **which build you got.** `uvx transcripto --version` should print **0.1.4**. If `--version`
 > is not a recognised flag at all you are on 0.1.1, which predates `trace`, Cursor support and
 > this README. `uvx --refresh transcripto` forces a fresh resolve past uv's cache.
 >
@@ -324,10 +324,10 @@ thinking about X across ALL my sessions", in your own words only.
 $ transcripto find USER-JOURNEY.md          # run 2026-08-29
 USER-JOURNEY.md  4 touches across sessions (3 were writes/edits)
 
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md            abd9e871
-2026-08-21  WROTE  ~/…/Obsidian LIFE/00 Dashboard/suite-user-journey.md       0f845ede
-2026-08-27  read   ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
-2026-08-27  WROTE  ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
+2026-08-20  WROTE  ~/CODE/demo/USER-JOURNEY.md                              abd9e871
+2026-08-21  WROTE  ~/CODE/demo/docs/onboarding-notes.md                       0f845ede
+2026-08-27  read   ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
+2026-08-27  WROTE  ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
 ```
 
 the file you lost, found across every session you ever ran, with the session id

{transcripto-0.1.4 → transcripto-0.1.5}/README.md

@@ -11,7 +11,7 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
-> **which build you got.** `uvx transcripto --version` should print **0.1.3**. If `--version`
+> **which build you got.** `uvx transcripto --version` should print **0.1.4**. If `--version`
 > is not a recognised flag at all you are on 0.1.1, which predates `trace`, Cursor support and
 > this README. `uvx --refresh transcripto` forces a fresh resolve past uv's cache.
 >
@@ -306,10 +306,10 @@ thinking about X across ALL my sessions", in your own words only.
 $ transcripto find USER-JOURNEY.md          # run 2026-08-29
 USER-JOURNEY.md  4 touches across sessions (3 were writes/edits)
 
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md            abd9e871
-2026-08-21  WROTE  ~/…/Obsidian LIFE/00 Dashboard/suite-user-journey.md       0f845ede
-2026-08-27  read   ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
-2026-08-27  WROTE  ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
+2026-08-20  WROTE  ~/CODE/demo/USER-JOURNEY.md                              abd9e871
+2026-08-21  WROTE  ~/CODE/demo/docs/onboarding-notes.md                       0f845ede
+2026-08-27  read   ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
+2026-08-27  WROTE  ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
 ```
 
 the file you lost, found across every session you ever ran, with the session id

{transcripto-0.1.4 → transcripto-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "transcripto"
-version = "0.1.4"
+version = "0.1.5"
 description = "Search everything your coding agents ever did, grade your own prompts, and price your decisions. Local, stdlib-only, your data never leaves the machine."
 readme = "README.md"
 requires-python = ">=3.9"

{transcripto-0.1.4 → transcripto-0.1.5/transcripto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.4
+Version: 0.1.5
 Summary: Search everything your coding agents ever did, grade your own prompts, and price your decisions. Local, stdlib-only, your data never leaves the machine.
 Author: Oscar Morke
 License: MIT
@@ -29,7 +29,7 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
-> **which build you got.** `uvx transcripto --version` should print **0.1.3**. If `--version`
+> **which build you got.** `uvx transcripto --version` should print **0.1.4**. If `--version`
 > is not a recognised flag at all you are on 0.1.1, which predates `trace`, Cursor support and
 > this README. `uvx --refresh transcripto` forces a fresh resolve past uv's cache.
 >
@@ -324,10 +324,10 @@ thinking about X across ALL my sessions", in your own words only.
 $ transcripto find USER-JOURNEY.md          # run 2026-08-29
 USER-JOURNEY.md  4 touches across sessions (3 were writes/edits)
 
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md            abd9e871
-2026-08-21  WROTE  ~/…/Obsidian LIFE/00 Dashboard/suite-user-journey.md       0f845ede
-2026-08-27  read   ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
-2026-08-27  WROTE  ~/CODE/hack-fleet-ata/docs/USER-JOURNEY.md                 cddfde29
+2026-08-20  WROTE  ~/CODE/demo/USER-JOURNEY.md                              abd9e871
+2026-08-21  WROTE  ~/CODE/demo/docs/onboarding-notes.md                       0f845ede
+2026-08-27  read   ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
+2026-08-27  WROTE  ~/CODE/demo-api/docs/USER-JOURNEY.md                       cddfde29
 ```
 
 the file you lost, found across every session you ever ran, with the session id

{transcripto-0.1.4 → transcripto-0.1.5}/transcripto.py

@@ -5,7 +5,7 @@ Indexes coding-agent transcripts (Claude Code ~/.claude/projects, Codex ~/.codex
 into a local SQLite full-text index. Stdlib only. No network. Your data never
 leaves the machine.
 """
-import sys, os, json, glob, re, sqlite3, argparse
+import sys, os, json, glob, re, sqlite3, argparse, math
 from datetime import datetime, timezone
 
 # The tool ships under two console scripts (`transcripto` and `trace`) and is also
@@ -25,7 +25,7 @@ PROG = _prog()
 # packaging. A stranger who reads the README on GitHub and installs from PyPI can be
 # holding a different build than the one the README describes, and until this flag
 # existed there was no way for them to tell which.
-VERSION = "0.1.4"
+VERSION = "0.1.5"
 
 USAGE = """
   %(p)s index                 build / refresh the index (incremental)
@@ -285,22 +285,42 @@ def _day(ts):
 
 
 def cmd_search(args):
+    """Your own prompts first, and never call a machine record "you".
+
+    The label used to be `"you" if role == "user"`. On a real corpus 93,004 rows
+    carry role='user' and only 4,218 were typed: the label was wrong on 95.5% of
+    them, on the second command a curious reader runs, in a tool whose whole
+    argument is the difference between what you wrote and what the machine did.
+    `is_human` already existed and every other command used it.
+
+    Hits you typed sort first, because those are the ones worth finding.
+    """
     con = connect()
     try:
         rows = con.execute(
-            "SELECT m.ts,m.project,m.role,m.cwd,snippet(messages_fts,0,'\033[1m','\033[0m','…',14)"
+            "SELECT m.ts,m.project,m.role,m.is_human,m.cwd,"
+            " snippet(messages_fts,0,'\033[1m','\033[0m','…',14)"
             " FROM messages_fts JOIN messages m ON m.id=messages_fts.rowid"
-            " WHERE messages_fts MATCH ? ORDER BY m.ts DESC LIMIT ?",
+            " WHERE messages_fts MATCH ?"
+            " ORDER BY m.is_human DESC, m.ts DESC LIMIT ?",
             (_match(args.query), args.limit)).fetchall()
     except sqlite3.OperationalError as e:
         print("search error:", e); return
     if not rows:
         print("no matches. try `%s index` first, or broader terms." % PROG); return
-    for ts, proj, role, cwd, snip in rows:
-        repo = os.path.basename(cwd) if cwd else proj
-        who = "you" if role == "user" else "agent"
-        print("\033[2m%s\033[0m  \033[36m%s\033[0m  %-5s  %s"
-              % (_day(ts), repo, who, " ".join(snip.split())))
+    for ts, proj, role, human, cwd, snip in rows:
+        repo = os.path.basename(cwd.rstrip("/")) if cwd else proj
+        if human:
+            who, colour = "you", "\033[1m"
+        elif role == "user":
+            # role='user' but nobody typed it: a tool result or a harness injection.
+            who, colour = "harness", "\033[2m"
+        else:
+            who, colour = "agent", "\033[2m"
+        print("\033[2m%s\033[0m  \033[36m%-16s\033[0m %s%-7s\033[0m %s"
+              % (_day(ts), repo[:16], colour, who, " ".join(snip.split())))
+    typed = sum(1 for r in rows if r[3])
+    print("\n\033[2m%d of %d hits are prompts you typed.\033[0m" % (typed, len(rows)))
 
 
 def _repo(cwd, proj):
@@ -469,41 +489,112 @@ def cmd_trace(args):
 
 
 def cmd_sessions(args):
+    """List the sessions YOU typed in. The rest get one line, not eighteen rows.
+
+    This used to list every session by recency. On a real corpus 1,306 of 1,530
+    sessions contain no typed prompt at all, so 8 of 18 rows printed
+    "(no prompt you typed)" on the command most likely to be somebody's first
+    screenshot. Those rows were not a rendering bug. 85% is the finding, and
+    listing machine sessions in date order was burying it.
+
+    --all brings them back, because sometimes you want the subagent run.
+    """
     con = connect()
+    HUMAN = ("is_human=1 AND text!='' AND text NOT LIKE '<command-name>%'"
+             " AND text NOT LIKE '<local-command-%'")
+    having = "" if getattr(args, "all", False) else (
+        " HAVING SUM(CASE WHEN " + HUMAN + " THEN 1 ELSE 0 END) > 0")
     rows = con.execute(
-        "SELECT session_id,project,MAX(ts) mx,COUNT(*) FROM messages"
-        " GROUP BY session_id ORDER BY mx DESC LIMIT ?", (args.limit,)).fetchall()
-    for sid, proj, mx, cnt in rows:
-        # Same gate the rest of the tool sells: the opening ask is the first turn
-        # the OPERATOR typed (is_human=1), not the first `type: user` record. Without
-        # it the column filled up with `<command-name>/clear</command-name>` — a slash
-        # command the harness wrote, printed under a heading that says "opening ask".
-        # Slash commands clear is_human on most harnesses but not all, so the
-        # wrapper is excluded by name too, and a run of them is skipped rather than
-        # taken as the title.
+        "SELECT session_id,project,MAX(ts) mx,COUNT(*),"
+        " SUM(CASE WHEN " + HUMAN + " THEN 1 ELSE 0 END) typed,"
+        " MAX(cwd) FROM messages GROUP BY session_id" + having +
+        " ORDER BY mx DESC LIMIT ?", (args.limit,)).fetchall()
+    for sid, proj, mx, cnt, typed, cwd in rows:
         t = con.execute("SELECT text FROM messages WHERE session_id=? AND role='user'"
-                        " AND is_human=1 AND text!='' AND text NOT LIKE '<command-name>%'"
-                        " AND text NOT LIKE '<local-command-%' ORDER BY ts LIMIT 1",
-                        (sid,)).fetchone()
-        title = (t[0][:90].replace("\n", " ") if t else "\033[2m(no prompt you typed)\033[0m")
-        print("\033[2m%s\033[0m  \033[36m%-22s\033[0m %4d msg  %s"
-              % (_day(mx), proj[:22], cnt, title))
+                        " AND " + HUMAN + " ORDER BY ts LIMIT 1", (sid,)).fetchone()
+        title = (t[0][:78].replace("\n", " ") if t
+                 else "\033[2mno prompt you typed — agent-only run\033[0m")
+        where = os.path.basename((cwd or proj or "").rstrip("/")) or (proj or "")
+        print("\033[2m%s\033[0m  \033[36m%-18s\033[0m %3d typed \033[2m/%-5d\033[0m %s"
+              % (_day(mx), where[:18], typed or 0, cnt, title))
+    if not rows:
+        total = con.execute("SELECT COUNT(DISTINCT session_id) FROM messages").fetchone()[0]
+        if not total:
+            print("Your index is empty. `%s index` found no transcripts to read." % PROG)
+        else:
+            print("None of your %s indexed sessions has a prompt you typed in it."
+                  % f"{total:,}")
+            print("\033[2mthat is the finding, not an empty list. `--all` lists them.\033[0m")
+        return
+    if not getattr(args, "all", False):
+        quiet = con.execute("SELECT COUNT(*) FROM (SELECT session_id FROM messages"
+                            " GROUP BY session_id HAVING SUM(CASE WHEN " + HUMAN +
+                            " THEN 1 ELSE 0 END)=0)").fetchone()[0]
+        ses = con.execute("SELECT COUNT(DISTINCT session_id) FROM messages").fetchone()[0]
+        if quiet:
+            print("\n\033[2m%s of your %s sessions have no prompt you typed in them (%.0f%%)."
+                  " They ran\n  without you. `--all` lists them.\033[0m"
+                  % (f"{quiet:,}", f"{ses:,}", 100 * quiet / ses if ses else 0))
 
 
 def cmd_stats(args):
+    """Rank what the operator typed, not what the machine emitted.
+
+    This used to be COUNT(*) FROM messages GROUP BY project. On a real corpus that
+    put a single home-directory bucket on top with 110,569 rows and filled eight of
+    twelve rows with `wf_*` workflow hashes: the tool ranking its own internals.
+    Two things were wrong. It counted machine messages, in a product whose argument
+    is that the typed share is the scarce part. And `project` is the harness's
+    folder encoding, so every typed prompt from one machine lands in one bucket;
+    `cwd` is where work happened and `cost` already keys on it.
+    """
     con = connect()
-    print("\033[1mprojects by activity\033[0m")
-    for proj, c in con.execute("SELECT project,COUNT(*) c FROM messages GROUP BY project"
-                               " ORDER BY c DESC LIMIT 12"):
-        print("  %5d  %s" % (c, proj))
-    print("\n\033[1mmost-written files\033[0m")
+    HUMAN = ("is_human=1 AND text!='' AND text NOT LIKE '<command-name>%'"
+             " AND text NOT LIKE '<local-command-%'")
+    typed = con.execute("SELECT COUNT(*) FROM messages WHERE " + HUMAN).fetchone()[0]
+    tot = con.execute("SELECT COUNT(*) FROM messages").fetchone()[0]
+    # The empty state is the one a stranger sees first, straight after install.
+    # "0 of 0 ... 0.0%" is a ratio over nothing, printed by a tool whose argument
+    # is that a rate needs a denominator.
+    if not tot:
+        print("Your index is empty, so there is no share to show and this prints none.")
+        print("\033[2m`%s index` found no transcripts under ~/.claude/projects. either"
+              " no agent has\n  run on this machine yet, or they are somewhere else."
+              "\033[0m" % PROG)
+        return
+
+    # The headline, because it is the whole argument and it used to be a footnote.
+    # Name the population. `coach` reads the raw JSONL and reports the same
+    # numerator over ~499k RECORDS, which is 0.8%. This reads the index, which
+    # keeps ~205k MESSAGES, and the same numerator over that is 2.1%. Both are
+    # true of different populations, and a tool that prints two shares for one
+    # claim without saying which population it read is doing the thing this tool
+    # exists to catch.
+    print("\033[1m%s of the %s messages in your index are things you typed.  %.1f%%\033[0m"
+          % (f"{typed:,}", f"{tot:,}", 100 * typed / tot if tot else 0.0))
+    print("\033[2mthe rest is the machine answering. `coach` counts raw transcript records"
+          " instead\n  of indexed messages, so its share is smaller; same numerator, wider"
+          " population.\033[0m")
+
+    print("\n\033[1mwhere you typed them\033[0m")
+    rows = con.execute("SELECT cwd,COUNT(*) n FROM messages WHERE " + HUMAN +
+                       " AND cwd IS NOT NULL AND cwd!='' GROUP BY cwd"
+                       " ORDER BY n DESC LIMIT 10").fetchall()
+    for cwd, n in rows:
+        print("  %5d  %s" % (n, os.path.basename(cwd.rstrip("/")) or cwd))
+
+    print("\n\033[1mfiles your prompts moved most\033[0m")
     for name, c in con.execute("SELECT name,COUNT(*) c FROM files WHERE action IN('write','edit')"
-                               " GROUP BY name ORDER BY c DESC LIMIT 12"):
+                               " GROUP BY name ORDER BY c DESC LIMIT 10"):
         print("  %5d  %s" % (c, name))
-    tot = con.execute("SELECT COUNT(*) FROM messages").fetchone()[0]
+
     ses = con.execute("SELECT COUNT(DISTINCT session_id) FROM messages").fetchone()[0]
+    quiet = con.execute("SELECT COUNT(*) FROM (SELECT session_id FROM messages"
+                        " GROUP BY session_id HAVING SUM(CASE WHEN " + HUMAN +
+                        " THEN 1 ELSE 0 END)=0)").fetchone()[0]
     fil = con.execute("SELECT COUNT(DISTINCT path) FROM files").fetchone()[0]
-    print("\n%d messages · %d sessions · %d distinct files tracked" % (tot, ses, fil))
+    print("\n%s sessions · %s of them you never typed in · %s files touched"
+          % (f"{ses:,}", f"{quiet:,}", f"{fil:,}"))
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -793,6 +884,7 @@ _STOP = {"the", "a", "an", "to", "of", "in", "into", "on", "for", "and", "or",
          "case", "cases", "set", "result", "nothing", "empty", "load", "box"}
 
 MIN_PATTERN_N = 8   # a habit is only rankable once you have this many episodes
+MAX_CI_WIDTH = 0.30  # and its 95% interval must be narrower than this to be advice
 MIN_EPISODES_TO_RANK = 30   # below this, refuse to rank the corpus at all — a
                             # rate over a handful of episodes is the exact thing
                             # this tool exists to distrust. Raised from 3 after a
@@ -1558,17 +1650,55 @@ def prompt_patterns(text):
     return tags
 
 
-def rank_patterns(episodes):
+def _wilson(k, n, z=1.96):
+    """95% Wilson score interval for a proportion. Returns (lo, hi)."""
+    if not n:
+        return 0.0, 0.0
+    p = k / n
+    denom = 1 + z * z / n
+    centre = p + z * z / (2 * n)
+    margin = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return (centre - margin) / denom, (centre + margin) / denom
+
+
+def rank_patterns(episodes, baseline=None):
+    """Rank habits by survival, and refuse to rank one we cannot tell from average.
+
+    MIN_PATTERN_N alone is not enough. On a real corpus (2026-09-04, 2244 episodes)
+    a band of n=40 at 55% sat fifth in "do more of these" beside a band of n=815,
+    and its 95% interval was [39.8, 69.3] — it straddled the 47% corpus baseline and
+    overlapped the WORST band. The tool told its user to write vaguer prompts.
+
+    So a habit is ranked only when its interval EXCLUDES the corpus baseline, i.e.
+    when we can actually say it differs from average. Everything else is still
+    measured and still printed, just not under a heading that says "do more of these".
+    A denominator too small to rank does not get ranked.
+    """
     buckets = {}
     for ep in episodes:
         for tag in prompt_patterns(ep["opener"]):
             buckets.setdefault(tag, []).append(ep)
+    if baseline is None:
+        baseline = (sum(1 for e in episodes if e["survived"]) / len(episodes)
+                    if episodes else 0.0)
     out = []
     for tag, eps in buckets.items():
         n = len(eps)
         durable = sum(1 for e in eps if e["survived"])
+        lo, hi = _wilson(durable, n)
         out.append({"pattern": tag, "n": n, "survived": durable,
                     "survival_rate": durable / n if n else 0.0,
+                    "ci_lo": lo, "ci_hi": hi,
+                    # Two conditions, both necessary. (1) the interval must EXCLUDE
+                    # the corpus baseline, or we cannot say the habit differs from
+                    # average. (2) the interval must be narrower than MAX_CI_WIDTH,
+                    # because an estimate of "somewhere between 49% and 94%" is not
+                    # advice at any position in a list. n>=8 alone allowed both a
+                    # baseline-straddling band and a 45pp-wide one to be printed
+                    # under "do more of these".
+                    "distinguishable": (n >= MIN_PATTERN_N
+                                        and not (lo <= baseline <= hi)
+                                        and (hi - lo) <= MAX_CI_WIDTH),
                     "rankable": n >= MIN_PATTERN_N})
     out.sort(key=lambda p: (p["survival_rate"], p["n"]), reverse=True)
     return out
@@ -1649,8 +1779,13 @@ def coach(roots=None, harness=None, verified_human=False):
         corrections += corr
         episodes += extract_episodes(rows, source=p, pasted=pasted)
 
-    patterns = rank_patterns(episodes)
-    rankable = [p for p in patterns if p["rankable"]]
+    _coach_baseline = (sum(1 for e in episodes if e["survived"]) / len(episodes)
+                       if episodes else 0.0)
+    patterns = rank_patterns(episodes, baseline=_coach_baseline)
+    rankable = [p for p in patterns if p["distinguishable"]]
+    # Measured, but the interval straddles the corpus baseline, so we cannot say it
+    # differs from average. Printed under its own heading, never as advice.
+    indistinct = [p for p in patterns if p["rankable"] and not p["distinguishable"]]
     durable = sum(1 for e in episodes if e["survived"])
     tiers = {t: sum(1 for e in episodes if e["tier"] == t)
              for t in ("commit", "artifact", "reverted", "none")}
@@ -1673,7 +1808,8 @@ def coach(roots=None, harness=None, verified_human=False):
         "episodes": len(episodes), "durable": durable,
         "durable_rate": round(durable / len(episodes), 3) if episodes else 0.0,
         "tiers": tiers,
-        "top_patterns": rankable[:5],
+        "top_patterns": [p for p in rankable
+                         if p["survival_rate"] > _coach_baseline][:5],
         # The share block needs named habits by name, and a habit can land in either
         # half of the most/least split depending on corpus. Give it the whole list
         # rather than making it guess which slice to look in.
@@ -1686,12 +1822,18 @@ def coach(roots=None, harness=None, verified_human=False):
         # first outside run was the one that saw it. Slicing from index 5 makes the
         # two lists disjoint by construction at every corpus size, and is
         # byte-identical to the old output once there are >=10 rankable habits.
-        "bottom_patterns": rankable[5:][-5:][::-1],
+        # Direction, not list position. A band is "survives least" because it sits
+        # BELOW the corpus baseline, never because it fell outside the first five
+        # slots. Position slicing put a 42% band under "do more of these" the moment
+        # the baseline filter shortened the list.
+        "bottom_patterns": [p for p in rankable
+                            if p["survival_rate"] <= _coach_baseline][-5:][::-1],
         "best_prompt": _pick(episodes, True,
                              lambda e: (e["score"], -e["corrective_turns"],
                                         e["assistant_turns"])),
         "worst_prompt": _pick(episodes, False,
                               lambda e: (e["corrective_turns"], e["assistant_turns"])),
+        "indistinct_patterns": indistinct,
         "sparse": len(rankable) < 5,
         "rankable_corpus": len(episodes) >= MIN_EPISODES_TO_RANK,
         "proxy": ("survival = a durable Write/Edit or an un-reverted git commit "
@@ -1757,6 +1899,13 @@ def cmd_coach(args):
         print("    %s coach --root <dir>          point at a folder of .jsonl transcripts\n" % PROG)
         return
     B, D = "\033[1m", "\033[0m"
+    # The share you typed is the argument the whole tool rests on, and it used to
+    # sit in grey at the bottom under the fold. It is the first thing now.
+    print("\n  %s%s of the %s records in your transcripts are things you typed.  %.2f%%%s"
+          % (B, f"{r['human_turns']:,}", f"{r['total_records']:,}",
+             r["human_pct"], D))
+    print("  \033[2mthe rest is the machine answering you. this grades the %s.\033[0m"
+          % f"{r['human_turns']:,}")
     print("\n  %sYOUR PROMPT HABITS, GRADED%s   (offline, your machine only)\n" % (B, D))
     w = r["worst_prompt"]
     if w:
@@ -1778,16 +1927,29 @@ def cmd_coach(args):
         # one exists to catch. So no ranking. The two things below need no sample
         # size — one episode each — and they are the honest half of the output.
         print("\n  %sNot enough episodes to rank your habits yet.%s" % (B, D))
-        print("  You have %s; habits become rankable at %s. A survival percentage over"
+        print("  You have %s. At %s the tool starts looking, and a habit ranks once its"
               % (r["episodes"], MIN_EPISODES_TO_RANK))
+        print("  own count is large enough to separate it from your average, which is a"
+              "\n  bigger number than %s. A survival percentage over"
+              % MIN_EPISODES_TO_RANK)
         print("  a handful of episodes is the number this tool was built to distrust,")
         print("  so it will not print one. Your raw survival and your single best and")
         print("  worst prompt need no sample size — here they are.")
     else:
-        if r["sparse"]:
+        if r["sparse"] and r["top_patterns"]:
             print("\n  \033[2m(few habits cleared the %s-episode minimum, showing what is "
                   "rankable)\033[0m" % MIN_PATTERN_N)
-        print("\n  %sSURVIVES MOST%s  do more of these:" % (B, D))
+        # An empty header under a promise is a claim about rows that do not exist.
+        # The baseline-overlap rule can empty this list entirely on a small corpus,
+        # where no single band's interval clears the user's own average. Say that,
+        # rather than printing "do more of these" over nothing.
+        if not r["top_patterns"]:
+            print("\n  %sNo habit beats your own average by enough to call it.%s" % (B, D))
+            print("  \033[2mEvery band's 95%% interval straddles your %d%% baseline. That is a"
+                  "\n  finding, not a gap: at this corpus size the differences are noise.\033[0m"
+                  % round(r["durable_rate"] * 100))
+        else:
+            print("\n  %sSURVIVES MOST%s  do more of these:" % (B, D))
         for p in r["top_patterns"]:
             print("    %3d%%  (%s/%s)  %s" % (round(p["survival_rate"] * 100),
                                               p["survived"], p["n"], p["pattern"]))
@@ -1799,9 +1961,20 @@ def cmd_coach(args):
             for p in r["bottom_patterns"]:
                 print("    %3d%%  (%s/%s)  %s" % (round(p["survival_rate"] * 100),
                                                   p["survived"], p["n"], p["pattern"]))
-        else:
+        elif r["top_patterns"]:
             print("\n  \033[2m(every rankable habit is listed above; too few to split "
                   "into a most/least pair)\033[0m")
+        # Measured, but the 95% interval straddles your own survival rate, so the
+        # honest statement is "cannot tell this apart from your average", not a
+        # ranking. These used to appear under "do more of these".
+        if r.get("indistinct_patterns"):
+            print("\n  \033[2mMEASURED, NOT RANKED  the 95%% interval straddles your "
+                  "%d%% baseline, so these cannot be told apart from your average:\033[0m"
+                  % round(r["durable_rate"] * 100))
+            for p in r["indistinct_patterns"]:
+                print("    \033[2m%3d%%  (%s/%s)  [%d-%d%%]  %s\033[0m"
+                      % (round(p["survival_rate"] * 100), p["survived"], p["n"],
+                         round(p["ci_lo"] * 100), round(p["ci_hi"] * 100), p["pattern"]))
     print("\n  \033[2mharness %s  ·  %s transcript(s), %s records  ·  %s typed by you "
           "(%s%%)\033[0m"
           % (r["harness"], r["files"], format(r["total_records"], ","),
@@ -2026,7 +2199,10 @@ def main():
     s = sub.add_parser("trace"); s.add_argument("query"); s.add_argument("-n", "--limit", type=int, default=10)
     s.add_argument("-a", "--all", action="store_true", help="show every file, not the first 8")
     s.set_defaults(fn=cmd_trace)
-    s = sub.add_parser("sessions"); s.add_argument("-n", "--limit", type=int, default=30); s.set_defaults(fn=cmd_sessions)
+    s = sub.add_parser("sessions"); s.add_argument("-n", "--limit", type=int, default=30)
+    s.add_argument("--all", action="store_true",
+                   help="include sessions you never typed in (85%% of them, on a real corpus)")
+    s.set_defaults(fn=cmd_sessions)
     sub.add_parser("stats").set_defaults(fn=cmd_stats)
     s = sub.add_parser("cost")
     s.add_argument("--days", type=int, default=30, help="window in days (0 = all time)")