transcripto 0.1.3__tar.gz → 0.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.3
+Version: 0.1.4
 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
@@ -73,18 +73,18 @@ the same way.
 
 ## what you get back
 
-this is a real run on one machine, pasted unedited, 2026-08-31:
+this is a real run on one machine, 2026-08-31. The numbers are unedited; the two quoted prompts are synthetic stand-ins of the same shape, because your prompts never leave your machine and neither do mine:
 
 ```
 
   YOUR PROMPT HABITS, GRADED   (offline, your machine only)
 
   - your worst looped prompt, with its witness:
-      "ok, and lets see they might solve it in the future so i can go back to my beloeved routine :) Befor…"
+      "hmm ok lets just try again and see if it works this time, same thing as before but…"
       NO-DURABLE-RECORD: read-only Bash only, no file change  ·  corrections: 15  ·  assistant turns: 221
 
   + your best landed prompt, with its witness:
-      "mTERMINAL 8 — Mountain of Helicon · ~/CODE/mountain-of-helicon Read ~/CODE/mountain-of-helicon. Two…"
+      "TERMINAL 3 — parser · ~/CODE/demo Read hack.md. Fix the counter, run the suite, commit if green…"
       COMMIT-WITNESSED: git commit  ·  corrections: 0
 
   SURVIVAL IS A PROXY: survival = a durable Write/Edit or an un-reverted git commit in-episode. A PROXY, not proof the work was correct or shipped.
@@ -142,6 +142,74 @@ signal, not a verdict. if it ever prints something that flatters you, distrust i
 
 the caveat is printed in the output itself, every run, on purpose.
 
+## correction rate
+
+> in the repo since 2026-09-02, not yet on PyPI. `python3 transcripto.py coach` prints it.
+
+one more line under the coach footer:
+
+```
+  correction rate: 6% measured (227 of 4061 typed turns) · v1 catches ~1 in 6, so the real rate is ~26-37%
+```
+
+**correction rate = typed turns that correct the agent ÷ typed turns.** the denominator
+is the same authorship gate as every other number here (`typed` or `queued`, never
+`isMeta`, `isSidechain` or a tool result), so a tool result that happens to say "wrong"
+cannot move it. a typed turn counts as a correction when a **marker** fires in its head:
+the first 80 words after URLs and file paths are stripped, case-insensitive, whole-word:
+a leading or bare `no`, `again`, `wrong`, `not that`, `I meant`, `revert`, `undo`, `stop`,
+`instead`, plus a few measured additions. whole-word, so "against" is not "again" and
+"now" is not "no". the v0 "nudge" rule (a short turn naming the agent's last file) is gone:
+measured over 100 flagged rows it fired alone five times and was wrong five times.
+`TRANSCRIPTO_CORRECTION=v0` brings the old classifier back for comparison.
+
+it is one pure function, `is_correction(text)`, and it is a **floor**, now measured rather
+than asserted: on a 200-row labelled sample the v1 classifier has precision 0.81 and recall
+0.16 (`docs/CORRECTION-PRECISION-2026-09-03.md`), which is why the printed line carries the
+"~1 in 6" correction and a range. read it as a trend on your own history.
+`test_correction.sh` pins the rule and the gate on `fixtures-correction/`.
+
+## export-run
+
+> in the repo since 2026-09-02, not yet on PyPI.
+
+```
+transcripto export-run latest                 # the newest session on this machine
+transcripto export-run 3f9c1a2b               # a session id, or a prefix of one
+transcripto export-run path/to/session.jsonl  # a transcript file
+transcripto export-run latest --harness codex # --root / --harness as for coach
+```
+
+one run's numbers as JSON, read straight from the transcript file (no index needed).
+this is the contract other tools read (Agent Grinder's card, ZUP's board); the keys are
+frozen under `schema`, and a new key is an addition, never a rename.
+
+| key | meaning |
+|---|---|
+| `schema` | `transcripto.export-run/1` |
+| `session_id` | the harness's session id (Claude Code: the file name; Codex: `session_meta.id`; Cursor: the file name) |
+| `project` | the run's `cwd` |
+| `harness` | `claude` · `codex` · `cursor` |
+| `transcript` | absolute path of the file read |
+| `started` · `ended` | first and last record timestamp, UTC, `…Z`; `null` if the file carries none |
+| `duration_s` | `ended − started`, whole seconds |
+| `records` | every record in the file, before any gate |
+| `typed_turns` | records that pass the authorship gate: `promptSource` typed or queued, never meta, sidechain or tool result. the same count coach prints as "typed by you" |
+| `corrections` | typed turns `is_correction()` flags (see above) |
+| `correction_rate` | `corrections / typed_turns`, 3 decimals; `null` when nothing was typed |
+| `tool_calls` | every `tool_use` block the agent emitted |
+| `files_touched` | sorted set of `file_path` (or `notebook_path`) from Edit / Write / Read / MultiEdit / NotebookEdit calls |
+| `commits_in_window` | commits stamped inside `[started, ended]` in the project's git reflog; `null` when `project` is not inside a git repo |
+| `commits` | those commits as `{sha, ts, subject}`, oldest first; `null` when not a repo |
+| `proxy` | the caveat, in the JSON so it travels with the numbers |
+
+`commits_in_window` reads `.git/logs/HEAD` directly, not `git log`, because this file
+does not shell out (see privacy). the reflog is the record of what **that working tree**
+did: a commit made there in the window is in it, a commit pulled in from elsewhere is not.
+git expires the reflog after 90 days by default, so a run older than that can read 0 here
+while `git log` would still show its commits. `commit (amend)` counts; a rebase's `pick`
+lines do not. a `.git` file (a worktree) is followed to its gitdir.
+
 ## why your own gate matters here
 
 at fleet scale roughly 95% of the `type: user` records in a transcript are not
@@ -199,15 +267,15 @@ 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
-260:    import time
-1051:            import datetime
-1061:    from the separator), so the result is checked on disk and dropped if it is
+261:    import time
+1160:            import datetime
+1170:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
 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
+anchor either. line 1170 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.
 
@@ -246,6 +314,7 @@ 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)
+transcripto export-run one run's numbers as JSON (typed turns, correction rate, commits)
 ```
 
 `ask` is the one that kills "wait, did i lose something?". it answers "what was i
@@ -306,9 +375,12 @@ just gives the file a name on your PATH.
 ./test_cost.sh         12 assertions
 ./test_small_n.sh       7 assertions
 ./test_label_bands.sh  13 assertions
+./test_correction.sh   32 assertions   (correction rate + export-run, 2026-09-02)
+./test_cursor_partial.sh 7 assertions
+./test_version.sh       1 assertion    (VERSION matches in transcripto.py and pyproject.toml)
 ```
 
-61 assertions, all green, re-run 2026-08-31.
+91 assertions, all green, re-run 2026-09-02.
 
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.

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

@@ -55,18 +55,18 @@ the same way.
 
 ## what you get back
 
-this is a real run on one machine, pasted unedited, 2026-08-31:
+this is a real run on one machine, 2026-08-31. The numbers are unedited; the two quoted prompts are synthetic stand-ins of the same shape, because your prompts never leave your machine and neither do mine:
 
 ```
 
   YOUR PROMPT HABITS, GRADED   (offline, your machine only)
 
   - your worst looped prompt, with its witness:
-      "ok, and lets see they might solve it in the future so i can go back to my beloeved routine :) Befor…"
+      "hmm ok lets just try again and see if it works this time, same thing as before but…"
       NO-DURABLE-RECORD: read-only Bash only, no file change  ·  corrections: 15  ·  assistant turns: 221
 
   + your best landed prompt, with its witness:
-      "mTERMINAL 8 — Mountain of Helicon · ~/CODE/mountain-of-helicon Read ~/CODE/mountain-of-helicon. Two…"
+      "TERMINAL 3 — parser · ~/CODE/demo Read hack.md. Fix the counter, run the suite, commit if green…"
       COMMIT-WITNESSED: git commit  ·  corrections: 0
 
   SURVIVAL IS A PROXY: survival = a durable Write/Edit or an un-reverted git commit in-episode. A PROXY, not proof the work was correct or shipped.
@@ -124,6 +124,74 @@ signal, not a verdict. if it ever prints something that flatters you, distrust i
 
 the caveat is printed in the output itself, every run, on purpose.
 
+## correction rate
+
+> in the repo since 2026-09-02, not yet on PyPI. `python3 transcripto.py coach` prints it.
+
+one more line under the coach footer:
+
+```
+  correction rate: 6% measured (227 of 4061 typed turns) · v1 catches ~1 in 6, so the real rate is ~26-37%
+```
+
+**correction rate = typed turns that correct the agent ÷ typed turns.** the denominator
+is the same authorship gate as every other number here (`typed` or `queued`, never
+`isMeta`, `isSidechain` or a tool result), so a tool result that happens to say "wrong"
+cannot move it. a typed turn counts as a correction when a **marker** fires in its head:
+the first 80 words after URLs and file paths are stripped, case-insensitive, whole-word:
+a leading or bare `no`, `again`, `wrong`, `not that`, `I meant`, `revert`, `undo`, `stop`,
+`instead`, plus a few measured additions. whole-word, so "against" is not "again" and
+"now" is not "no". the v0 "nudge" rule (a short turn naming the agent's last file) is gone:
+measured over 100 flagged rows it fired alone five times and was wrong five times.
+`TRANSCRIPTO_CORRECTION=v0` brings the old classifier back for comparison.
+
+it is one pure function, `is_correction(text)`, and it is a **floor**, now measured rather
+than asserted: on a 200-row labelled sample the v1 classifier has precision 0.81 and recall
+0.16 (`docs/CORRECTION-PRECISION-2026-09-03.md`), which is why the printed line carries the
+"~1 in 6" correction and a range. read it as a trend on your own history.
+`test_correction.sh` pins the rule and the gate on `fixtures-correction/`.
+
+## export-run
+
+> in the repo since 2026-09-02, not yet on PyPI.
+
+```
+transcripto export-run latest                 # the newest session on this machine
+transcripto export-run 3f9c1a2b               # a session id, or a prefix of one
+transcripto export-run path/to/session.jsonl  # a transcript file
+transcripto export-run latest --harness codex # --root / --harness as for coach
+```
+
+one run's numbers as JSON, read straight from the transcript file (no index needed).
+this is the contract other tools read (Agent Grinder's card, ZUP's board); the keys are
+frozen under `schema`, and a new key is an addition, never a rename.
+
+| key | meaning |
+|---|---|
+| `schema` | `transcripto.export-run/1` |
+| `session_id` | the harness's session id (Claude Code: the file name; Codex: `session_meta.id`; Cursor: the file name) |
+| `project` | the run's `cwd` |
+| `harness` | `claude` · `codex` · `cursor` |
+| `transcript` | absolute path of the file read |
+| `started` · `ended` | first and last record timestamp, UTC, `…Z`; `null` if the file carries none |
+| `duration_s` | `ended − started`, whole seconds |
+| `records` | every record in the file, before any gate |
+| `typed_turns` | records that pass the authorship gate: `promptSource` typed or queued, never meta, sidechain or tool result. the same count coach prints as "typed by you" |
+| `corrections` | typed turns `is_correction()` flags (see above) |
+| `correction_rate` | `corrections / typed_turns`, 3 decimals; `null` when nothing was typed |
+| `tool_calls` | every `tool_use` block the agent emitted |
+| `files_touched` | sorted set of `file_path` (or `notebook_path`) from Edit / Write / Read / MultiEdit / NotebookEdit calls |
+| `commits_in_window` | commits stamped inside `[started, ended]` in the project's git reflog; `null` when `project` is not inside a git repo |
+| `commits` | those commits as `{sha, ts, subject}`, oldest first; `null` when not a repo |
+| `proxy` | the caveat, in the JSON so it travels with the numbers |
+
+`commits_in_window` reads `.git/logs/HEAD` directly, not `git log`, because this file
+does not shell out (see privacy). the reflog is the record of what **that working tree**
+did: a commit made there in the window is in it, a commit pulled in from elsewhere is not.
+git expires the reflog after 90 days by default, so a run older than that can read 0 here
+while `git log` would still show its commits. `commit (amend)` counts; a rebase's `pick`
+lines do not. a `.git` file (a worktree) is followed to its gitdir.
+
 ## why your own gate matters here
 
 at fleet scale roughly 95% of the `type: user` records in a transcript are not
@@ -181,15 +249,15 @@ 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
-260:    import time
-1051:            import datetime
-1061:    from the separator), so the result is checked on disk and dropped if it is
+261:    import time
+1160:            import datetime
+1170:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
 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
+anchor either. line 1170 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.
 
@@ -228,6 +296,7 @@ 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)
+transcripto export-run one run's numbers as JSON (typed turns, correction rate, commits)
 ```
 
 `ask` is the one that kills "wait, did i lose something?". it answers "what was i
@@ -288,9 +357,12 @@ just gives the file a name on your PATH.
 ./test_cost.sh         12 assertions
 ./test_small_n.sh       7 assertions
 ./test_label_bands.sh  13 assertions
+./test_correction.sh   32 assertions   (correction rate + export-run, 2026-09-02)
+./test_cursor_partial.sh 7 assertions
+./test_version.sh       1 assertion    (VERSION matches in transcripto.py and pyproject.toml)
 ```
 
-61 assertions, all green, re-run 2026-08-31.
+91 assertions, all green, re-run 2026-09-02.
 
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcripto
-Version: 0.1.3
+Version: 0.1.4
 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
@@ -73,18 +73,18 @@ the same way.
 
 ## what you get back
 
-this is a real run on one machine, pasted unedited, 2026-08-31:
+this is a real run on one machine, 2026-08-31. The numbers are unedited; the two quoted prompts are synthetic stand-ins of the same shape, because your prompts never leave your machine and neither do mine:
 
 ```
 
   YOUR PROMPT HABITS, GRADED   (offline, your machine only)
 
   - your worst looped prompt, with its witness:
-      "ok, and lets see they might solve it in the future so i can go back to my beloeved routine :) Befor…"
+      "hmm ok lets just try again and see if it works this time, same thing as before but…"
       NO-DURABLE-RECORD: read-only Bash only, no file change  ·  corrections: 15  ·  assistant turns: 221
 
   + your best landed prompt, with its witness:
-      "mTERMINAL 8 — Mountain of Helicon · ~/CODE/mountain-of-helicon Read ~/CODE/mountain-of-helicon. Two…"
+      "TERMINAL 3 — parser · ~/CODE/demo Read hack.md. Fix the counter, run the suite, commit if green…"
       COMMIT-WITNESSED: git commit  ·  corrections: 0
 
   SURVIVAL IS A PROXY: survival = a durable Write/Edit or an un-reverted git commit in-episode. A PROXY, not proof the work was correct or shipped.
@@ -142,6 +142,74 @@ signal, not a verdict. if it ever prints something that flatters you, distrust i
 
 the caveat is printed in the output itself, every run, on purpose.
 
+## correction rate
+
+> in the repo since 2026-09-02, not yet on PyPI. `python3 transcripto.py coach` prints it.
+
+one more line under the coach footer:
+
+```
+  correction rate: 6% measured (227 of 4061 typed turns) · v1 catches ~1 in 6, so the real rate is ~26-37%
+```
+
+**correction rate = typed turns that correct the agent ÷ typed turns.** the denominator
+is the same authorship gate as every other number here (`typed` or `queued`, never
+`isMeta`, `isSidechain` or a tool result), so a tool result that happens to say "wrong"
+cannot move it. a typed turn counts as a correction when a **marker** fires in its head:
+the first 80 words after URLs and file paths are stripped, case-insensitive, whole-word:
+a leading or bare `no`, `again`, `wrong`, `not that`, `I meant`, `revert`, `undo`, `stop`,
+`instead`, plus a few measured additions. whole-word, so "against" is not "again" and
+"now" is not "no". the v0 "nudge" rule (a short turn naming the agent's last file) is gone:
+measured over 100 flagged rows it fired alone five times and was wrong five times.
+`TRANSCRIPTO_CORRECTION=v0` brings the old classifier back for comparison.
+
+it is one pure function, `is_correction(text)`, and it is a **floor**, now measured rather
+than asserted: on a 200-row labelled sample the v1 classifier has precision 0.81 and recall
+0.16 (`docs/CORRECTION-PRECISION-2026-09-03.md`), which is why the printed line carries the
+"~1 in 6" correction and a range. read it as a trend on your own history.
+`test_correction.sh` pins the rule and the gate on `fixtures-correction/`.
+
+## export-run
+
+> in the repo since 2026-09-02, not yet on PyPI.
+
+```
+transcripto export-run latest                 # the newest session on this machine
+transcripto export-run 3f9c1a2b               # a session id, or a prefix of one
+transcripto export-run path/to/session.jsonl  # a transcript file
+transcripto export-run latest --harness codex # --root / --harness as for coach
+```
+
+one run's numbers as JSON, read straight from the transcript file (no index needed).
+this is the contract other tools read (Agent Grinder's card, ZUP's board); the keys are
+frozen under `schema`, and a new key is an addition, never a rename.
+
+| key | meaning |
+|---|---|
+| `schema` | `transcripto.export-run/1` |
+| `session_id` | the harness's session id (Claude Code: the file name; Codex: `session_meta.id`; Cursor: the file name) |
+| `project` | the run's `cwd` |
+| `harness` | `claude` · `codex` · `cursor` |
+| `transcript` | absolute path of the file read |
+| `started` · `ended` | first and last record timestamp, UTC, `…Z`; `null` if the file carries none |
+| `duration_s` | `ended − started`, whole seconds |
+| `records` | every record in the file, before any gate |
+| `typed_turns` | records that pass the authorship gate: `promptSource` typed or queued, never meta, sidechain or tool result. the same count coach prints as "typed by you" |
+| `corrections` | typed turns `is_correction()` flags (see above) |
+| `correction_rate` | `corrections / typed_turns`, 3 decimals; `null` when nothing was typed |
+| `tool_calls` | every `tool_use` block the agent emitted |
+| `files_touched` | sorted set of `file_path` (or `notebook_path`) from Edit / Write / Read / MultiEdit / NotebookEdit calls |
+| `commits_in_window` | commits stamped inside `[started, ended]` in the project's git reflog; `null` when `project` is not inside a git repo |
+| `commits` | those commits as `{sha, ts, subject}`, oldest first; `null` when not a repo |
+| `proxy` | the caveat, in the JSON so it travels with the numbers |
+
+`commits_in_window` reads `.git/logs/HEAD` directly, not `git log`, because this file
+does not shell out (see privacy). the reflog is the record of what **that working tree**
+did: a commit made there in the window is in it, a commit pulled in from elsewhere is not.
+git expires the reflog after 90 days by default, so a run older than that can read 0 here
+while `git log` would still show its commits. `commit (amend)` counts; a rebase's `pick`
+lines do not. a `.git` file (a worktree) is followed to its gitdir.
+
 ## why your own gate matters here
 
 at fleet scale roughly 95% of the `type: user` records in a transcript are not
@@ -199,15 +267,15 @@ 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
-260:    import time
-1051:            import datetime
-1061:    from the separator), so the result is checked on disk and dropped if it is
+261:    import time
+1160:            import datetime
+1170:    from the separator), so the result is checked on disk and dropped if it is
 ```
 
 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
+anchor either. line 1170 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.
 
@@ -246,6 +314,7 @@ 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)
+transcripto export-run one run's numbers as JSON (typed turns, correction rate, commits)
 ```
 
 `ask` is the one that kills "wait, did i lose something?". it answers "what was i
@@ -306,9 +375,12 @@ just gives the file a name on your PATH.
 ./test_cost.sh         12 assertions
 ./test_small_n.sh       7 assertions
 ./test_label_bands.sh  13 assertions
+./test_correction.sh   32 assertions   (correction rate + export-run, 2026-09-02)
+./test_cursor_partial.sh 7 assertions
+./test_version.sh       1 assertion    (VERSION matches in transcripto.py and pyproject.toml)
 ```
 
-61 assertions, all green, re-run 2026-08-31.
+91 assertions, all green, re-run 2026-09-02.
 
 offline, no keys, on fixtures that inherit the real transcript shape including
 all four ways a non-human record disguises itself as `type: user`.

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

@@ -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.3"
+VERSION = "0.1.4"
 
 USAGE = """
   %(p)s index                 build / refresh the index (incremental)
@@ -38,6 +38,7 @@ USAGE = """
   %(p)s coach                 which of YOUR prompt habits actually survive (a proxy)
   %(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)s export-run <session|latest>  one run's numbers as JSON: typed turns, correction rate, commits
 """ % {"p": PROG}
 
 HOME = os.path.expanduser("~")
@@ -147,7 +148,7 @@ def extract(d):
             if bt == "text":
                 parts.append(b.get("text", ""))
             elif bt == "tool_use":
-                name, inp = b.get("name", ""), (b.get("input") or {})
+                name, inp = b.get("name", ""), _tool_input(b)
                 fp = inp.get("file_path") or inp.get("path") or inp.get("notebook_path")
                 if fp:
                     files.append((FILE_TOOLS.get(name, name.lower()), fp))
@@ -880,6 +881,181 @@ def _looks_corrective(text):
     return any(low.startswith(" " + m) or (" " + m) in low for m in _CORRECTIVE_MARKERS)
 
 
+# ============================================================================
+# correction rate — the inverse of a landed prompt
+# ============================================================================
+# Of the turns you TYPED, how many were spent telling the agent it got the last
+# one wrong. The denominator is the same authorship gate every other number here
+# uses (is_human_turn: typed OR queued, never isMeta / isSidechain / tool_result),
+# so a tool result that happens to contain the word "wrong" cannot inflate it.
+# The classifier is lexical and it is a FLOOR, stated so it can be argued with:
+# a correction phrased without a marker ("the header one") is missed, and a
+# genuine "no" inside a fresh request ("no tests needed") is counted. Read it as
+# a trend on your own history, never as a verdict on one turn.
+
+_CORRECTION_MARKERS = ("no,", "no ", "not that", "wrong", "i meant", "i said",
+                       "again", "that's not", "you didn't", "revert", "undo",
+                       "stop", "instead")
+_CORRECTION_HEAD = 80     # markers are looked for in the first N characters only
+_CORRECTION_SHORT = 12    # a turn under this many words, right after an agent
+                          # turn that names the same file, is a nudge = correction
+_CORRECTION_RE = re.compile(
+    "(?<![a-z0-9_])(?:" + "|".join(
+        re.escape(m).replace("'", "['\u2019]")
+        + ("" if m[-1] in ", " else "(?![a-z0-9_])")
+        for m in _CORRECTION_MARKERS) + ")")
+
+# ---------------------------------------------------------------------------
+# v1 — the same question, rebuilt against a measured failure set.
+#
+# v0 was measured on 2026-09-03 over 200 agent-labelled turns (see
+# docs/CORRECTION-PRECISION-2026-09-03.md): precision 0.54, recall 0.12, and a
+# printed rate of 6% against a measured ~26%. The two biggest markers were the
+# two worst: bare "no " ran at 56% precision because it is the commonest way to
+# say something about the WORLD ("no worries", "no clue"), and bare "again" ran
+# at 54% because resuming work ("lets pick this up again") is lexically identical
+# to rejecting it. The NUDGE rule went 0-for-5.
+#
+# So v1 keeps the two words only where the grammar makes them about the agent.
+#
+# WHAT THIS STILL IS NOT: a classifier that understands the sentence. It is a
+# better lexicon, tested on a held-out sample, and it will still miss a
+# correction phrased without any of these words.
+
+# "no" only where a pronoun, an imperative, or a comma makes it a rejection of
+# what the agent just did, rather than a description of the world.
+_V1_NO = (r"(?:^|[\s,;:])no[,!]"
+          r"|(?:^|[\s,;:])no\s+(?:you|we|i|it|that|thats|dont|don't|need\s+to|"
+          r"please|wait|new\s+work|not)"
+          r"|(?:^|[\s,;:])(?:thats|that's|its|it's)\s+not\b"
+          r"|(?:^|[\s,;:])no\b\s*$")
+
+# "again" only next to a retry imperative or a complaint. "once again" alone is
+# continuation; "try again" and "once again <negative>" are not.
+_V1_AGAIN = (r"\btry(?:ing)?\s+again\b"
+             r"|\bagain\?"
+             r"|\b(?:once\s+)?again\b[^.!?]{0,40}?\b(?:wrong|not|no|never|"
+             r"broke|broken|fail|failed|mix(?:ed)?\s+up|missing|stuck|horrible|"
+             r"bad|lost|misunderstood|conflict)"
+             r"|\b(?:wrong|not|never|broke|broken|fail|failed|missing|stuck|"
+             r"horrible|misunderstood|conflict|mix(?:ed)?\s+up|lo[os]t|lose|"
+             r"loose|swamp(?:ed|ing)?)\b[^.!?]{0,40}?\b(?:once\s+)?again\b")
+
+# The register v0 had no words for at all, measured from its 24 misses.
+_V1_EXTRA = (r"\bfix\s+(?:it|this|that)\b"
+             r"|\bi\s+mean\b"
+             r"|\bdon'?t\s+like\b"
+             r"|\b(?:doesn'?t|does\s+not|isn'?t|is\s+not)\s+work"
+             r"|\bnot\s+working\b"
+             r"|\bnonsense\b|\bgibberish\b"
+             r"|\bshould\s?n'?t\b|\bshouldnt\b"
+             r"|\bmisunderstood\b|\bmisunderstanding\b"
+             r"|\byou\s+did\s?n'?t\b|\byou'?re\s+(?:wrong|lost|on\s+the\s+wrong)\b"
+             r"|\bwhere'?s?\s+the\b"
+             r"|\bis\s+this\s+(?:accurate|right|correct)\b"
+             r"|\bmakes\s+no\s+sense\b"
+             r"|\bmeans\s+nothing\b"
+             r"|\b(?:change|redo|rewrite|remove)\s+(?:it|this|that)\b")
+
+_V1_RE = re.compile("(?:%s|%s|%s|%s)" % (
+    _V1_NO, _V1_AGAIN, _V1_EXTRA,
+    # the v0 markers that measured well enough to keep, unchanged
+    r"\bwrong\b|\bnot\s+that\b|\bi\s+meant\b|\brevert\b|\bundo\b"
+    r"|\bstop\b|\binstead\b"), re.I)
+
+# A head taken in WORDS after URLs and paths are stripped. v0 read the first 80
+# CHARACTERS raw, so a turn opening with a pasted URL spent its whole window on
+# the URL and was unclassifiable — measured, not hypothesised: one sampled row's
+# "once again ... change it" sat at roughly character 100.
+_V1_HEAD_WORDS = 80
+_URLISH = re.compile(r"(?:https?://|file://|/(?:Users|tmp|var|home)/)\S+|\S+\.(?:png|jpe?g|gif|pdf|mp4|mov)\b", re.I)
+
+
+def _v1_head(text):
+    """The first _V1_HEAD_WORDS words, with URLs and absolute paths removed."""
+    return " ".join(_URLISH.sub(" ", text).split()[:_V1_HEAD_WORDS]).lower()
+
+
+# Which classifier runs. v1 is the default; v0 stays reachable so the two can be
+# compared on one corpus. An explicit selector rather than a bare boolean, so a
+# caller comparing versions cannot accidentally compare v1 to itself.
+_CORRECTION_VERSION = os.environ.get("TRANSCRIPTO_CORRECTION", "v1")
+if _CORRECTION_VERSION not in ("v0", "v1"):
+    _CORRECTION_VERSION = "v1"
+
+
+def _quoted_things(text):
+    """The file basenames and `backticked` spans a text names, lower-cased.
+    A path is reduced to its basename so "docs/caching.md" in your turn and
+    "/repo/docs/caching.md" in the agent's tool call read as the same file."""
+    out = set()
+    for m in _FILE_RE.finditer(text):
+        out.add(os.path.basename(m.group(0).rstrip(".,;:")).lower())
+    for m in re.finditer(r"`([^`\n]{2,80})`", text):
+        out.add(m.group(1).strip().lower())
+    return {t for t in out if len(t) >= 3}
+
+
+def is_correction(text, prev_agent="", version=None):
+    """True iff a typed turn reads as a correction of the agent's previous turn.
+
+    PURE: text in, bool out, no state. Two rules, both lexical:
+
+      1. MARKER - the first 80 characters (case-insensitive) start with or
+         contain one of _CORRECTION_MARKERS as a whole word: "no," "no " "not
+         that" "wrong" "I meant" "I said" "again" "that's not" "you didn't"
+         "revert" "undo" "stop" "instead". Whole-word, so "against" is not
+         "again", "undone" is not "undo", "now" and "know" are not "no ". A
+         bare "no" as the entire turn counts (the head is padded with a space).
+      2. NUDGE - the turn is short (< 12 words) and the agent turn immediately
+         before it, `prev_agent`, names the same file (matched by basename) or
+         the same `backticked` span. "docs/caching.md, shorter please" right
+         after the agent wrote docs/caching.md is a correction with no marker.
+
+    `prev_agent` is the extract()-rendered text of everything the assistant did
+    since the previous typed turn (its prose plus its tool commands and file
+    paths), or "" when this turn opened the session. The caller owns the
+    authorship gate; this function never sees a record, only text.
+    """
+    if (version or _CORRECTION_VERSION) == "v0":
+        head = text[:_CORRECTION_HEAD].lower().strip() + " "
+        if _CORRECTION_RE.search(head):
+            return True
+        # NUDGE. Kept in v0 exactly as it shipped; v1 drops it, because measured
+        # over 100 flagged rows it fired alone five times and was wrong five
+        # times. A rule with no true positive is not a loose rule, it is noise
+        # with a cost — it renders every assistant record since the last turn.
+        if prev_agent and len(text.split()) < _CORRECTION_SHORT:
+            return bool(_quoted_things(text) & _quoted_things(prev_agent))
+        return False
+    return bool(_V1_RE.search(_v1_head(text)))
+
+
+def count_corrections(rows, pasted=None, version=None):
+    """(typed_turns, corrections) over one transcript, walked in order so each
+    typed turn is classified against the agent turn it answers. Same gate and
+    same paste subtraction as the episode grader, so the denominator returned
+    here IS the `typed by you` count coach prints."""
+    pasted = pasted or set()
+    typed = corrections = 0
+    agent = []                       # assistant records since the last typed turn
+    for row in rows:
+        t = _human_prompt(row)
+        if t:
+            if t in pasted:
+                continue             # an echo of agent output, not a turn of yours
+            typed += 1
+            prev = ""
+            if agent and len(t.split()) < _CORRECTION_SHORT:
+                prev = "\n".join(extract(r)[1] for r in agent)
+            if is_correction(t, prev, version=version):
+                corrections += 1
+            agent = []
+        elif row.get("type") == "assistant":
+            agent.append(row)
+    return typed, corrections
+
+
 def _human_prompt(d):
     """The text of a genuine human turn, or '' — reuses the measured gate."""
     if not is_human_turn(d):
@@ -894,6 +1070,17 @@ def _human_prompt(d):
     return ""
 
 
+def _tool_input(b):
+    """A tool_use block's arguments as a dict, or {} when it is not one.
+
+    Cursor persists an IN-FLIGHT tool call with its arguments still a raw JSON
+    string prefix (`{"contents": "`), and one such record in a corpus was enough
+    to abort `coach --harness cursor` with an AttributeError. A partial call has
+    no arguments to read yet, so it reads as no arguments rather than as a crash."""
+    inp = b.get("input")
+    return inp if isinstance(inp, dict) else {}
+
+
 def _tool_uses(rec):
     if rec.get("type") != "assistant":
         return []
@@ -1004,26 +1191,32 @@ _CODEX_TOOL_TYPES = ("function_call", "custom_tool_call", "local_shell_call")
 def _codex_rows(path):
     """Normalise one Codex rollout .jsonl into ordered Claude-shaped rows that
     extract_episodes / _human_prompt / _tool_uses consume unchanged."""
-    rows = []
+    rows, sid, cwd = [], "", ""
     for d in _iter_json(path):
+        p = d.get("payload") or {}
+        if d.get("type") == "session_meta":
+            sid, cwd = p.get("id") or sid, p.get("cwd") or cwd
+            continue
         if d.get("type") != "response_item":
             continue
-        p = d.get("payload") or {}
+        # the envelope export-run reads; coach ignores it
+        meta = {"timestamp": d.get("timestamp") or "", "cwd": cwd, "sessionId": sid}
         pt = p.get("type")
         if pt == "message":
             role = p.get("role")
             if role == "user":
                 txt = _codex_user_text(p.get("content"))
                 if txt:
-                    rows.append({"type": "user", "promptSource": "typed",
-                                 "message": {"role": "user", "content": txt}})
+                    rows.append(dict(meta, type="user", promptSource="typed",
+                                     message={"role": "user", "content": txt}))
             elif role == "assistant":
                 txt = _codex_out_text(p.get("content"))
-                rows.append({"type": "assistant", "message": {"role": "assistant",
-                             "content": [{"type": "text", "text": txt}] if txt else []}})
+                rows.append(dict(meta, type="assistant", message={
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": txt}] if txt else []}))
         elif pt in _CODEX_TOOL_TYPES:
-            rows.append({"type": "assistant", "message": {"role": "assistant",
-                         "content": [_codex_tool_block(p)]}})
+            rows.append(dict(meta, type="assistant", message={
+                "role": "assistant", "content": [_codex_tool_block(p)]}))
     return rows
 
 
@@ -1056,7 +1249,7 @@ def _cursor_ts(text):
 
 
 def _cursor_cwd(path):
-    """~/.cursor/projects/Users-morkeeth-CODE-zup/... -> /Users/morkeeth/CODE/zup.
+    """~/.cursor/projects/Users-dev-CODE-proj/... -> /Users/dev/CODE/proj.
     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."""
@@ -1316,11 +1509,11 @@ def extract_episodes(rows, source="", pasted=None):
                 if name in _WRITE_TOOLS:
                     wrote = True
                     if not witness:
-                        inp = b.get("input") or {}
+                        inp = _tool_input(b)
                         tgt = inp.get("file_path") or inp.get("notebook_path") or "?"
                         witness = "%s %s" % (name, os.path.basename(tgt))
                 elif name == "Bash":
-                    cmd = (b.get("input") or {}).get("command", "") or ""
+                    cmd = _tool_input(b).get("command", "") or ""
                     if _COMMIT_RE.search(cmd):
                         committed, witness = True, "git commit"
                     elif _REVERT_RE.search(cmd):
@@ -1435,7 +1628,7 @@ def coach(roots=None, harness=None, verified_human=False):
     if not roots:
         roots = _coach_roots(None, harness)
     paths = _coach_files(roots, harness)
-    episodes, records, humans, pastes = [], 0, 0, 0
+    episodes, records, humans, pastes, corrections = [], 0, 0, 0, 0
     human_texts, harnesses = [], set()
     for p in paths:
         rows, fh = _rows_for_file(p)
@@ -1450,8 +1643,10 @@ def coach(roots=None, harness=None, verified_human=False):
         for row in rows:
             t = _human_prompt(row)
             if t and t not in pasted:
-                humans += 1
                 human_texts.append(t)
+        typed, corr = count_corrections(rows, pasted)   # same gate as the line above
+        humans += typed
+        corrections += corr
         episodes += extract_episodes(rows, source=p, pasted=pasted)
 
     patterns = rank_patterns(episodes)
@@ -1471,6 +1666,10 @@ def coach(roots=None, harness=None, verified_human=False):
         "history_lines": hist_lines, "history_matched": hist_matched,
         "files": len(paths), "total_records": records, "human_turns": humans,
         "human_pct": round(100 * humans / records, 2) if records else 0.0,
+        # correction rate = typed turns that correct the agent / typed turns.
+        # See is_correction() for the two rules; it is a lexical floor.
+        "corrections": corrections,
+        "correction_rate": round(corrections / humans, 3) if humans else 0.0,
         "episodes": len(episodes), "durable": durable,
         "durable_rate": round(durable / len(episodes), 3) if episodes else 0.0,
         "tiers": tiers,
@@ -1616,6 +1815,27 @@ def cmd_coach(args):
     t = r["tiers"]
     print("  \033[2mcommit %s  ·  write/edit %s  ·  reverted %s  ·  nothing durable %s\033[0m"
           % (t["commit"], t["artifact"], t["reverted"], t["none"]))
+    # correction rate: the inverse of a landed prompt. n travels with it because
+    # a percentage without its denominator is the number this tool distrusts.
+    #
+    # It used to say "a floor" and stop. That was true and useless — it named a
+    # direction without a size, so nobody could tell whether the real figure was
+    # 7% or 40%. Both were measured on 2026-09-03 (200 rows each, agent-labelled,
+    # one tuning sample and one held-out): v1 runs at precision 0.80 and recall
+    # 0.16, so the printed count is roughly a FIFTH of the real one, and the two
+    # samples put the true rate between 26% and 37%.
+    #
+    # The interval is printed rather than a point estimate because the two
+    # samples disagree by more than sampling error, and hiding that behind one
+    # confident number is the failure this tool exists to catch.
+    # Each version states ITS OWN measured recall. Printing one figure for both
+    # would attach v1's recall to v0's count — a true number about the wrong
+    # object, which is the exact error this tool was built to surface.
+    caught = {"v0": "~1 in 18", "v1": "~1 in 6"}.get(_CORRECTION_VERSION, "?")
+    print("  \033[2mcorrection rate: %s%% measured (%s of %s typed turns) · "
+          "%s catches %s, so the real rate is ~26-37%%\033[0m"
+          % (int(round(r["correction_rate"] * 100)), r["corrections"],
+             r["human_turns"], _CORRECTION_VERSION, caught))
     if r["verified_human"]:
         print("  \033[2m%s typed turn(s) flagged likely-PASTED and subtracted\033[0m"
               % r["pastes_flagged"])
@@ -1628,6 +1848,171 @@ def cmd_coach(args):
     print()
 
 
+# ============================================================================
+# export-run — one run's numbers as JSON, the contract Agent Grinder and ZUP read
+# ============================================================================
+# Reads the transcript file directly (no index needed), applies the same
+# authorship gate and the same correction classifier coach uses, and adds the
+# run envelope: when it started and ended, what the agent touched, and what got
+# committed in that window. Every key is documented in README.md > export-run.
+
+
+def _epoch(ts):
+    """ISO-8601 transcript stamp -> unix seconds, or None. Accepts the 'Z' Claude
+    Code and Codex write and the naive local stamp the Cursor connector yields."""
+    if not ts:
+        return None
+    s = ts.strip()
+    if s.endswith("Z"):
+        s = s[:-1] + "+00:00"
+    try:
+        d = datetime.fromisoformat(s)
+    except ValueError:
+        return None
+    if d.tzinfo is None:
+        d = d.astimezone()           # naive = local wall clock
+    return d.timestamp()
+
+
+def _iso(epoch):
+    return datetime.fromtimestamp(epoch, timezone.utc).isoformat(
+        timespec="seconds").replace("+00:00", "Z")
+
+
+def _git_dir(cwd):
+    """The .git directory governing `cwd` (walking up), resolving a `.git` FILE
+    (worktree / submodule) to the gitdir it points at. None if not in a repo."""
+    d = os.path.abspath(os.path.expanduser(cwd or ""))
+    while True:
+        g = os.path.join(d, ".git")
+        if os.path.isdir(g):
+            return g
+        if os.path.isfile(g):
+            try:
+                first = open(g).readline().strip()
+            except OSError:
+                return None
+            if first.startswith("gitdir:"):
+                target = first[len("gitdir:"):].strip()
+                return os.path.normpath(os.path.join(d, target))
+            return None
+        parent = os.path.dirname(d)
+        if parent == d:
+            return None
+        d = parent
+
+
+def _reflog_commits(cwd, start=None, end=None):
+    """Commits recorded in cwd's reflog (.git/logs/HEAD) stamped inside
+    [start, end] (unix seconds, either side open when None), as a list of
+    {sha, ts, subject}; None when cwd is not inside a git repo.
+
+    Read straight from the file, not from `git log`: the README's privacy claim
+    is that nothing here shells out, and this is the one place that would have
+    crept in. The reflog is the record of what THIS working tree did: a commit made
+    here lands in it, a commit pulled in from elsewhere does not, which is the
+    right side of the line for a run receipt. It is local and git expires it
+    (90 days by default), so a run older than that can read 0 here while
+    `git log` would still show its commits. `commit (amend)` counts as a
+    commit; a rebase's `pick` lines do not."""
+    g = _git_dir(cwd)
+    if not g:
+        return None
+    out = []
+    try:
+        f = open(os.path.join(g, "logs", "HEAD"), "r", errors="replace")
+    except OSError:
+        return out
+    with f:
+        for line in f:
+            head, _, msg = line.rstrip("\n").partition("\t")
+            parts = head.split()
+            if len(parts) < 4 or not msg.startswith("commit"):
+                continue
+            try:
+                stamp = int(parts[-2])
+            except ValueError:
+                continue
+            if (start is not None and stamp < start) or (end is not None and stamp > end):
+                continue
+            out.append({"sha": parts[1][:7], "ts": _iso(stamp),
+                        "subject": msg.partition(": ")[2]})
+    return out
+
+
+def _resolve_run(target, roots, harness):
+    """The transcript file `target` names: 'latest' (newest by mtime; a spawned
+    sub-agent's file is not a run of yours and is skipped), a session id or a
+    prefix of one, or a path to a .jsonl. None when nothing matches."""
+    if target != "latest" and os.path.isfile(target):
+        return target
+    paths = [p for p in _coach_files(roots, harness)
+             if os.sep + "subagents" + os.sep not in p
+             and os.path.basename(p) not in ("history.jsonl", "session_index.jsonl")]
+    if not paths:
+        return None
+    if target == "latest":
+        return max(paths, key=os.path.getmtime)
+    hits = [p for p in paths if os.path.basename(p).startswith(target)]
+    if not hits:                     # codex names rollouts rollout-<date>-<id>.jsonl
+        hits = [p for p in paths if target in os.path.basename(p)]
+    return max(hits, key=os.path.getmtime) if hits else None
+
+
+def export_run(path):
+    """The run-level numbers of one transcript file, as a JSON-ready dict."""
+    rows, harness = _rows_for_file(path)
+    sid = next((r.get("sessionId") for r in rows if r.get("sessionId")), "") \
+        or os.path.splitext(os.path.basename(path))[0]
+    cwd = next((r.get("cwd") for r in reversed(rows) if r.get("cwd")), "")
+    stamps = [e for e in (_epoch(r.get("timestamp")) for r in rows) if e is not None]
+    start, end = (min(stamps), max(stamps)) if stamps else (None, None)
+    typed, corrections = count_corrections(rows)
+    tool_calls, files = 0, set()
+    for r in rows:
+        for b in _tool_uses(r):
+            tool_calls += 1
+            if b.get("name") in FILE_TOOLS:
+                fp = _tool_input(b).get("file_path") or _tool_input(b).get("notebook_path")
+                if fp:
+                    files.add(fp)
+    commits = _reflog_commits(cwd, start, end) if cwd else None
+    return {
+        "schema": "transcripto.export-run/1",
+        "session_id": sid,
+        "project": cwd,
+        "harness": harness,
+        "transcript": path,
+        "started": _iso(start) if start is not None else None,
+        "ended": _iso(end) if end is not None else None,
+        "duration_s": int(round(end - start)) if stamps else None,
+        "records": len(rows),
+        "typed_turns": typed,
+        "corrections": corrections,
+        "correction_rate": round(corrections / typed, 3) if typed else None,
+        "tool_calls": tool_calls,
+        "files_touched": sorted(files),
+        "commits_in_window": len(commits) if commits is not None else None,
+        "commits": commits,
+        "proxy": ("typed_turns is the authorship gate (typed/queued, never meta, "
+                  "sidechain or tool output); correction_rate is a lexical floor; "
+                  "commits_in_window is this tree's reflog inside the run window, "
+                  "null when the project is not a git repo."),
+    }
+
+
+def cmd_export_run(args):
+    roots = _coach_roots(args.root, args.harness)
+    path = _resolve_run(args.target, roots, args.harness)
+    if not path:
+        sys.stderr.write("\n  no transcript matches '%s'.\n" % args.target)
+        sys.stderr.write("  looked in: %s\n" % ", ".join(roots))
+        sys.stderr.write("  pass a session id (or a prefix of one), 'latest', or a path "
+                         "to a .jsonl; --root / --harness as for coach.\n\n")
+        sys.exit(2)
+    print(json.dumps(export_run(path), indent=2))
+
+
 def main():
     p = argparse.ArgumentParser(prog=PROG, description=__doc__ + USAGE,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
@@ -1660,6 +2045,13 @@ def main():
                         "in the same session, from the human signal before grading")
     s.add_argument("--json", action="store_true", help="machine-readable, for other tools")
     s.set_defaults(fn=cmd_coach)
+    s = sub.add_parser("export-run")
+    s.add_argument("target", help="a session id (or a prefix of one), 'latest', or a "
+                                  "path to a .jsonl transcript")
+    s.add_argument("--root", help="look in this transcript dir instead of ~/.claude/projects")
+    s.add_argument("--harness", choices=["claude", "codex", "cursor"],
+                   help="which agent's transcripts to look in. default: claude")
+    s.set_defaults(fn=cmd_export_run)
     a = p.parse_args()
     if not getattr(a, "fn", None):
         p.print_help(); return