copyrun 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,14 @@
 # copyrun
 
-Receipts for AI-written code.
+A copy of you that runs your agents. Copy. Run.
 
-copyrun turns a coding-agent session (Claude Code, Codex, Cursor) into a run page that shows what the agent actually did: the prompts, the commands it ran, the files it changed and whether the tests passed. Attach it to a pull request so reviewers can check the work, or find a run that solved your problem and reuse it.
+Every time you allow or stop a step an agent wants to take, copyrun records the decision and your reason, on your machine. `npx copyrun copy` is the version of your judgment built from that record: it answers your agents the way you would where its own score proves it (repeating your refusals, never allowing migrations, auth, secrets, CI, dependencies or deletes alone), turns what you decide again and again into rules every agent reads (`copy rules --write`), and exports as one signed file you can take to your next job. `copy skills` counts how you solve problems with agents from the sessions on this machine (framing, decomposition, verification, recovery), and `copy compare @someone/slice` replays someone's published rules over your own decisions, or your team's.
+
+`npx copyrun on` puts every agent acting as you on one screen at copyrun.ai/mission, whoever made it: which agent, in which project, what it's doing this second, which one is waiting for you, and a Stop. Claude Code, Codex and Cursor report through their hooks; Gemini CLI, OpenCode, OpenClaw, Aider, Goose, Amp and Copilot CLI are seen by their process; anything else reports with `npx copyrun beat`. The hooks send the agent, the folder name and the kind of step, never a path, a prompt, code or output.
+
+When an agent reaches a step it shouldn't take alone (a migration, a change to auth, secrets or CI, a new dependency, a delete), `npx copyrun setup --ask` pauses it until you Allow or Stop from any browser, and no answer in time means Stop.
+
+The CLI also turns a coding-agent session (Claude Code, Codex, Cursor) into a signed record that shows what the agent actually did: the prompts, the commands it ran, the files it changed and whether the tests passed. Attach it to a pull request as the receipt so reviewers can check the work, and let your agent reuse what worked for you last time.
 
 ## Install
 
@@ -21,9 +27,14 @@ npm install -g copyrun
 ## Usage
 
 ```sh
+copyrun on                  # every agent acting as you on one screen (copyrun.ai/mission); copyrun off; copyrun watch; copyrun beat
+copyrun                     # the debrief: what your agent actually did in the last session here (claims vs test runs, where to look)
+copyrun why <file>:<line>   # which prompt wrote this line: git blame for agent code
+copyrun week                # your agents this week, from the sessions on this machine
 copyrun share               # share the latest session from this project
 copyrun pr                  # add it to this branch's pull request
 copyrun check               # check the agent's claims against what it ran
+copyrun resume --with codex # another agent picks up where the last session stopped
 copyrun search "<task>"     # find runs that did a similar task
 copyrun clone <id|url>      # install a run's recipe as a skill in this project
 copyrun worked <id|url>     # report that a cloned run worked (or: copyrun failed)
@@ -55,10 +66,22 @@ You choose who can see the run:
 
 Maintainers can install the [copyrun GitHub App](https://copyrun.ai/docs/github-app) to add a check to pull requests.
 
+### What did my agent actually do?
+
+`copyrun` with no arguments, inside a project an agent worked in, reads the last session on this machine and prints one screen: what you asked, what the agent said, its closing claims against the session's own test, build and lint runs, where to look before you ship (files changed after the last test, tests removed, sensitive changes), the files it changed, the files no prompt names, the times you corrected it, and the tokens it used. Nothing is uploaded and no account is needed. `copyrun last <session>` does the same for any session; the exit code is 2 when a claim is contradicted.
+
+`copyrun why <file>:<line>` is git blame for agent code: the session step that wrote the line, the prompt before it and what the agent said just before, from the sessions that ran in this repository. `copyrun why <file>` lists every stretch a session wrote. A line edited by hand since matches nothing, so "no session wrote this line" is a floor.
+
+`copyrun week` is your agents this week: sessions per agent, how often one said "tests pass" when the last run failed, changes that never ran a test, your corrections and tokens, against the week before. Counts only, nothing uploaded.
+
 ### Checking claims
 
 `copyrun check` reads the latest session and flags claims that don't match what happened, such as "all tests pass" when the last test run failed. It runs entirely locally and needs no account. Add `--strict` to exit with a non-zero code for use in CI or git hooks.
 
+### Handing a session to another agent
+
+`copyrun resume --with <claude|codex|cursor>` takes the latest session in this folder (or a session id, or a run you can open) and starts the other agent with a handoff: your request, your corrections as rules, the files changed, the last checks, where it stopped and where to look. It's quoted as data and redacted like a share, the agent shows a plan before changing files, and nothing is uploaded. `--print` prints the handoff instead. Very long sessions are read from their start and their last 24 MB.
+
 ### Signing in
 
 ```sh