transcripto 0.1.1__tar.gz → 0.1.2__tar.gz

{transcripto-0.1.1/transcripto.egg-info → transcripto-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.1
+Version: 0.1.2
 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,6 +29,56 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
+> **check which build you got.** `trace`, `--harness cursor`, and the "run `index`
+> first" errors below all arrive in **0.1.2**. On anything older, `trace` is not a
+> command, cursor is rejected, and the index-gated commands fail with a raw sqlite
+> traceback instead of an instruction. One line settles which one you are holding:
+>
+> ```
+> uvx transcripto --version          # 0.1.2 or newer = this README is accurate
+> ```
+>
+> *Read 2026-08-31: PyPI was serving 0.1.1 while this README described 0.1.2, so
+> `uvx transcripto` gave the older build. If `--version` is not even a recognised
+> flag, you have 0.1.1 — it was added in 0.1.2 precisely because there was no way
+> to tell.* The repo always matches this README and needs nothing installed:
+>
+> ```
+> git clone https://github.com/Morkeeth/transcripto && cd transcripto
+> python3 transcripto.py coach
+> ```
+
+## three harnesses, one instrument
+
+```
+transcripto coach                     # Claude Code, ~/.claude/projects
+transcripto coach --harness codex     # Codex, ~/.codex
+transcripto coach --harness cursor    # Cursor, ~/.cursor/projects/*/agent-transcripts
+```
+
+**Authorship is not the same gate in all three, and the tool says so rather than pooling them.**
+Claude Code stamps `promptSource: typed`, which is the measured-reliable signal: about 95% of raw
+`type: user` records are not the operator at all. Cursor has no such field. Its one honest
+equivalent is the `<user_query>` wrapper it puts around a submitted prompt, which injected and
+tool-result records do not carry. That is a weaker signal and it is labelled weaker.
+
+## `trace` — what actually happened after you asked
+
+`ask` shows what you typed. `find` shows what a file went through. Neither answers the
+question that matters after the fact: **you asked for X, did anything durable happen?**
+
+```
+transcripto trace "the gate"
+```
+
+It walks each of your matching prompts forward inside its own session and lists the writes
+and edits that followed, stopping at your next prompt so one turn cannot claim the next
+turn's work. Green dot = something durable landed. Red = nothing was touched.
+
+**Honest limit:** a write following a prompt in the same session is CO-OCCURRENCE, not proof
+the write was caused by that prompt or that it was correct. Same proxy `coach` uses, labelled
+the same way.
+
 ## what you get back
 
 this is a real run on one machine, pasted unedited, 2026-08-28:
@@ -73,9 +123,13 @@ them as a snapshot rather than a constant. yours will be different, which is the
 whole point. the last two lines are the ones that sting: it hands you back your
 own best and worst prompt, verbatim, with the receipt for why it scored each one.
 
-on that machine, prompts that wrote down what done looks like survived **63% of
-the time (66 of 104)**. prompts with no stated intent survived **39% (411 of
-1043)**. i had spent a year blaming the model.
+on that machine, on that date, prompts that wrote down what done looks like
+survived **63% of the time (66 of 104)**. prompts with no stated intent survived
+**39% (411 of 1043)**. i had spent a year blaming the model.
+
+one day later, 2026-08-29, the same command on the same machine read 63% (67 of
+107) and 40% (424 of 1072) over 2,874 transcripts. the percentages held and the
+denominators moved, which is what a snapshot is supposed to do.
 
 ## the proxy caveat, which travels with every number
 
@@ -127,8 +181,10 @@ read these before you quote a number at anyone.
 - **one operator's corpus.** every figure in this README comes from one machine.
   it is an existence proof that the measurement runs, not a finding about how
   people prompt. run it on yours and you get yours.
-- **two harnesses today: Claude Code and Codex.** nothing else is supported.
-  cursor, aider, and the rest are not read.
+- **three harnesses today: Claude Code, Codex, Cursor.** nothing else is supported.
+  aider and the rest are not read. and the three are not equal: Claude Code has a
+  measured-reliable authorship field, Cursor has only the `<user_query>` wrapper,
+  which is weaker and is labelled weaker wherever it is used.
 - **the habit labels are heuristics.** "states-a-check-or-done-condition" is a
   pattern match over your text, not comprehension. it will misfile some prompts.
 - **correlation, not instruction.** detailed prompts surviving more often does not
@@ -144,25 +200,50 @@ claim, so here is the grep that settles it against the single file it ships as:
 $ grep -nE '^[[:space:]]*(import|from) ' transcripto.py
 8:import sys, os, json, glob, re, sqlite3, argparse
 9:from datetime import datetime, timezone
-225:    import time
+260:    import time
+1051:            import datetime
+1061:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
-that is the whole import list, three lines. `time` sits inside the `watch` loop,
-which is why the pattern allows for indentation. anchor it at `^import` and you
-would miss one, so do not take my word for the anchor either.
+five lines, four of which are imports and all four are stdlib. `time` and
+`datetime` sit inside functions, which is why the pattern allows for indentation —
+anchor it at `^import` and you would miss two, so do not take my word for the
+anchor either. line 1061 is the pattern catching a docstring that happens to begin
+with the word `from`; it is prose, not an import, and it is left in rather than
+tuned out, because a grep you tuned until it agreed with you proves nothing.
 
-your transcripts stay in `~/.claude` and `~/.codex`. the index it builds stays in
-`~/.trace`.
+what the list does NOT contain is the actual claim: no `socket`, no `urllib`, no
+`requests`, no `http.client`, no `subprocess`. that one is checkable too, and the
+right answer is no output at all:
+
+```
+$ grep -nE '\b(socket|urllib|requests|http\.client|subprocess)\b' transcripto.py
+$
+```
+
+your transcripts stay in `~/.claude`, `~/.codex` and `~/.cursor`. the index it
+builds stays in `~/.trace`.
 
 ## the rest of it
 
+`coach` and `cost` read your transcript files directly and need nothing set up.
+**the other six read a local index, so run this once first:**
+
+```
+transcripto index      # a few minutes on a large corpus, incremental after that
+```
+
+on a 2,874-file corpus that was 164 seconds, measured 2026-08-29. if you skip it,
+the six say so and exit 2.
+
 ```
 transcripto index      build / refresh (incremental)
 transcripto watch      live, new sessions get picked up as your agents work
 transcripto ask        YOUR OWN messages about a topic, newest first + a rollup
 transcripto search     full-text across everything (you + agents + tool logs)
 transcripto find       every session that wrote / edited / read a file
-transcripto sessions   recent sessions + their opening ask
+transcripto trace      what durably happened after each prompt you typed (0.1.2+)
+transcripto sessions   recent sessions + the first prompt YOU typed in each
 transcripto stats      what you actually work on
 transcripto cost       what ONE of your decisions costs
 transcripto coach      which of YOUR prompt habits survive (a proxy)
@@ -172,11 +253,17 @@ transcripto coach      which of YOUR prompt habits survive (a proxy)
 thinking about X across ALL my sessions", in your own words only.
 
 ```
-$ transcripto find USER-JOURNEY.md
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md
+$ 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
 ```
 
-the file you lost, found across every session you ever ran, one line.
+the file you lost, found across every session you ever ran, with the session id
+that touched it. `find` needs `transcripto index` first.
 
 ## Codex
 
@@ -215,11 +302,15 @@ just gives the file a name on your PATH.
 ## tests
 
 ```
-./test_coach.sh    14 assertions
-./test_codex.sh    14 assertions
-./test_cost.sh     12 assertions
+./test_coach.sh        15 assertions
+./test_codex.sh        14 assertions
+./test_cost.sh         12 assertions
+./test_small_n.sh       7 assertions
+./test_label_bands.sh  13 assertions
 ```
 
+61 assertions, all green, re-run 2026-08-31.
+
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.
 
@@ -227,6 +318,15 @@ the load-bearing one in `test_coach.sh` is `REVERTED IS NOT SURVIVED`: a commit
 that got `reset --hard` in the same session left no durable record. flip that one
 line and the suite goes red, which is the point. a generous proxy is a broken one.
 
+`test_label_bands.sh` is the other one, and it exists because 0.1.1 shipped the
+defect it pins. `SURVIVES MOST` took the top five habits and `SURVIVES LEAST` took
+the bottom five, which overlap whenever you have fewer than ten rankable habits —
+so a new user, who necessarily has few, read the same habit at the same percentage
+under both "do more of these" and "these tend to loop". on a 3-habit corpus 0.1.1
+reprinted all three, all at 65% (22/34). the suite is red on the published 0.1.1
+file and green on this one, and its `wide` band asserts the fix leaves a large
+corpus byte-identical.
+
 ## why though
 
 your agent history is proof. every "yeah it's done" has a real trace sitting

{transcripto-0.1.1 → transcripto-0.1.2}/README.md

@@ -11,6 +11,56 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
+> **check which build you got.** `trace`, `--harness cursor`, and the "run `index`
+> first" errors below all arrive in **0.1.2**. On anything older, `trace` is not a
+> command, cursor is rejected, and the index-gated commands fail with a raw sqlite
+> traceback instead of an instruction. One line settles which one you are holding:
+>
+> ```
+> uvx transcripto --version          # 0.1.2 or newer = this README is accurate
+> ```
+>
+> *Read 2026-08-31: PyPI was serving 0.1.1 while this README described 0.1.2, so
+> `uvx transcripto` gave the older build. If `--version` is not even a recognised
+> flag, you have 0.1.1 — it was added in 0.1.2 precisely because there was no way
+> to tell.* The repo always matches this README and needs nothing installed:
+>
+> ```
+> git clone https://github.com/Morkeeth/transcripto && cd transcripto
+> python3 transcripto.py coach
+> ```
+
+## three harnesses, one instrument
+
+```
+transcripto coach                     # Claude Code, ~/.claude/projects
+transcripto coach --harness codex     # Codex, ~/.codex
+transcripto coach --harness cursor    # Cursor, ~/.cursor/projects/*/agent-transcripts
+```
+
+**Authorship is not the same gate in all three, and the tool says so rather than pooling them.**
+Claude Code stamps `promptSource: typed`, which is the measured-reliable signal: about 95% of raw
+`type: user` records are not the operator at all. Cursor has no such field. Its one honest
+equivalent is the `<user_query>` wrapper it puts around a submitted prompt, which injected and
+tool-result records do not carry. That is a weaker signal and it is labelled weaker.
+
+## `trace` — what actually happened after you asked
+
+`ask` shows what you typed. `find` shows what a file went through. Neither answers the
+question that matters after the fact: **you asked for X, did anything durable happen?**
+
+```
+transcripto trace "the gate"
+```
+
+It walks each of your matching prompts forward inside its own session and lists the writes
+and edits that followed, stopping at your next prompt so one turn cannot claim the next
+turn's work. Green dot = something durable landed. Red = nothing was touched.
+
+**Honest limit:** a write following a prompt in the same session is CO-OCCURRENCE, not proof
+the write was caused by that prompt or that it was correct. Same proxy `coach` uses, labelled
+the same way.
+
 ## what you get back
 
 this is a real run on one machine, pasted unedited, 2026-08-28:
@@ -55,9 +105,13 @@ them as a snapshot rather than a constant. yours will be different, which is the
 whole point. the last two lines are the ones that sting: it hands you back your
 own best and worst prompt, verbatim, with the receipt for why it scored each one.
 
-on that machine, prompts that wrote down what done looks like survived **63% of
-the time (66 of 104)**. prompts with no stated intent survived **39% (411 of
-1043)**. i had spent a year blaming the model.
+on that machine, on that date, prompts that wrote down what done looks like
+survived **63% of the time (66 of 104)**. prompts with no stated intent survived
+**39% (411 of 1043)**. i had spent a year blaming the model.
+
+one day later, 2026-08-29, the same command on the same machine read 63% (67 of
+107) and 40% (424 of 1072) over 2,874 transcripts. the percentages held and the
+denominators moved, which is what a snapshot is supposed to do.
 
 ## the proxy caveat, which travels with every number
 
@@ -109,8 +163,10 @@ read these before you quote a number at anyone.
 - **one operator's corpus.** every figure in this README comes from one machine.
   it is an existence proof that the measurement runs, not a finding about how
   people prompt. run it on yours and you get yours.
-- **two harnesses today: Claude Code and Codex.** nothing else is supported.
-  cursor, aider, and the rest are not read.
+- **three harnesses today: Claude Code, Codex, Cursor.** nothing else is supported.
+  aider and the rest are not read. and the three are not equal: Claude Code has a
+  measured-reliable authorship field, Cursor has only the `<user_query>` wrapper,
+  which is weaker and is labelled weaker wherever it is used.
 - **the habit labels are heuristics.** "states-a-check-or-done-condition" is a
   pattern match over your text, not comprehension. it will misfile some prompts.
 - **correlation, not instruction.** detailed prompts surviving more often does not
@@ -126,25 +182,50 @@ claim, so here is the grep that settles it against the single file it ships as:
 $ grep -nE '^[[:space:]]*(import|from) ' transcripto.py
 8:import sys, os, json, glob, re, sqlite3, argparse
 9:from datetime import datetime, timezone
-225:    import time
+260:    import time
+1051:            import datetime
+1061:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
-that is the whole import list, three lines. `time` sits inside the `watch` loop,
-which is why the pattern allows for indentation. anchor it at `^import` and you
-would miss one, so do not take my word for the anchor either.
+five lines, four of which are imports and all four are stdlib. `time` and
+`datetime` sit inside functions, which is why the pattern allows for indentation —
+anchor it at `^import` and you would miss two, so do not take my word for the
+anchor either. line 1061 is the pattern catching a docstring that happens to begin
+with the word `from`; it is prose, not an import, and it is left in rather than
+tuned out, because a grep you tuned until it agreed with you proves nothing.
 
-your transcripts stay in `~/.claude` and `~/.codex`. the index it builds stays in
-`~/.trace`.
+what the list does NOT contain is the actual claim: no `socket`, no `urllib`, no
+`requests`, no `http.client`, no `subprocess`. that one is checkable too, and the
+right answer is no output at all:
+
+```
+$ grep -nE '\b(socket|urllib|requests|http\.client|subprocess)\b' transcripto.py
+$
+```
+
+your transcripts stay in `~/.claude`, `~/.codex` and `~/.cursor`. the index it
+builds stays in `~/.trace`.
 
 ## the rest of it
 
+`coach` and `cost` read your transcript files directly and need nothing set up.
+**the other six read a local index, so run this once first:**
+
+```
+transcripto index      # a few minutes on a large corpus, incremental after that
+```
+
+on a 2,874-file corpus that was 164 seconds, measured 2026-08-29. if you skip it,
+the six say so and exit 2.
+
 ```
 transcripto index      build / refresh (incremental)
 transcripto watch      live, new sessions get picked up as your agents work
 transcripto ask        YOUR OWN messages about a topic, newest first + a rollup
 transcripto search     full-text across everything (you + agents + tool logs)
 transcripto find       every session that wrote / edited / read a file
-transcripto sessions   recent sessions + their opening ask
+transcripto trace      what durably happened after each prompt you typed (0.1.2+)
+transcripto sessions   recent sessions + the first prompt YOU typed in each
 transcripto stats      what you actually work on
 transcripto cost       what ONE of your decisions costs
 transcripto coach      which of YOUR prompt habits survive (a proxy)
@@ -154,11 +235,17 @@ transcripto coach      which of YOUR prompt habits survive (a proxy)
 thinking about X across ALL my sessions", in your own words only.
 
 ```
-$ transcripto find USER-JOURNEY.md
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md
+$ 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
 ```
 
-the file you lost, found across every session you ever ran, one line.
+the file you lost, found across every session you ever ran, with the session id
+that touched it. `find` needs `transcripto index` first.
 
 ## Codex
 
@@ -197,11 +284,15 @@ just gives the file a name on your PATH.
 ## tests
 
 ```
-./test_coach.sh    14 assertions
-./test_codex.sh    14 assertions
-./test_cost.sh     12 assertions
+./test_coach.sh        15 assertions
+./test_codex.sh        14 assertions
+./test_cost.sh         12 assertions
+./test_small_n.sh       7 assertions
+./test_label_bands.sh  13 assertions
 ```
 
+61 assertions, all green, re-run 2026-08-31.
+
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.
 
@@ -209,6 +300,15 @@ the load-bearing one in `test_coach.sh` is `REVERTED IS NOT SURVIVED`: a commit
 that got `reset --hard` in the same session left no durable record. flip that one
 line and the suite goes red, which is the point. a generous proxy is a broken one.
 
+`test_label_bands.sh` is the other one, and it exists because 0.1.1 shipped the
+defect it pins. `SURVIVES MOST` took the top five habits and `SURVIVES LEAST` took
+the bottom five, which overlap whenever you have fewer than ten rankable habits —
+so a new user, who necessarily has few, read the same habit at the same percentage
+under both "do more of these" and "these tend to loop". on a 3-habit corpus 0.1.1
+reprinted all three, all at 65% (22/34). the suite is red on the published 0.1.1
+file and green on this one, and its `wide` band asserts the fix leaves a large
+corpus byte-identical.
+
 ## why though
 
 your agent history is proof. every "yeah it's done" has a real trace sitting

{transcripto-0.1.1 → transcripto-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "transcripto"
-version = "0.1.1"
+version = "0.1.2"
 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.1 → transcripto-0.1.2/transcripto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.1
+Version: 0.1.2
 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,6 +29,56 @@ your disk and never opens a socket.
 uvx transcripto coach
 ```
 
+> **check which build you got.** `trace`, `--harness cursor`, and the "run `index`
+> first" errors below all arrive in **0.1.2**. On anything older, `trace` is not a
+> command, cursor is rejected, and the index-gated commands fail with a raw sqlite
+> traceback instead of an instruction. One line settles which one you are holding:
+>
+> ```
+> uvx transcripto --version          # 0.1.2 or newer = this README is accurate
+> ```
+>
+> *Read 2026-08-31: PyPI was serving 0.1.1 while this README described 0.1.2, so
+> `uvx transcripto` gave the older build. If `--version` is not even a recognised
+> flag, you have 0.1.1 — it was added in 0.1.2 precisely because there was no way
+> to tell.* The repo always matches this README and needs nothing installed:
+>
+> ```
+> git clone https://github.com/Morkeeth/transcripto && cd transcripto
+> python3 transcripto.py coach
+> ```
+
+## three harnesses, one instrument
+
+```
+transcripto coach                     # Claude Code, ~/.claude/projects
+transcripto coach --harness codex     # Codex, ~/.codex
+transcripto coach --harness cursor    # Cursor, ~/.cursor/projects/*/agent-transcripts
+```
+
+**Authorship is not the same gate in all three, and the tool says so rather than pooling them.**
+Claude Code stamps `promptSource: typed`, which is the measured-reliable signal: about 95% of raw
+`type: user` records are not the operator at all. Cursor has no such field. Its one honest
+equivalent is the `<user_query>` wrapper it puts around a submitted prompt, which injected and
+tool-result records do not carry. That is a weaker signal and it is labelled weaker.
+
+## `trace` — what actually happened after you asked
+
+`ask` shows what you typed. `find` shows what a file went through. Neither answers the
+question that matters after the fact: **you asked for X, did anything durable happen?**
+
+```
+transcripto trace "the gate"
+```
+
+It walks each of your matching prompts forward inside its own session and lists the writes
+and edits that followed, stopping at your next prompt so one turn cannot claim the next
+turn's work. Green dot = something durable landed. Red = nothing was touched.
+
+**Honest limit:** a write following a prompt in the same session is CO-OCCURRENCE, not proof
+the write was caused by that prompt or that it was correct. Same proxy `coach` uses, labelled
+the same way.
+
 ## what you get back
 
 this is a real run on one machine, pasted unedited, 2026-08-28:
@@ -73,9 +123,13 @@ them as a snapshot rather than a constant. yours will be different, which is the
 whole point. the last two lines are the ones that sting: it hands you back your
 own best and worst prompt, verbatim, with the receipt for why it scored each one.
 
-on that machine, prompts that wrote down what done looks like survived **63% of
-the time (66 of 104)**. prompts with no stated intent survived **39% (411 of
-1043)**. i had spent a year blaming the model.
+on that machine, on that date, prompts that wrote down what done looks like
+survived **63% of the time (66 of 104)**. prompts with no stated intent survived
+**39% (411 of 1043)**. i had spent a year blaming the model.
+
+one day later, 2026-08-29, the same command on the same machine read 63% (67 of
+107) and 40% (424 of 1072) over 2,874 transcripts. the percentages held and the
+denominators moved, which is what a snapshot is supposed to do.
 
 ## the proxy caveat, which travels with every number
 
@@ -127,8 +181,10 @@ read these before you quote a number at anyone.
 - **one operator's corpus.** every figure in this README comes from one machine.
   it is an existence proof that the measurement runs, not a finding about how
   people prompt. run it on yours and you get yours.
-- **two harnesses today: Claude Code and Codex.** nothing else is supported.
-  cursor, aider, and the rest are not read.
+- **three harnesses today: Claude Code, Codex, Cursor.** nothing else is supported.
+  aider and the rest are not read. and the three are not equal: Claude Code has a
+  measured-reliable authorship field, Cursor has only the `<user_query>` wrapper,
+  which is weaker and is labelled weaker wherever it is used.
 - **the habit labels are heuristics.** "states-a-check-or-done-condition" is a
   pattern match over your text, not comprehension. it will misfile some prompts.
 - **correlation, not instruction.** detailed prompts surviving more often does not
@@ -144,25 +200,50 @@ claim, so here is the grep that settles it against the single file it ships as:
 $ grep -nE '^[[:space:]]*(import|from) ' transcripto.py
 8:import sys, os, json, glob, re, sqlite3, argparse
 9:from datetime import datetime, timezone
-225:    import time
+260:    import time
+1051:            import datetime
+1061:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
-that is the whole import list, three lines. `time` sits inside the `watch` loop,
-which is why the pattern allows for indentation. anchor it at `^import` and you
-would miss one, so do not take my word for the anchor either.
+five lines, four of which are imports and all four are stdlib. `time` and
+`datetime` sit inside functions, which is why the pattern allows for indentation —
+anchor it at `^import` and you would miss two, so do not take my word for the
+anchor either. line 1061 is the pattern catching a docstring that happens to begin
+with the word `from`; it is prose, not an import, and it is left in rather than
+tuned out, because a grep you tuned until it agreed with you proves nothing.
 
-your transcripts stay in `~/.claude` and `~/.codex`. the index it builds stays in
-`~/.trace`.
+what the list does NOT contain is the actual claim: no `socket`, no `urllib`, no
+`requests`, no `http.client`, no `subprocess`. that one is checkable too, and the
+right answer is no output at all:
+
+```
+$ grep -nE '\b(socket|urllib|requests|http\.client|subprocess)\b' transcripto.py
+$
+```
+
+your transcripts stay in `~/.claude`, `~/.codex` and `~/.cursor`. the index it
+builds stays in `~/.trace`.
 
 ## the rest of it
 
+`coach` and `cost` read your transcript files directly and need nothing set up.
+**the other six read a local index, so run this once first:**
+
+```
+transcripto index      # a few minutes on a large corpus, incremental after that
+```
+
+on a 2,874-file corpus that was 164 seconds, measured 2026-08-29. if you skip it,
+the six say so and exit 2.
+
 ```
 transcripto index      build / refresh (incremental)
 transcripto watch      live, new sessions get picked up as your agents work
 transcripto ask        YOUR OWN messages about a topic, newest first + a rollup
 transcripto search     full-text across everything (you + agents + tool logs)
 transcripto find       every session that wrote / edited / read a file
-transcripto sessions   recent sessions + their opening ask
+transcripto trace      what durably happened after each prompt you typed (0.1.2+)
+transcripto sessions   recent sessions + the first prompt YOU typed in each
 transcripto stats      what you actually work on
 transcripto cost       what ONE of your decisions costs
 transcripto coach      which of YOUR prompt habits survive (a proxy)
@@ -172,11 +253,17 @@ transcripto coach      which of YOUR prompt habits survive (a proxy)
 thinking about X across ALL my sessions", in your own words only.
 
 ```
-$ transcripto find USER-JOURNEY.md
-2026-08-20  WROTE  ~/CODE/mountain-of-helicon-main/USER-JOURNEY.md
+$ 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
 ```
 
-the file you lost, found across every session you ever ran, one line.
+the file you lost, found across every session you ever ran, with the session id
+that touched it. `find` needs `transcripto index` first.
 
 ## Codex
 
@@ -215,11 +302,15 @@ just gives the file a name on your PATH.
 ## tests
 
 ```
-./test_coach.sh    14 assertions
-./test_codex.sh    14 assertions
-./test_cost.sh     12 assertions
+./test_coach.sh        15 assertions
+./test_codex.sh        14 assertions
+./test_cost.sh         12 assertions
+./test_small_n.sh       7 assertions
+./test_label_bands.sh  13 assertions
 ```
 
+61 assertions, all green, re-run 2026-08-31.
+
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.
 
@@ -227,6 +318,15 @@ the load-bearing one in `test_coach.sh` is `REVERTED IS NOT SURVIVED`: a commit
 that got `reset --hard` in the same session left no durable record. flip that one
 line and the suite goes red, which is the point. a generous proxy is a broken one.
 
+`test_label_bands.sh` is the other one, and it exists because 0.1.1 shipped the
+defect it pins. `SURVIVES MOST` took the top five habits and `SURVIVES LEAST` took
+the bottom five, which overlap whenever you have fewer than ten rankable habits —
+so a new user, who necessarily has few, read the same habit at the same percentage
+under both "do more of these" and "these tend to loop". on a 3-habit corpus 0.1.1
+reprinted all three, all at 65% (22/34). the suite is red on the published 0.1.1
+file and green on this one, and its `wide` band asserts the fix leaves a large
+corpus byte-identical.
+
 ## why though
 
 your agent history is proof. every "yeah it's done" has a real trace sitting

{transcripto-0.1.1 → transcripto-0.1.2}/transcripto.py

@@ -21,6 +21,12 @@ def _prog():
 
 PROG = _prog()
 
+# The single source of truth for the version, so `--version` cannot drift from the
+# 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.2"
+
 USAGE = """
   %(p)s index                 build / refresh the index (incremental)
   %(p)s ask "<topic>"         YOUR OWN messages about a topic, newest first + a rollup
@@ -30,7 +36,7 @@ USAGE = """
   %(p)s stats                 what you work on most: projects, files, volume
   %(p)s cost                  what ONE decision of yours costs: spend / turns you typed
   %(p)s coach                 which of YOUR prompt habits actually survive (a proxy)
-  %(p)s coach --harness codex grade your Codex (~/.codex) transcripts instead
+  %(p)s coach --harness codex grade your Codex (~/.codex) transcripts instead\n  %(p)s coach --harness cursor grade your Cursor (~/.cursor) transcripts instead
   %(p)s coach --verified-human subtract likely-PASTED turns (echoes of agent output)
 """ % {"p": PROG}
 
@@ -42,10 +48,24 @@ FILE_TOOLS = {"Write": "write", "Edit": "edit", "Read": "read",
               "NotebookEdit": "edit", "MultiEdit": "edit"}
 
 
-def connect():
+def connect(require_index=True):
+    """Open the local index. Six commands (search/ask/find/trace/sessions/stats)
+    READ it and are meaningless without it; `index` and `watch` BUILD it and pass
+    require_index=False. Before this guard existed a cold start printed a raw
+    `sqlite3.OperationalError: no such table: messages_fts` — and three of the six
+    printed it and still exited 0."""
     os.makedirs(os.path.dirname(DB), exist_ok=True)
     con = sqlite3.connect(DB)
     con.execute("PRAGMA journal_mode=WAL")
+    if require_index and not con.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='messages'"
+    ).fetchone():
+        print("\n  no index yet.  (looked in %s)\n" % DB)
+        print("  this command reads a local index of your transcripts. build it once:\n")
+        print("    transcripto index\n")
+        print("  it takes a few minutes on a large corpus and is incremental after that.")
+        print("  `coach` and `cost` read your transcripts directly and need no index.\n")
+        sys.exit(2)
     return con
 
 
@@ -166,13 +186,26 @@ def is_human_turn(d):
     return True
 
 
-def _index_once(con):
-    """Incrementally index every changed/new transcript. Returns (new_sessions, new_msgs)."""
+def _index_once(con, progress=False):
+    """Incrementally index every changed/new transcript. Returns (new_sessions, new_msgs).
+
+    progress=True prints a heartbeat to stderr. A first index over a few thousand
+    transcripts takes minutes, and a silent terminal for that long reads as a hang,
+    which is the point at which a first-time user kills it.
+    """
     seen = []
     for root in ROOTS:
         seen += glob.glob(os.path.join(root, "**", "*.jsonl"), recursive=True)
+    if progress:
+        sys.stderr.write("scanning %d transcript file(s) in %s\n"
+                         % (len(seen), ", ".join(r.replace(HOME, "~") for r in ROOTS)))
+        sys.stderr.flush()
     new = msgs = 0
-    for f in sorted(seen):
+    for done, f in enumerate(sorted(seen), 1):
+        if progress and done % 250 == 0:
+            sys.stderr.write("  %d/%d files · %d changed · %d messages\r"
+                             % (done, len(seen), new, msgs))
+            sys.stderr.flush()
         mt = os.path.getmtime(f)
         row = con.execute("SELECT mtime FROM indexed WHERE session_file=?", (f,)).fetchone()
         if row and abs(row[0] - mt) < 1e-6:
@@ -214,8 +247,10 @@ def _index_once(con):
 
 
 def cmd_index(args):
-    con = connect(); init_schema(con)
-    new, msgs = _index_once(con)
+    con = connect(require_index=False); init_schema(con)
+    new, msgs = _index_once(con, progress=sys.stderr.isatty())
+    if sys.stderr.isatty():
+        sys.stderr.write(" " * 60 + "\r"); sys.stderr.flush()
     tot = con.execute("SELECT COUNT(*) FROM messages").fetchone()[0]
     print("indexed %d changed sessions · +%d messages · %d total searchable" % (new, msgs, tot))
 
@@ -223,7 +258,7 @@ def cmd_index(args):
 def cmd_watch(args):
     """Live indexing: pick up new transcripts + trace lines automatically as they land."""
     import time
-    con = connect(); init_schema(con)
+    con = connect(require_index=False); init_schema(con)
     _index_once(con)
     tot = con.execute("SELECT COUNT(*) FROM messages").fetchone()[0]
     print(PROG + " watch, live. %d messages indexed; polling %s every %ds. Ctrl-C to stop."
@@ -299,11 +334,11 @@ def cmd_ask(args):
             any_hit = 0
         if any_hit:
             print("no messages YOU typed about '%s', but %d agent/tool turns mention it."
-                  "\ntry `" + PROG + " search \"%s\"` to see those, or `" + PROG + " index` if it's new."
-                  % (args.query, any_hit, args.query))
+                  "\ntry `%s search \"%s\"` to see those, or `%s index` if it's new."
+                  % (args.query, any_hit, PROG, args.query, PROG))
         else:
-            print("nothing about '%s' yet. try `" + PROG + " index` first, or broader terms."
-                  % args.query)
+            print("nothing about '%s' yet. try `%s index` first, or broader terms."
+                  % (args.query, PROG))
         return
 
     # ---- rollup: the arc across ALL your matches, not just the shown page ----
@@ -357,15 +392,99 @@ def cmd_find(args):
         print("%s  %s  %s  \033[2m%s\033[0m" % (_day(ts), tag, path, sid[:8]))
 
 
+def cmd_trace(args):
+    """WHAT ACTUALLY HAPPENED after you asked. The join nothing else makes.
+
+    `ask` shows what you typed. `find` shows what a file went through. Neither
+    answers the only question that matters after the fact: you asked for X, did
+    anything durable happen? This walks each of your matching prompts forward
+    inside its own session and lists the writes and edits that followed it,
+    stopping at your next prompt so one turn cannot claim the next turn's work.
+
+    HONEST LIMIT, stated because the product is about claims: a write following
+    a prompt in the same session is CO-OCCURRENCE, not proof the write was caused
+    by that prompt or that it was correct. It is the same proxy `coach` uses and
+    it is labelled the same way.
+    """
+    con = connect()
+    try:
+        rows = con.execute(
+            "SELECT m.id,m.ts,m.project,m.cwd,m.session_id,m.text,m.git_branch"
+            " FROM messages_fts JOIN messages m ON m.id=messages_fts.rowid"
+            " WHERE messages_fts MATCH ? AND m.is_human=1"
+            " ORDER BY m.ts DESC LIMIT ?",
+            (_match(args.query), args.limit)).fetchall()
+    except sqlite3.OperationalError as e:
+        print("trace error:", e); return
+    if not rows:
+        print("no prompts YOU typed matching '%s'. try `%s ask \"%s\"` or `%s index`."
+              % (args.query, PROG, args.query, PROG)); return
+
+    landed = stalled = 0
+    blocks = []
+    for _id, ts, proj, cwd, sid, text, branch in rows:
+        nxt = con.execute(
+            "SELECT MIN(ts) FROM messages WHERE session_id=? AND is_human=1 AND ts>?",
+            (sid, ts)).fetchone()[0]
+        if nxt:
+            files = con.execute(
+                "SELECT ts,action,path FROM files WHERE session_id=? AND ts>? AND ts<?"
+                " ORDER BY ts", (sid, ts, nxt)).fetchall()
+        else:
+            files = con.execute(
+                "SELECT ts,action,path FROM files WHERE session_id=? AND ts>?"
+                " ORDER BY ts", (sid, ts)).fetchall()
+        durable = [f for f in files if f[1] in ("write", "edit")]
+        if durable: landed += 1
+        else: stalled += 1
+        blocks.append((ts, proj, cwd, sid, text, branch, files, durable))
+
+    total = len(blocks)
+    pct = (100.0 * landed / total) if total else 0.0
+    print("\033[1m%s\033[0m  %d prompt%s you typed · \033[32m%d landed\033[0m · "
+          "\033[31m%d produced nothing durable\033[0m · %.0f%%"
+          % (args.query, total, "" if total == 1 else "s", landed, stalled, pct))
+    print("\033[2mdurable = a Write or Edit in the same session before your next prompt. "
+          "CO-OCCURRENCE, not proof of cause or correctness.\033[0m\n")
+
+    for ts, proj, cwd, sid, text, branch, files, durable in blocks:
+        mark = "\033[32m●\033[0m" if durable else "\033[31m○\033[0m"
+        head = " ".join((text or "").split())[:110]
+        br = (" \033[2m%s\033[0m" % branch) if branch else ""
+        print("%s %s  \033[36m%s\033[0m%s  \033[2m%s\033[0m"
+              % (mark, _day(ts), _repo(cwd, proj)[:22], br, (sid or "")[:8]))
+        print("   \033[1m\"%s\"\033[0m" % head)
+        if not files:
+            print("   \033[31mnothing touched\033[0m")
+        else:
+            shown = files if args.all else files[:8]
+            for fts, action, path in shown:
+                tag = {"write": "\033[32mWROTE\033[0m", "edit": "\033[33mEDIT \033[0m",
+                       "read": "\033[2mread \033[0m"}.get(action, action.upper())
+                print("   %s %s" % (tag, path))
+            if len(files) > len(shown):
+                print("   \033[2m… %d more, -a to show all\033[0m" % (len(files) - len(shown)))
+        print()
+
+
 def cmd_sessions(args):
     con = connect()
     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.
         t = con.execute("SELECT text FROM messages WHERE session_id=? AND role='user'"
-                        " AND text!='' ORDER BY ts LIMIT 1", (sid,)).fetchone()
-        title = (t[0][:90].replace("\n", " ") if t else "(no user text)")
+                        " 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))
 
@@ -908,6 +1027,102 @@ def _codex_rows(path):
     return rows
 
 
+# --- Cursor CLI ------------------------------------------------------------
+# Cursor writes ~/.cursor/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl
+# with the SAME {role, message:{content:[...]}} shape Claude Code uses, so
+# extract() already reads it. Three things are missing and this connector adds
+# them: there is no timestamp field (it is embedded in the user text), no cwd
+# field (it is the directory slug), and the human turn is wrapped in
+# <user_query> tags that would otherwise be graded as part of the prompt.
+
+_CUR_TS = re.compile(r"<timestamp>(.*?)</timestamp>", re.S)
+_CUR_Q = re.compile(r"<user_query>\s*(.*?)\s*</user_query>", re.S)
+
+
+def _cursor_ts(text):
+    """'Thursday, Aug 13, 2026, 5:53 PM (UTC+2)' -> ISO-ish, or ''. Never guesses
+    a date it cannot parse: an unparsed stamp yields '' rather than today."""
+    m = _CUR_TS.search(text or "")
+    if not m:
+        return ""
+    raw = m.group(1).strip()
+    for fmt in ("%A, %b %d, %Y, %I:%M %p", "%A, %B %d, %Y, %I:%M %p"):
+        try:
+            import datetime
+            return datetime.datetime.strptime(raw.split(" (")[0], fmt).isoformat()
+        except Exception:
+            pass
+    return ""
+
+
+def _cursor_cwd(path):
+    """~/.cursor/projects/Users-morkeeth-CODE-zup/... -> /Users/morkeeth/CODE/zup.
+    The slug is lossy (a real hyphen in a directory name is indistinguishable
+    from the separator), so the result is checked on disk and dropped if it is
+    not a real directory. A wrong cwd is worse than no cwd."""
+    parts = os.path.normpath(path).split(os.sep)
+    try:
+        slug = parts[parts.index("projects") + 1]
+    except (ValueError, IndexError):
+        return ""
+    cand = "/" + slug.replace("-", "/")
+    if os.path.isdir(cand):
+        return cand
+    # try collapsing trailing segments back into hyphenated names
+    segs = slug.split("-")
+    for join_from in range(len(segs) - 1, 0, -1):
+        cand = "/" + "/".join(segs[:join_from] + ["-".join(segs[join_from:])])
+        if os.path.isdir(cand):
+            return cand
+    return ""
+
+
+def _cursor_rows(path):
+    """Normalise Cursor records onto the Claude shape the indexer already reads.
+
+    AUTHORSHIP, stated because it is a DIFFERENT gate with different provenance.
+    Claude Code stamps `promptSource: typed`, which is the measured-reliable signal
+    (~95% of raw `type: user` records are not the operator). Cursor has no such
+    field. Its one honest equivalent is the `<user_query>` wrapper: Cursor puts it
+    around a prompt the operator submitted, and injected/tool-result user records
+    do not carry it. So a Cursor record counts as typed IFF it carried that
+    wrapper. This is a weaker signal than Claude's and it is labelled as such
+    rather than silently pooled with it.
+    """
+    cwd = _cursor_cwd(path)
+    sid = os.path.splitext(os.path.basename(path))[0]
+    last_ts = ""
+    out = []
+    for d in _iter_json(path):
+        if not isinstance(d, dict) or "message" not in d:
+            continue
+        msg = d.get("message") or {}
+        c = msg.get("content")
+        wrapped = False
+        if isinstance(c, list):
+            for b in c:
+                if isinstance(b, dict) and b.get("type") == "text":
+                    t = b.get("text") or ""
+                    ts = _cursor_ts(t)
+                    if ts:
+                        last_ts = ts
+                    q = _CUR_Q.search(t)
+                    if q:
+                        b["text"] = q.group(1)
+                        wrapped = True
+                    elif _CUR_TS.search(t):
+                        b["text"] = _CUR_TS.sub("", t).strip()
+        role = d.get("role") or msg.get("role")
+        d["type"] = "user" if role == "user" else "assistant"
+        if role == "user" and wrapped:
+            d["promptSource"] = "typed"
+        d["timestamp"] = last_ts
+        d["cwd"] = cwd
+        d["sessionId"] = sid
+        out.append(d)
+    return out
+
+
 def _sniff(path):
     """'codex' (rollout), 'codex-history' (history.jsonl), or 'claude', from the
     first parseable record. Lets `--root ~/.codex` and mixed dirs just work."""
@@ -916,6 +1131,9 @@ def _sniff(path):
             return "codex"
         if set(d.keys()) == {"session_id", "ts", "text"}:
             return "codex-history"
+        # Cursor: role + message only, and none of Claude's envelope fields.
+        if set(d.keys()) <= {"role", "message"} and "message" in d:
+            return "cursor"
         return "claude"
     return "claude"
 
@@ -928,6 +1146,8 @@ def _rows_for_file(path):
         return _codex_rows(path), "codex"
     if h == "codex-history":
         return [], "codex-history"
+    if h == "cursor":
+        return _cursor_rows(path), "cursor"
     return list(_iter_json(path)), "claude"
 
 
@@ -942,6 +1162,10 @@ def _coach_files(roots, harness):
             paths.append(r)
             continue
         base = os.path.basename(r.rstrip("/"))
+        if harness == "cursor" or base == ".cursor":
+            paths += sorted(glob.glob(
+                os.path.join(r, "projects", "*", "agent-transcripts", "*", "*.jsonl")))
+            continue
         if harness == "codex" or base == ".codex":
             got = sorted(glob.glob(os.path.join(r, "archived_sessions", "*.jsonl")))
             got += sorted(glob.glob(os.path.join(r, "sessions", "**", "*.jsonl"),
@@ -1194,7 +1418,11 @@ def _coach_roots(root=None, harness=None):
     Single source of truth so the empty-result message names the real path."""
     if root:
         return [root]
-    return [os.path.expanduser("~/.codex")] if harness == "codex" else list(ROOTS)
+    if harness == "codex":
+        return [os.path.expanduser("~/.codex")]
+    if harness == "cursor":
+        return [os.path.expanduser("~/.cursor")]
+    return list(ROOTS)
 
 
 def coach(roots=None, harness=None, verified_human=False):
@@ -1247,8 +1475,15 @@ def coach(roots=None, harness=None, verified_human=False):
         "durable_rate": round(durable / len(episodes), 3) if episodes else 0.0,
         "tiers": tiers,
         "top_patterns": rankable[:5],
-        "bottom_patterns": (rankable[-5:][::-1] if len(rankable) > 5
-                            else rankable[::-1][:5]),
+        # SURVIVES LEAST must draw only from habits SURVIVES MOST did not take.
+        # The old guard was `len(rankable) > 5`, which only protected the <=5 case:
+        # with 6-9 rankable habits, rankable[:5] and rankable[-5:] overlap, and the
+        # tool printed the SAME row under "do more of these" and "these tend to
+        # loop" with the same denominator. A first-time user has 6-9 habits, so the
+        # 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],
         "best_prompt": _pick(episodes, True,
                              lambda e: (e["score"], -e["corrective_turns"],
                                         e["assistant_turns"])),
@@ -1280,8 +1515,12 @@ def cmd_coach(args):
         print("\n  this reads transcripts that already exist on your machine; it does not")
         print("  create them. if that directory is empty, use the agent for a session first.\n")
         print("  otherwise:")
-        print("    %s coach --harness codex      grade Codex (~/.codex) instead" % PROG)
-        print("    %s coach --root <dir>         point at a folder of .jsonl transcripts\n" % PROG)
+        # All three supported harnesses are offered here. Listing only two while the
+        # README sells three is how a stranger concludes cursor is unsupported.
+        print("    %s coach --harness codex       grade Codex (~/.codex) instead" % PROG)
+        print("    %s coach --harness cursor      grade Cursor "
+              "(~/.cursor/projects/*/agent-transcripts)" % PROG)
+        print("    %s coach --root <dir>          point at a folder of .jsonl transcripts\n" % PROG)
         return
     B, D = "\033[1m", "\033[0m"
     print("\n  %sYOUR PROMPT HABITS, GRADED%s   (offline, your machine only)\n" % (B, D))
@@ -1322,10 +1561,17 @@ def cmd_coach(args):
         for p in r["top_patterns"]:
             print("    %3d%%  (%s/%s)  %s" % (round(p["survival_rate"] * 100),
                                               p["survived"], p["n"], p["pattern"]))
-        print("\n  %sSURVIVES LEAST%s  these tend to loop:" % (B, D))
-        for p in r["bottom_patterns"]:
-            print("    %3d%%  (%s/%s)  %s" % (round(p["survival_rate"] * 100),
-                                              p["survived"], p["n"], p["pattern"]))
+        # With <=5 rankable habits SURVIVES MOST already showed all of them, so
+        # there is no honest "least" left to print. An empty header under a
+        # promise ("these tend to loop") is a claim about rows that do not exist.
+        if r["bottom_patterns"]:
+            print("\n  %sSURVIVES LEAST%s  these tend to loop:" % (B, D))
+            for p in r["bottom_patterns"]:
+                print("    %3d%%  (%s/%s)  %s" % (round(p["survival_rate"] * 100),
+                                                  p["survived"], p["n"], p["pattern"]))
+        else:
+            print("\n  \033[2m(every rankable habit is listed above; too few to split "
+                  "into a most/least pair)\033[0m")
     b = r["best_prompt"]
     if b:
         print("\n  \033[32m+\033[0m your best landed prompt, with its witness:")
@@ -1344,12 +1590,16 @@ def cmd_coach(args):
 def main():
     p = argparse.ArgumentParser(prog=PROG, description=__doc__ + USAGE,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--version", action="version", version="%s %s" % (PROG, VERSION))
     sub = p.add_subparsers(dest="cmd")
     sub.add_parser("index").set_defaults(fn=cmd_index)
     s = sub.add_parser("watch"); s.add_argument("--interval", type=int, default=5); s.set_defaults(fn=cmd_watch)
     s = sub.add_parser("ask"); s.add_argument("query"); s.add_argument("-n", "--limit", type=int, default=25); s.set_defaults(fn=cmd_ask)
     s = sub.add_parser("search"); s.add_argument("query"); s.add_argument("-n", "--limit", type=int, default=25); s.set_defaults(fn=cmd_search)
     s = sub.add_parser("find"); s.add_argument("name"); s.set_defaults(fn=cmd_find)
+    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)
     sub.add_parser("stats").set_defaults(fn=cmd_stats)
     s = sub.add_parser("cost")
@@ -1359,9 +1609,10 @@ def main():
     s.set_defaults(fn=cmd_cost)
     s = sub.add_parser("coach")
     s.add_argument("--root", help="grade this transcript dir instead of ~/.claude/projects")
-    s.add_argument("--harness", choices=["claude", "codex"],
+    s.add_argument("--harness", choices=["claude", "codex", "cursor"],
                    help="which agent's transcripts to grade. codex reads "
-                        "~/.codex (archived_sessions + sessions). default: auto-detect")
+                        "~/.codex (archived_sessions + sessions); cursor reads "
+                        "~/.cursor/projects/*/agent-transcripts. default: auto-detect")
     s.add_argument("--verified-human", dest="verified_human", action="store_true",
                    help="subtract likely-PASTED turns: a typed turn whose text is a "
                         "verbatim/high n-gram echo of an earlier agent or tool message "