@method-ai-hq/sdk 0.19.0 → 0.20.0

package/dist/packages/sdk/src/method-help.js

@@ -13,7 +13,7 @@ export const commandHelp = {
     "new-id": { usage: "method new-id FILE", purpose: "Make a copied Method file a new Method.", arguments: "Writes a new id: line. A copy that keeps its id: saves to the same Method.", result: "JSON with file and method_id.", errors: "Missing file.", example: "method new-id copy.method" },
     bind: { usage: "method bind FILE_OR_ID NAME (--file FOLDER | --connection URL) [--upload]", purpose: "Save a named input location or connection.", arguments: "Default: this computer only, in ~/.config/method/computer.json under the Method's ID (a FILE gets its id: line). A folder named NAME beside the Method needs no binding. --upload saves only the selected input folder or connection URL in the account. It never scans your disk. Keep credentials in the service's normal sign-in store.", result: "Saved binding and scope.", errors: "Missing input, invalid name, or unsafe path.", example: "method bind METHOD_ID prepared_day --file day-records --upload", remote: true },
     state: { usage: "method state ID [--enable --file state.json | --release RUN_ID]", purpose: "Read or explicitly enable shared account state.", arguments: "Accepted state updates use revision checks. Inspect a stopped run's external actions before releasing its ownership.", result: "Current revision, value, and owner run.", errors: "Concurrent ownership or stale revision. Existing state is never silently overwritten.", example: "method state METHOD_ID --enable --file initial-state.json", remote: true },
-    wait: { usage: "method wait RUN_DIRECTORY", purpose: "Reconnect to the same local worker.", arguments: "Use the directory returned by run. Closing this output connection leaves the worker active.", result: "Live output, then a final line with the run status (succeeded, unconfirmed, waiting_for_you, or failed), the headline of a failure, and the dashboard link of a synced run.", errors: "Stopped process or missing run.", example: "method wait .runs/example" },
+    wait: { usage: "method wait RUN_DIRECTORY\nmethod wait [JUDGMENT_ID] [--timeout SECONDS] [--json]", purpose: "Reconnect to a local run, or get what a fix did with a correction.", arguments: "With a run directory: reconnects to the same local worker; closing this output connection leaves the worker active. With a judgment ID (from method judge --json), or with nothing: waits for the fix of that correction, or of every correction that this computer is fixing, for up to --timeout seconds (default 100), and prints what it did. A wait that ends first says so in one line; the fix goes on, and method wait can run again.", result: "For a run: live output, then a final line with the run status (succeeded, unconfirmed, waiting_for_you, or failed), the headline of a failure, and the dashboard link of a synced run. For a fix: one plain line per correction for the person (Fixed, No fix found yet, Could not test a fix safely, a question, ...). After a fix it shows what the fixed agent gives now, from the test; nothing was sent. After a question, one more line says how to send the person's answer. --json prints {outcomes: [{judgment, status, outcome, lines, next?}]}.", errors: "Stopped process or missing run, or a judgment that this computer is not fixing.", example: "method wait .runs/example\nmethod wait\nmethod wait jdg_6f1c…" },
     'run-status': { usage: "method run-status RUN_DIRECTORY", purpose: "Read worker status without waiting.", arguments: "Local run directory.", result: "Worker status and whether its process is active.", errors: "Unreadable run directory.", example: "method run-status .runs/example" },
     cancel: { usage: "method cancel RUN_DIRECTORY", purpose: "Stop a local run process.", arguments: "Inspect uncertain external actions before any explicit retry.", result: "Cancellation request. The checkpoint remains available.", errors: "Unreadable run directory.", example: "method cancel .runs/example" },
     progress: { usage: "method progress --message TEXT [--completed N --total N --unit NAME] [--child NAME]\nmethod progress --codex --child NAME", purpose: "Report public progress from a running script or relay a child Codex JSON stream.", arguments: "METHOD_PROGRESS_FD is supplied by the executor. --codex reads JSON lines from stdin; --message sends one message. Do not include secrets or source contents.", result: "Writes to the separate progress pipe. No stdout output. No-op outside a Method process.", errors: "Invalid arguments. Malformed Codex events are ignored.", example: "method progress --message 'Rendered 12 of 40 pages' --completed 12 --total 40 --unit pages" },
@@ -36,11 +36,13 @@ export const commandHelp = {
     get: { usage: "method get WORKFLOW_ID [--version VERSION_ID] [--out FILE] [--server URL]", purpose: "Read an online method; optionally make a local draft for editing.", arguments: "Default: latest version. --out must name a new file. Use a version ID to read an exact saved version.", result: "Without --out: {workflow_id,version_id,version_number,workflow}. With --out: {workflow_id,version_id,version_number,file}; writes the workflow with its id: line and the saved files.", errors: "Missing method or version; output file already exists.", example: "method get wf_example --out edit.method", remote: true },
     explain: { usage: "method explain FILE [--step ID] [--no-round-trip] [--server URL]", purpose: "Explain each script step of the saved version in a script card.", arguments: "FILE is a local Method whose current content is a saved version (run or publish it while signed in). For each run step whose script has no card, code analysis finds the hosts, secrets, environment variables, files, and commands the script uses; a hosted model writes a one-sentence summary and 3 to 8 steps; every number, quoted name, and host in that text must appear in the code (one retry). The round trip writes a program from the steps alone and replays up to 3 recorded inputs of the step from local runs through both programs without network access. A script that calls the network is not replayed. --step explains one step. --no-round-trip skips the replay. A signed-in run starts this in the background; publish waits for it.", result: "One line per step with its summary and check results. Cards upload to the version; the dashboard shows them beside each script. A failed check is shown on the card and never blocks publish.", errors: "No saved version, local files that differ from the saved version, or no hosted-model credit. Without sign-in it prints one line and makes no card.", example: "method explain leads.method --step score", remote: true },
     publish: { usage: "method publish FILE [--reason TEXT] [--accept-failing-case ID[,ID]] [--cloud|--workers] [--env NAME] [--server URL]", purpose: "Mark a version as published, for sharing, schedules, and production runs.", arguments: "Runs the Method's cases first; a version that breaks an approved case is refused unless --accept-failing-case names it, and the version records that. Uses the version of the file's current content: it finishes that upload (no time limit while bytes move), checks the cases, then marks it published with the reason (default: Published.). --accept-failing-case needs --reason. The first save of a new file creates the Method. --cloud runs the production runs of the environment on Method Cloud; --workers runs them on your workers again. --env NAME selects the environment (default production).", result: "JSON with workflow_id, version_id, url, published_at, the cases line, and the open warnings and notes (issues). With --cloud or --workers: placement. Warnings and notes never block a publish.", errors: "An error issue (nothing is published), failing case, --accept-failing-case without --reason, or no network.", example: "method publish task.method --reason 'Shorter introduction'", remote: true },
-    judge: { usage: "method judge RUN_ID right|wrong [--step STEP_ID] [--note TEXT] [--corrected FILE] [--json] [--server URL]\nmethod judge RUN_ID keep JUDGMENT_ID", purpose: "Record the person's reaction to a run's result. A wrong one fixes the Method on this computer.", arguments: "RUN_ID is the run_id of the run's start line, or the run ID on the dashboard. right: the person used or approved the result; it is recorded only. wrong: the person corrected it, or asked to change the Method because of it. --note: the person's words (at most 4000 characters), even when they are vague. --corrected FILE: the result that the person says is right; JSON is sent as JSON, other text as text (at most 1 MB). --step: the step whose output was wrong. A wrong judgment then fixes the Method in the foreground, with your own Claude Code or Codex (hosted models only when neither is signed in): it records the correction as a case in cases/ next to the Method file, finds the step that causes it, tests up to three small changes against this run, every earlier corrected or approved run, and every case, and changes the file only when a change fixes this run and breaks no earlier correction. The change is saved as a new version; restoring the version before it on the Method page undoes it. It takes a few minutes. Corrections that wait (from the dashboard, or a fix that stopped) are fixed in the same loop. The fix starts from the newest version of the Method, as method run does. A correction of a step that someone changed after the run is not fixed, and the line names who changed it. A change that fixes one person's correction only by breaking another person's case is held, not applied, and the line names both. Two people who judge the same step of a run in opposite ways are held too: the output shows both, and method judge RUN_ID keep JUDGMENT_ID keeps one and sets the other aside. For a run whose content stays on this computer (run_data: device), the account gets only the verdict and the step; the note and the corrected result go in .method/judgments.jsonl next to the Method file. Run it in the folder of the Method file when the run came from an older CLI. Do not ask the person to confirm a judgment, and do not edit the Method yourself for the same correction.", result: "One line: what changed and how many earlier corrections it passes, with how to undo it; or No safe change found and the reason. A subscription limit or another failure of the model service is an error, and the correction waits for the next method judge or method run. --json prints the judgment and the fix (kind change or none, cause, steps, cases made, version, usage with null dollars on a subscription, what the replay caps left out, and the log file).", errors: "An unknown run, a run of a Method that is not in your account, no sign-in, or a failure of the model service.", example: "method judge 6f1c… wrong --note \"it's not even redlined\"", remote: true },
+    judge: { usage: "method judge RUN_ID right|wrong [--step STEP_ID] [--note TEXT] [--corrected FILE] [--json] [--server URL]\nmethod judge RUN_ID keep JUDGMENT_ID", purpose: "Record the person's reaction to a run's result. A wrong one starts a fix on this computer and returns at once.", arguments: "RUN_ID is the run_id of the run's start line, or the run ID on the dashboard. right: the person used or approved the result; it is recorded only. wrong: the person corrected it, or asked to change the Method because of it. --note: the person's words (at most 4000 characters), even when they are vague. --corrected FILE: the result that the person says is right; JSON is sent as JSON, other text as text (at most 1 MB). --step: the step whose output was wrong. A wrong judgment starts the fix in its own process, with your own Claude Code or Codex (hosted models only when neither is signed in), and prints one line at once. The fix records the correction as a case in cases/ next to the Method file, judged on what the person saw (the result, the files the run wrote, the messages it sent), and tests changes on a private copy of the run, with every message or change held back. It applies a change only when the change fixes this run reliably and breaks no earlier correction, or adds the note as a learned rule when it cannot test one safely. method wait prints what it did, and so does the next method run of the Method. method undo restores the Method as it was before. The fix starts from the newest version of the Method, as method run does. Two people who judge the same step of a run in opposite ways are held: the output shows both, and method judge RUN_ID keep JUDGMENT_ID keeps one and sets the other aside. For a run whose content stays on this computer (run_data: device), the account gets only the verdict and the step; the note and the corrected result go in .method/judgments.jsonl next to the Method file. Do not ask the person to confirm a judgment, and do not edit the Method yourself for the same correction.", result: "One line: Working on it. --json prints the judgment and {fix: {status: working, wait}}; method wait JUDGMENT_ID gives the outcome.", errors: "An unknown run, a run of a Method that is not in your account, or no sign-in.", example: "method judge 6f1c… wrong --note \"it's not even redlined\"\nmethod wait", remote: true },
+    learned: { usage: "method learned FILE [--remove NUMBER] [--json]", purpose: "List the rules that the agent learned from corrections, or remove one.", arguments: "The rules are in learned.json beside the Method file; a step uses a rule when its condition holds. Each line says the rule in plain words, who taught it, when, and how often it applied in this computer's runs. --remove NUMBER (from the list, or the rule's id from --json) retires one rule and saves a new version; method undo brings it back.", result: "One line per rule, or the rule that was removed. --json prints {rules: [{id, step, when, then, by, created, applied, text}]}.", errors: "No such rule, or a learned.json that is not valid.", example: "method learned nda.method\nmethod learned nda.method --remove 2", remote: true },
+    undo: { usage: "method undo [FILE] [--json]", purpose: "Undo Method's last change to a Method: a fix, a pruning change, or a removed learned rule.", arguments: "FILE defaults to the only Method file in this folder, else the Method of the last change on this computer. Restores the Method file and the files the change wrote, and saves that as a new version. A file that changed after Method's change is not overwritten. Run it again to undo the change before.", result: "One line: what is undone.", errors: "Nothing to undo, or the file changed after the change.", example: "method undo", remote: true },
     changes: { usage: "method changes FILE [--json] [--server URL]", purpose: "List the changes that Method applied to a Method.", arguments: "Lists, newest first, the changes that method judge applied on this computer and the changes that Method made in the account. A change made in the account is a new version: the next method run of the file takes it.", result: "One line per change: its date, its version, and its cause. --json prints {file, method_id, changes: [{id, source, cause, date, version_id, steps}]}. No changes.", errors: "No id: line and no change made on this computer.", example: "method changes task.method", remote: true },
     secret: { usage: "method secret find [FILE]\nmethod secret import FILE NAME...\nmethod secret set NAME\nmethod secret list [NAME...]", purpose: "Give this computer the values of a Method's declared secrets.", arguments: "find lists the KEY=VALUE files in this folder (3 levels down) and in the parent folder (2 levels down) with the key names in each, never values; for the Method FILE (or the only Method here) it says which declared secrets each file holds and prints the import command. import copies the named values from a KEY=VALUE file that the user names, without printing them. set opens a private form on 127.0.0.1 in the browser for one value. list shows names and where each value is found (shell, this computer, or missing), never values. Values are kept in ~/.config/method/secrets.json (mode 0600) and are never sent to Method. A value exported in the shell is used first. Every script of the Method receives all of its declared secrets.", result: "JSON with the saved names, or the list.", errors: "A name is missing from the file, or no value was entered.", example: "method secret find\nmethod secret import ../service/.env ARCHIVE_TOKEN" },
     connect: { usage: "method connect [APP_FOLDER] [--file METHOD_FILE]", purpose: "Connect an app to the Method in this folder, so the app runs it in production.", arguments: "Run it in the Method's folder. APP_FOLDER (default: this folder) is the app's folder. It makes a service key named after the app folder and writes METHOD_API_KEY to the app's .env (a new file, or a new or replaced line); it never prints the key. It adds .env to .gitignore in a git repository. When the Method has no published version, it publishes the current file. It detects Node (package.json) or Python (pyproject.toml, requirements.txt), and prints the install line and the code to add. Run it again: an app with a working key keeps it.", result: "JSON with the method_id, the published version, where the key is, install, code, secrets_to_set_on_the_host, and next.", errors: "No or several .method files (give --file), an app folder with no language marker, or a failing case at publish.", example: "method connect ../app", remote: true },
-    answer: { usage: "method answer RUN_ID [--answer JSON]", purpose: "Show or answer the question of a production run that waits on an ask step.", arguments: "Without --answer it prints the question and its form (the fields of the answer). With --answer it checks the answer against the form and sends it; the run continues. A run that keeps its content on devices has a sealed question: run this where the app's METHOD_API_KEY is (the environment, or the .env of this folder), or on the laptop that started the run with its sign-in. Local runs (method run FILE) take answers with --human FILE as before.", result: "The question and form, or the run after the answer.", errors: "The run is not waiting, the answer does not match the form, or the key cannot open a sealed question (wrong_key).", example: "method answer 6f1c… --answer '{\"approved\":true}'", remote: true },
+    answer: { usage: "method answer RUN_ID [--answer JSON]\nmethod answer JUDGMENT_ID \"THE PERSON'S WORDS\"", purpose: "Answer the question of a production run that waits on an ask step, or the question that a fix asked about a correction.", arguments: "With a run ID: without --answer it prints the question and its form (the fields of the answer); with --answer it checks the answer against the form and sends it, and the run continues. A run that keeps its content on devices has a sealed question: run this where the app's METHOD_API_KEY is (the environment, or the .env of this folder), or on the laptop that started the run with its sign-in. Local runs (method run FILE) take answers with --human FILE as before. With a judgment ID: send the person's own words, word for word, and the fix starts again with them in its own process; method wait gives what it did. Never answer a fix's question yourself. For a Method whose run content stays on this computer, the answer stays next to the Method file.", result: "The question and form, or the run after the answer; for a fix, one line.", errors: "The run is not waiting, the answer does not match the form, the key cannot open a sealed question (wrong_key), or the correction has no open question.", example: "method answer 6f1c… --answer '{\"approved\":true}'\nmethod answer jdg_6f1c… \"Every counterparty NDA must come back redlined.\"", remote: true },
     worker: { usage: "method worker [--method ID]... [--concurrency N] [--server URL]", purpose: "Run production runs that an app started with the runs API.", arguments: "Uses METHOD_API_KEY, or the sign-in of this computer. Use the app's key: runs that keep content on devices open only with the key that started them. The worker claims queued runs of the organization (or only of each --method), renews each run's lease, downloads the run's saved version by ID, prepares its dependencies once per version, reads declared secrets from the environment, and sends the run records to the dashboard. An ask step makes the run wait: the worker saves the run folder, reports the question, and lets go of the run; after the answer, a worker continues it and reuses the finished steps. --concurrency runs that many at the same time (default 1). Ctrl+C stops after the current runs; a second Ctrl+C stops them and queues them again. The libraries start a worker in the app's process with method.run(), so this command is for separate worker processes.", result: "One JSON line for each finished run: {run_id, method_id, version_id, status, run_data, result?, error?, run_dir}, and one for each run that starts to wait: {run_id, status: waiting, question}. A run_data: device result is printed only here.", errors: "Missing or revoked key. A run whose lease expires goes back to the queue and runs again (at most 3 attempts).", example: "METHOD_API_KEY=mk_live_... method worker --method wf_example", remote: true },
     keys: { usage: "method keys create --name NAME\nmethod keys list\nmethod keys revoke KEY_ID", purpose: "Manage the organization's service keys for production runs.", arguments: "A service key (mk_live_...) lets an app start runs and lets a worker run them. method connect makes one for an app and writes it to the app's .env. Keep the key in the app's secret store as METHOD_API_KEY; never put it in a Method or in chat.", result: "create prints the key and its webhook_secret once; the server keeps only a hash of the key. list shows names, prefixes, and last use, never keys.", errors: "Requires a person's sign-in (method login), not a service key.", example: "method keys create --name 'Cuties backend'", remote: true },
     status: { usage: "method status [--server URL]", purpose: "Check installation and sign-in without listing Methods or starting login.", arguments: "No required arguments. Checks the selected server with the current credential when one exists.", result: "JSON {installed:true,server,signed_in}. A missing or expired credential returns signed_in:false. Does not print account details.", errors: "Network and server errors exit 1; they are not reported as signed out.", example: "method status", remote: true },
@@ -66,13 +68,13 @@ export const commandHelp = {
 --verbose: print runtime events.
 NAME: the name of a Method in your workspace (not case-sensitive), run as method run ID runs it: the newest version. When several Methods have the name, the run does not start; the result lists their names and IDs (exit 2).
 Before a signed-in run of a FILE, the file takes the newest version of its Method. When a teammate saved a newer version, an unchanged file takes it, and a changed file combines it step by step and file by file; one line on stderr says whose version it took and which of your changes are kept. When you and a teammate changed the same step or the same script file, nothing runs and no file changes: the result has status needs_you and both texts of each part (exit 2). Combine them in the file, then run again. Offline, the file runs as it is, with one line. --resume does not change the file.
-Then corrections of the Method that wait (from the dashboard, or a fix that stopped) are fixed first, as method judge fixes them, with one line on stderr.
+First, the outcomes of fixes of this Method that nobody has seen yet are printed, one line each. Then corrections of the Method that wait (from the dashboard, an answer, or a fix that stopped) start a fix in the background, as method judge does, with one line on stderr; the run does not wait for it. After a run that completed, its output is checked in the background against the corrections that fixes of the last 30 days answered; nothing runs again, and a problem that comes back twice is reported on the next run.
 When the same run (the same version and the same inputs) is already going in your workspace, one line says who started it and links to it; this run starts too. To find it, each run record has a sha256 of its inputs; a run whose content stays on devices (run_data: device) sends none, because a hash of short inputs can show them.
 A Method that uses shared state (method state) waits while another person's run holds the state, with one line, and starts when it is free. A run that stopped while it held the state stops this run, and the line names the person who must check it.
 A Method whose declared secrets are not on this computer stops before the first step with the list of missing keys, each with its method secret set command. A step that stops because a file is not on this computer names the file and who saved this version.
 Use method doctor to check the installed Node and configured tools.`, result: "When signed in, the start line and the final result have dashboard: the link to the run's page; give it to the user when the run starts. Progress, then the final result as JSON on stdout; a run that stopped has failure (owner, headline, step, next), and a failed run also prints Failed, Whose problem, and Next lines on stderr. Local result.json and run evidence. The runtime executes the method's declared scripts, calls, agents, and checks. Executes trusted local processes; changes declarations do not enforce permissions. Runs exit 0 on completion, 1 on failure, 2 when human input is needed, and 3 when an observer could not confirm an external change (unconfirmed).", errors: "Missing inputs/access, failed check, timeout, unsafe resume/version mismatch, upload failure. See recovery. Never retry a business write without inspecting its saved changes.", example: "method run wf_example --version v_example --inputs inputs.json", remote: true },
     observe: { usage: "method observe [RUN_DIRECTORY...] [--pending ROOT]...", purpose: "Make the effect observations that are due for finished runs.", arguments: "Without directories, checks runs with open effects under .method-runs and the Method cache. Runs only observers and judges; never repeats an action. Schedule it, for example hourly, so late evidence such as a bounce reaches the run.", result: "JSON with each run's new verdicts, status, and next observation time. A synced run whose status changed is uploaded again.", errors: "Locked run, changed bundle, or a missing observer credential.", example: "method observe --pending .method-runs" },
-    test: { usage: "method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--cases DIR]", purpose: "Replay recorded cases against this version of a Method. Every case must pass.", arguments: "Cases are in cases/ beside the Method. Unchanged steps return their recorded outputs; changed steps run; files connections are scratch folders, so a changed step that writes files runs safely. A changed step that asks a person or acts on a service makes the case unverifiable. --baseline also runs each case on the old version, to show what the change fixed or broke.", result: "JSON report with a verdict per case and passed:true when no case blocks the change. Exit 0 or 1.", errors: "Unknown case, invalid Method, or setup errors.", example: "method test task.method --baseline task-before.method --new bounce-reported" },
+    test: { usage: "method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--cases DIR] [--once | --runs N [--min-pass N]] [--live STEP]... [--no-judge-cache] [--keep-dir DIR]", purpose: "Replay recorded cases against this version of a Method. Every case must pass.", arguments: "Cases are in cases/ beside the Method. Unchanged steps return their recorded outputs; changed steps run; each attempt works on its own copy of the files the recorded run read, so a changed step that writes files runs safely; a Method tool that sends or changes something returns a stand-in instead. --baseline also runs each case on the old version, to show what the change fixed or broke. --once runs each case once; --runs N and --min-pass N replace each case's own counts. --live STEP runs that step live even when it matches the recording. --no-judge-cache judges again instead of reusing earlier judgments. --keep-dir keeps each attempt's run folder there.", result: "JSON report with a verdict per case and passed:true when no case blocks the change. Exit 0 or 1.", errors: "Unknown case or step, invalid Method, or setup errors.", example: "method test task.method --baseline task-before.method --new bounce-reported" },
     case: { usage: "method case new|retire|list FILE ...", purpose: "Keep a correction as a recorded case that every later version must pass.", arguments: "Use method help case new, method help case retire, or method help case list.", result: "See the subcommand.", errors: "Unknown action. Choose new, retire, or list.", example: "method help case new" },
     "case new": { usage: "method case new FILE --id ID --note TEXT (--run BAD_RUN | --passing-run GOOD_RUN | both) (--rubric SENTENCE... | --expect FILE) [--ref outputs.NAME] [--context REF]... [--accept-conflict TEXT]", purpose: "Turn a correction into a recorded case.", arguments: "--run is the run that went wrong; the case must fail on it. --passing-run is the run the person accepted after the fix; the case must pass on it. With only --passing-run, the case pins behaviour that is already right. --rubric is a plain sentence that must be true of the output (repeatable); a model judges it with quotes. --ref selects the output to judge; the default is the Method's result. --context REF gives the judge other values to check against, such as the sources or the person's words (outputs.NAME or inputs.NAME); they are read, not judged. --expect FILE gives exact checks instead: {kind: equals, ref: outputs.NAME, value}, {kind: status, in: [STATUS]}, {kind: effect, effect: STEP/ITERATION/NAME, verdict: [VERDICT]}, or {kind: predicate, runtime: node, entrypoint: check.mjs}. --redact FILE maps recorded text to replacements. --accept-conflict TEXT keeps a case that conflicts with an instruction of the Method, with the person's answer.", result: "The saved case, with its result on each run. Its author is the signed-in person, so a refusal and the run notice name whose case it is. A case that the bad run already meets is refused: it does not capture the problem, or the note does not match the run. A case that can pass only by breaking an instruction of the Method's model steps is refused (case_conflicts): the error names the rule and the instruction.", errors: "A case that does not fail on the bad run, or does not pass on the passing run; a case that conflicts with an instruction; an existing ID; an unreadable run.", example: "method case new report.method --id sources-named --run .method-runs/bad --passing-run .method-runs/fixed --note 'Say which source backs each point.' --rubric 'Every point names the source file that supports it.'" },
     "case retire": { usage: "method case retire FILE ID --reason TEXT [--by NEW_ID]", purpose: "Retire a case whose rule no longer applies.", arguments: "The case stays on disk with its reason and is no longer run. Use it when a policy changed, not to make a failing change pass.", result: "JSON {retired}.", errors: "Unknown or already retired case.", example: "method case retire task.method old-terms --by new-terms --reason 'Payment terms changed on 1 October.'" },
@@ -303,12 +305,14 @@ const recipes = `# Recipes
 ## Corrections become cases
 
 When the user says a result was wrong:
-1. Record it: method judge RUN_ID wrong --note "the user's words" (--corrected FILE when they gave the right result). Use their words even when they are vague. Do not ask them to confirm it, and do not edit the Method for the same correction: method judge records the correction as a case, finds a change with the user's own agent, and applies it only when it fixes the run and breaks no earlier correction. It takes a few minutes.
-2. Tell the user the line it prints in plain words, then run the Method again and show the new result.
-3. When it prints No safe change found, tell the user the reason. If the user's words do not say what the right result is, ask before you change anything. Name the readings that the run and the Method's instructions allow, and what each one would change, in one question. A complaint about a missing part of the output can mean "produce it from what the inputs give", "mark what is missing", or "ask for it"; a complaint about wrong content can mean a wrong source, a wrong rule, or a wrong reading of the input. Do not choose a reading yourself, and never one that breaks the user's instructions. Then record the user's answer with method judge RUN_ID wrong --note "their answer".
-4. For a rule the user states outside a run, record it: method case new FILE --id ID --run BAD_RUN --passing-run GOOD_RUN --note "the user's words" --rubric "plain sentence that must be true" (repeat --rubric for each rule). --ref names the output to judge (default: the Method's result; a path to a file that the run saved is judged by that file's contents). When a rule compares the output with the sources, add --context with the step output that holds them, for example --context outputs.material. Make each sentence fail on the bad run; case new warns about one that does not. For an exact value, use --expect instead.
-5. case new refuses a case that can pass only by breaking one of the Method's instructions (case_conflicts), for example a rule that needs a fact that the inputs do not give when an instruction says not to invent facts, or a rule that requires what an instruction forbids. Show the user the rule and the instruction, and ask which one is right. When the user says the case is right, change the instruction first and record the case again. Add --accept-conflict "the user's answer" only when the user wants both.
-6. After any edit by hand, run method test FILE. Every case must pass. method publish refuses a version that breaks a case.
+1. Record it: method judge RUN_ID wrong --note "the user's words" (--corrected FILE when they gave the right result). Use their words even when they are vague. Do not ask them to confirm it, and do not edit the Method for the same correction. method judge returns at once with one line and tests a fix in the background, on a private copy of the run, with every message held back.
+2. Get the result with method wait. It waits up to 100 seconds; when it says it is still working, run it again. Tell the user the line it prints, in their words.
+3. After a fix, show the user what the fixed agent gives now: method wait prints the output from the test. Do not run the Method again to show it, above all when it sends or changes things: that would send it again.
+4. When method wait prints a question, show it to the user word for word and never answer it yourself. Send their own words with the command it prints: method answer JUDGMENT_ID "their words". Then run method wait again.
+5. When the user wants to see or remove what the agent learned from corrections, run method learned FILE, and method learned FILE --remove NUMBER. To go back to how the agent worked before Method's last change, run method undo.
+6. For a rule the user states outside a run, record it: method case new FILE --id ID --run BAD_RUN --passing-run GOOD_RUN --note "the user's words" --rubric "plain sentence that must be true" (repeat --rubric for each rule). --ref names what to judge (default: the Method's result; result, outputs.NAME, file:PATH for a file the run wrote, or effect:NAME for what a tool or effect sent). When a rule compares the output with the sources, add --context with the step output that holds them, for example --context outputs.material. Make each sentence fail on the bad run; case new warns about one that does not. For an exact value, use --expect instead.
+7. case new refuses a case that can pass only by breaking one of the Method's instructions (case_conflicts). Show the user the rule and the instruction, and ask which one is right. When the user says the case is right, change the instruction first and record the case again. Add --accept-conflict "the user's answer" only when the user wants both.
+8. After any edit by hand, run method test FILE. Every case must pass. method publish refuses a version that breaks a case.
 For a one-time preference, edit and run again; a case is not needed.
 
 ## Checked on every run, or on every new version
@@ -376,7 +380,7 @@ Learn: method authoring                 Start the installed guide.
 Local drafts: init, show, set, remove, step add/update/remove/move,
               check set/remove, validate, diff.
 Online documents: list, get, steps, step, publish, explain.
-Results and improvements: judge, changes.
+Results and improvements: judge, wait, answer, learned, undo, changes.
 Keys for scripts: secret find, secret import, secret set, secret list.
 Execution and evidence: run, run-status, wait, cancel, runs, logs, sync, observe.
 Effects and corrections: effect add/list, case new/retire/list, test.

package/dist/packages/sdk/src/method.js

@@ -99,8 +99,8 @@ async function sameRunLine(client, methodId, versionId, flags, device) {
         process.stderr.write(line + '\n');
 }
 /**
- * Before method run FILE in the parent process: the file takes the newest version of its Method, corrections that wait
- * are fixed, and the same-run line is printed. Returns false when the run must not start.
+ * Before method run FILE in the parent process: the outcomes of fixes not yet shown are printed, the file takes the
+ * newest version of its Method, corrections that wait start a fix, and the same-run line is printed. Returns false when the run must not start.
  */
 async function beforeFileRun(args, clientFactory) {
     if (process.env.METHOD_RUN_WORKER === '1' || args.includes('--resume') || !existsSync(args[1]))
@@ -116,6 +116,16 @@ async function beforeFileRun(args, clientFactory) {
         client = undefined;
     }
     const file = authoringPath(args[1]);
+    // The outcomes of fixes that nobody has seen yet come first.
+    const id = (() => { try {
+        return readDocument(file).id;
+    }
+    catch {
+        return undefined;
+    } })();
+    if (typeof id === 'string' && methodIdPattern.test(id))
+        for (const line of (await import('./fix-outcomes.js')).unshownLines(id))
+            process.stderr.write(line + '\n');
     const caught = await catchUpFile(client, file);
     if (caught === 'conflict')
         return false;
@@ -134,14 +144,22 @@ async function beforeFileRun(args, clientFactory) {
     return true;
 }
 /**
- * Before method run FILE: corrections that wait for this Method (from the dashboard, or a loop that stopped) are fixed
- * first, with one line about them. When a fix of the Method already runs on this computer, the run does not wait: that
- * fix takes the waiting corrections. A failure of the loop is one line too; the run goes on. Signed out, offline, a
- * resumed run, or the run worker: nothing.
+ * Before method run FILE: corrections that wait for this Method (from the dashboard, an answer on the dashboard, or a
+ * fix that stopped) start a fix in its own process, with one line; the run does not wait for it. Signed out, offline,
+ * a resumed run, or the run worker: nothing.
  */
 async function fixWaitingCorrections(args, clientFactory) {
     if (process.env.METHOD_RUN_WORKER === '1' || args.includes('--resume') || !existsSync(args[1]))
         return;
+    const file = authoringPath(args[1]), id = (() => { try {
+        return readDocument(file).id;
+    }
+    catch {
+        return undefined;
+    } })();
+    if (typeof id !== 'string' || !methodIdPattern.test(id))
+        return;
+    const outcomes = await import('./fix-outcomes.js');
     const server = parseArgs({ args: args.slice(2), strict: false, options: { server: { type: 'string' } } }).values.server;
     let client;
     try {
@@ -152,10 +170,17 @@ async function fixWaitingCorrections(args, clientFactory) {
     catch {
         return;
     }
-    const { fixWaiting, waitingLine } = await import('./improve.js');
+    const { fixRunning, waitingCorrections } = await import('./improve.js');
+    // A fix that runs now takes the waiting corrections in its next pass.
+    if (fixRunning(id))
+        return;
     try {
-        for (const fix of await fixWaiting(client, authoringPath(args[1]), { waitMs: 3000 }) ?? [])
-            process.stderr.write(waitingLine(fix) + '\n');
+        const waiting = (await waitingCorrections(client, file, id, 3000)).map(j => j.id);
+        if (!waiting.length)
+            return;
+        outcomes.markWorking(id, file, waiting);
+        await outcomes.fixStarter.start(file, id, waiting, client.server);
+        process.stderr.write((await import('./fix-lines.js')).waitingLine(waiting.length) + '\n');
     }
     catch (error) {
         if (!/^(fetch failed|401:|404:)|abort|timed? ?out/i.test(error.message))
@@ -198,6 +223,23 @@ export async function methodMain(args = process.argv.slice(2), clientFactory = s
     }
     if (args[0] === 'judge')
         return (await import('./judge.js')).judgeCommand(args.slice(1), clientFactory);
+    if (args[0] === 'answer' && /^jdg_/.test(args[1] ?? ''))
+        return (await import('./judge.js')).answerJudgmentCommand(args.slice(1), clientFactory);
+    if (args[0] === 'wait' && (!args[1] || /^jdg_|^--/.test(args[1])))
+        return (await import('./fix-outcomes.js')).waitCommand(args.slice(1));
+    if (args[0] === 'learned')
+        return (await import('./learned.js')).learnedCommand(args.slice(1), clientFactory);
+    if (args[0] === 'undo')
+        return (await import('./undo.js')).undoCommand(args.slice(1), clientFactory);
+    if (args[0] === '__fix' || args[0] === '__watch') {
+        const p = parseArgs({ args: args.slice(1), allowPositionals: true, options: { server: { type: 'string' }, judgment: { type: 'string', multiple: true }, prune: { type: 'boolean' } } });
+        const client = clientFactory(p.values.server ?? DEFAULT_SERVER), file = authoringPath(p.positionals[0]);
+        if (args[0] === '__watch') {
+            await (await import('./watch.js')).watchRun(client, file, resolve(p.positionals[1]));
+            return;
+        }
+        return (await import('./improve.js')).backgroundFix(client, file, p.values.judgment ?? [], { prune: !!p.values.prune });
+    }
     if (args[0] === 'changes')
         return (await import('./proposals.js')).changesMain(args.slice(1), clientFactory);
     if (args[0] === 'run' && /\.method$/i.test(args[1] ?? '') && !args.includes('--help') && !await beforeFileRun(args, clientFactory))

package/dist/packages/sdk/src/quality.d.ts

@@ -17,26 +17,77 @@ export declare const defaultRunRoots: () => string[];
 export declare function observeCommand(args: string[]): Promise<void>;
 /** A fingerprint of a Method and the files it runs, to tell whether its cases were checked since the last change. */
 export declare function methodFingerprint(file: string): string;
-/** A case as a person reads it: "Gráinne's case dates-conflict: the note" when the case names who made it. */
-export declare const caseName: (c: {
-    id: string;
-    author?: string | null;
-    note?: unknown;
-}) => string;
-/** One line for method run when the Method changed since its cases last passed. Cases with an author are named. */
+/** One line for method run when the Method changed since its earlier corrections last passed. Their authors are named. */
 export declare function casesNotice(file: string): Promise<string | undefined>;
+/**
+ * The judge profiles for a rubric: the configured judge, and when it is the user's own Claude Code or Codex and the
+ * other one is installed and signed in too, that one as well. A judge that the Method names is the only judge.
+ */
+export declare function judgeProfiles(config: any): Promise<any[]>;
+/**
+ * Evaluate a case's expectations with every judge profile (the runtime's judges option). A criterion passes only when
+ * every judge passes it; when the judges disagree it fails as unsure.
+ */
+export declare function evaluateWithJudges(expect: any[], outcome: any, context: {
+    caseDir: string;
+    config: any;
+    options?: any;
+}, profiles: any[]): Promise<{
+    status: string;
+    results: {
+        criteria?: ({
+            id: string;
+            text: string;
+            judge: string;
+            probability: any;
+            pass: boolean;
+            reason: string;
+            votes?: undefined;
+            unsure?: undefined;
+        } | {
+            id: string;
+            text: string;
+            judge: string;
+            votes: any[];
+            pass: boolean;
+            unsure: boolean;
+            reason: string;
+            probability?: undefined;
+        } | {
+            id: string;
+            text: string;
+            judge: string;
+            votes: any[];
+            pass: boolean;
+            reason: any;
+            probability?: undefined;
+            unsure?: undefined;
+        })[];
+        judge_calls?: number;
+        kind: any;
+        status: string;
+        reason: string;
+        text?: any;
+    }[];
+}>;
 /** The name of the signed-in person, for the author of a new case; null when signed out or offline. Asked once per sign-in in a process. */
 export declare function signedInName(client?: Pick<MethodClient, "server" | "request" | "token">): Promise<string | null>;
 /** Run the cases of a Method with the same preparation as method run. */
-export declare function runCases(file: string, flags: {
-    workspace?: string;
-}, options?: {
+export type CaseRunOptions = {
     casesDir?: string | undefined;
     ids?: string[] | undefined;
     baseline?: string | undefined;
     newIds?: string[];
     once?: boolean;
-}): Promise<{
+    runs?: number | undefined;
+    minPass?: number | undefined;
+    live?: string[] | undefined;
+    judgeCache?: boolean | undefined;
+    keepDir?: string | undefined;
+};
+export declare function runCases(file: string, flags: {
+    workspace?: string;
+}, options?: CaseRunOptions): Promise<{
     counts: {
         [k: string]: number;
     };

package/dist/packages/sdk/src/quality.js

@@ -1,16 +1,17 @@
 /** Effect observation, recorded cases, the save gate, and library observers. */
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
 import { parseArgs } from "node:util";
 import { observeRun, pendingRuns } from "@withmethod/runtime/observe.js";
-import { createCase, retireCase, listCases, testSuite } from "@withmethod/runtime/cases.js";
+import { createCase, retireCase, listCases, testSuite, evaluate } from "@withmethod/runtime/cases.js";
 import { authoringPath, editDocument, readDocument } from "./authoring.js";
 import { localSetup } from "./local-setup.js";
 import { resolveAgentProfiles, checkAgents, accountNeeds } from "./capabilities.js";
-import { localAgent, resolveModels } from "@withmethod/runtime/agents.js";
+import { agentSignedIn, localAgent, resolveModels } from "@withmethod/runtime/agents.js";
+import { executable } from "@withmethod/runtime/io.js";
 import { hostedModelsFor, managedModels } from "./hosted-models.js";
 import { managedClassification } from "./classification-client.js";
 import { MethodClient } from "./method-client.js";
@@ -58,6 +59,8 @@ export async function preparedConfig(file, flags, options = {}) {
         config.classification = await classification.resolve(new AbortController().signal);
     await checkAgents(config.models);
     const prepared = await prepareRuntime(setup.sourceRoot, config, method);
+    // A case's check script runs on Node, which the CLI itself runs on.
+    prepared.config.runtimes = { node: { command: process.execPath, version: process.version }, ...prepared.config.runtimes };
     const hostedModels = Object.values(prepared.config.models ?? {}).some((profile) => profile.backend === 'method') ? await hostedModelsFor(client) : undefined;
     return { config: prepared.config, sourceRoot: setup.sourceRoot, processPath: prepared.processPath, prepareBundle: prepared.prepareBundle, ...(hostedModels ? { hostedModels } : {}), ...(classification ? { classification } : {}) };
 }
@@ -100,7 +103,7 @@ export async function observeCommand(args) {
 export function methodFingerprint(file) {
     const folder = dirname(file), method = readDocument(file);
     const parts = [readFileSync(file, "utf8")];
-    const paths = new Set(method.files ?? []);
+    const paths = new Set([...(method.files ?? []), ...(existsSync(join(folder, "learned.json")) ? ["learned.json"] : [])]);
     for (const step of Object.values(method.steps ?? {})) {
         for (const exec of [step.do, step.check])
             if (exec?.kind === "run")
@@ -125,9 +128,7 @@ function recordChecked(file, report) {
     mkdirSync(dirname(checkedFile(file)), { recursive: true, mode: 0o700 });
     writePrivateJson(checkedFile(file), { file, fingerprint: methodFingerprint(file), passed: report.passed, cases: report.cases.length, at: new Date().toISOString() });
 }
-/** A case as a person reads it: "Gráinne's case dates-conflict: the note" when the case names who made it. */
-export const caseName = (c) => `${c.author}'s case ${c.id}: ${String(c.note ?? "").slice(0, 200).replace(/[.\s]+$/, "")}`;
-/** One line for method run when the Method changed since its cases last passed. Cases with an author are named. */
+/** One line for method run when the Method changed since its earlier corrections last passed. Their authors are named. */
 export async function casesNotice(file) {
     const cases = (await listCases(file)).filter((c) => c.status === "active");
     if (!cases.length)
@@ -139,8 +140,34 @@ export async function casesNotice(file) {
     catch { /* never checked */ }
     if (checked?.passed && checked.fingerprint === methodFingerprint(file))
         return undefined;
-    const named = cases.filter((c) => c.author);
-    return `${cases.length} case${cases.length === 1 ? "" : "s"} not checked since this Method changed${named.length ? ` (${named.map(caseName).join("; ")})` : ""}: method test ${file}`;
+    const { uncheckedLine, correctionName } = await import("./fix-lines.js");
+    return uncheckedLine(cases.length, cases.filter((c) => c.author).map(correctionName), `method test ${basename(file)}`);
+}
+/**
+ * The judge profiles for a rubric: the configured judge, and when it is the user's own Claude Code or Codex and the
+ * other one is installed and signed in too, that one as well. A judge that the Method names is the only judge.
+ */
+export async function judgeProfiles(config) {
+    const first = config?.models?.judge;
+    if (!first)
+        return [];
+    if (!["claude", "codex"].includes(first.backend) || first.command || first.model)
+        return [first];
+    const other = first.backend === "claude" ? "codex" : "claude";
+    try {
+        await executable(other);
+    }
+    catch {
+        return [first];
+    }
+    return await agentSignedIn(other) ? [first, { backend: other }] : [first];
+}
+/**
+ * Evaluate a case's expectations with every judge profile (the runtime's judges option). A criterion passes only when
+ * every judge passes it; when the judges disagree it fails as unsure.
+ */
+export async function evaluateWithJudges(expect, outcome, context, profiles) {
+    return evaluate(expect, outcome, profiles.length < 2 ? context : { ...context, options: { ...context.options, judges: profiles } });
 }
 const signedIn = new Map();
 /** The name of the signed-in person, for the author of a new case; null when signed out or offline. Asked once per sign-in in a process. */
@@ -172,22 +199,30 @@ async function declaredSecrets(file) {
     const { resolveSecrets } = await import("./secrets.js");
     return resolveSecrets(Object.keys(readDocument(file)?.secrets ?? {}));
 }
-/** Run the cases of a Method with the same preparation as method run. */
 export async function runCases(file, flags, options = {}) {
     const prepared = await preparedConfig(file, flags, { judge: true });
-    const report = await testSuite(file, prepared.config, { ...options,
+    // Claude Code and Codex both judge when both are signed in; a disagreement fails the criterion as unsure.
+    const judges = await judgeProfiles(prepared.config);
+    const report = await testSuite(file, prepared.config, { ...options, ...(judges.length > 1 ? { judges } : {}),
         runOptions: { processPath: prepared.processPath, prepareBundle: prepared.prepareBundle, secrets: await declaredSecrets(file), ...(prepared.classification ? { classification: prepared.classification } : {}), ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) } });
-    if (!options.ids && !options.casesDir && !options.once)
+    if (!options.ids && !options.casesDir && !options.once && !options.runs && !options.live?.length)
         recordChecked(file, report);
     return report;
 }
 export async function testCommand(args) {
-    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { case: { type: "string", multiple: true }, new: { type: "string", multiple: true }, baseline: { type: "string" }, cases: { type: "string" }, workspace: { type: "string" }, once: { type: "boolean" } } });
+    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { case: { type: "string", multiple: true }, new: { type: "string", multiple: true }, baseline: { type: "string" }, cases: { type: "string" }, workspace: { type: "string" }, once: { type: "boolean" },
+            runs: { type: "string" }, "min-pass": { type: "string" }, live: { type: "string", multiple: true }, "no-judge-cache": { type: "boolean" }, "keep-dir": { type: "string" } } });
     const file = positionals[0];
+    const usage = "Use method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--once | --runs N [--min-pass N]] [--live STEP]... [--no-judge-cache] [--keep-dir DIR]";
     if (!file || positionals.length !== 1)
-        throw Error("Use method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--once]");
+        throw Error(usage);
+    const count = (value, name) => { if (value === undefined)
+        return undefined; const n = Number(value); if (!Number.isSafeInteger(n) || n < 1 || n > 20)
+        throw Error(`${name} must be a number from 1 to 20. ${usage}`); return n; };
     const report = await runCases(authoringPath(file), values, { casesDir: values.cases ? authoringPath(values.cases) : undefined, ids: values.case,
-        baseline: values.baseline ? authoringPath(values.baseline) : undefined, newIds: values.new ?? [], once: !!values.once });
+        baseline: values.baseline ? authoringPath(values.baseline) : undefined, newIds: values.new ?? [], once: !!values.once,
+        runs: count(values.runs, "--runs"), minPass: count(values["min-pass"], "--min-pass"), live: values.live?.flatMap(step => step.split(",")).map(step => step.trim()).filter(Boolean),
+        ...(values["no-judge-cache"] ? { judgeCache: false } : {}), keepDir: values["keep-dir"] ? authoringPath(values["keep-dir"]) : undefined });
     print(report);
     process.exitCode = report.passed ? 0 : 1;
 }
@@ -200,16 +235,16 @@ export async function caseGate(file, accept = [], reason) {
     if (!cases.length)
         return { line: undefined, report: undefined };
     // A save checks every case; say so first, because live model steps and judges take time and cost money.
-    process.stderr.write(`Checking ${cases.length} case${cases.length === 1 ? "" : "s"} before saving. Cases whose model steps changed run them live, up to three times each.\n`);
+    process.stderr.write(`Checking ${cases.length} earlier correction${cases.length === 1 ? "" : "s"} before saving. Parts of the agent that changed run again, which can take a few minutes.\n`);
     const report = await runCases(file, {});
-    const t = report.totals;
-    process.stderr.write(`Cases checked in ${Math.round(t.duration_ms / 1000)} s: ${t.live_model_steps} live model step${t.live_model_steps === 1 ? "" : "s"}, ${t.judge_calls} judge call${t.judge_calls === 1 ? "" : "s"}.\n`);
+    process.stderr.write(`Checked in ${Math.round(report.totals.duration_ms / 1000)} s.\n`);
     const failing = report.cases.filter((c) => !["pass", "fixed"].includes(c.verdict));
     const unaccepted = failing.filter((c) => !accept.includes(c.id));
-    const authors = new Map(cases.map((c) => [c.id, c.author]));
-    const shown = (c) => authors.get(c.id) ? `${caseName({ ...c, author: authors.get(c.id) })} (${c.verdict})` : `${c.id} (${c.verdict}: ${c.note})`;
+    const byId = new Map(cases.map((c) => [c.id, c]));
+    const { correctionName } = await import("./fix-lines.js");
+    const shown = (c) => correctionName(byId.get(c.id) ?? c);
     if (unaccepted.length)
-        throw Object.assign(Error(`This version breaks ${unaccepted.length} approved case${unaccepted.length === 1 ? "" : "s"}: ${unaccepted.map(shown).join("; ")}. Fix the Method and run method test, or retire a case whose rule no longer applies with method case retire. To publish anyway, add --accept-failing-case ${unaccepted.map((c) => c.id).join(",")} with --reason.`), { code: "cases_failed" });
+        throw Object.assign(Error(`This change breaks ${unaccepted.length} earlier correction${unaccepted.length === 1 ? "" : "s"}: ${unaccepted.map(shown).join("; ")}. Fix the Method and run method test, or retire a correction whose rule no longer applies with method case retire. To publish anyway, add --accept-failing-case ${unaccepted.map((c) => c.id).join(",")} with --reason.`), { code: "cases_failed" });
     if (failing.length && !reason)
         throw Error("Give --reason for accepting a failing case.");
     return { report, line: failing.length ? `Cases: ${report.cases.length - failing.length} of ${report.cases.length} passed; accepted failing ${failing.map((c) => c.id).join(", ")}.` : `Cases: ${report.cases.length} of ${report.cases.length} passed.` };

package/dist/packages/sdk/src/undo.d.ts

@@ -0,0 +1,50 @@
+import { type MethodClient } from './method-client.js';
+export type UndoRecord = {
+    id: string;
+    file: string;
+    kind: 'fix' | 'prune' | 'learned';
+    created_at: string;
+    cause: string;
+    /** What the person reads after undo: what is no longer in effect. */
+    what: string;
+    before: {
+        text: string;
+        files: Record<string, string | null>;
+    };
+    after: {
+        sha256: string;
+        files: Record<string, string | null>;
+    };
+    undone_at?: string;
+};
+/** Take what the file and the named files are now, before a change is written. */
+export declare function snapshot(file: string, paths: string[]): {
+    text: string;
+    files: {
+        [k: string]: string | null;
+    };
+};
+/** Record a change after it was written, so method undo can restore the state before it. */
+export declare function recordChange(file: string, kind: UndoRecord['kind'], cause: string, what: string, before: UndoRecord['before']): UndoRecord;
+/** The changes of this file that can be undone, newest first. */
+export declare function undoRecords(file: string): (UndoRecord & {
+    path: string;
+})[];
+/**
+ * Restore the Method file, and the files the change wrote, as they were before the last change Method made (or before
+ * the change `id`, which must be the last one). A file that changed after that change is not overwritten. Returns the
+ * undone record; the caller saves the restored file as a new version.
+ */
+export declare function undoLast(file: string, id?: string): UndoRecord & {
+    path: string;
+};
+/**
+ * `method undo [FILE] [--json]`: restore the Method file, and the files the change wrote, as they were before the last
+ * fix, pruning change, or removed learned rule. The restored file is saved as a new version.
+ */
+export declare function undoCommand(args: string[], clientFactory: (server: string) => MethodClient): Promise<void>;
+/** Save a changed file as a new version when this computer is signed in. Undefined when it cannot be saved now. */
+export declare function saveVersion(client: MethodClient, file: string, reason: string): Promise<{
+    version_id: string;
+    url: string;
+} | undefined>;