@method-ai-hq/sdk 0.19.0 → 0.20.1

package/README.md

@@ -3,7 +3,7 @@
 MIT-licensed JavaScript API and the `method` CLI. Source and releases: https://github.com/method-ai-hq/method-sdk
 
 ```sh
-npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.19.0/method-ai-hq-sdk-0.19.0.tgz
+npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.20.1/method-ai-hq-sdk-0.20.1.tgz
 npx method --version
 ```
 

package/dist/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@method-ai-hq/sdk",
-    "version": "0.19.0",
+    "version": "0.20.1",
     "description": "Build and run reusable .method files with checked steps and saved results.",
     "license": "MIT",
     "type": "module",
@@ -35,7 +35,7 @@
         "prepack": "npm --prefix ../.. run build"
     },
     "dependencies": {
-        "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.15.0",
+        "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.16.2",
         "fflate": "^0.8.3",
         "yaml": "^2.9.0",
         "zod": "^3.25.76"

package/dist/packages/sdk/src/authoring-instructions.d.ts

@@ -16,5 +16,5 @@ export declare const costRules = "Before describing execution cost, check how th
 /** What to watch after a Method works. */
 export declare const watchRules = "# Watch it\n\n- Look at failed and unconfirmed runs on the dashboard. A run that needs attention says which step failed and why.\n- For classify, watch how often the choice is `unclear` or below your threshold. A rise means the inputs changed.\n- For slow effects such as email delivery, schedule `method observe --pending`.\n";
 /** What to do after a Method works: production, improvement, and script cards. */
-export declare const afterRules = "# After it works\n\n- **Put it in an app:** `method connect APP_FOLDER` publishes it and prints the code to add.\n- **Record each reaction:** after you show a result, run `method judge RUN_ID wrong --note \"THEIR WORDS\"` (with `--corrected FILE` when they gave the right result) when the user corrects it or asks to change the Method because of it, and `method judge RUN_ID right` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction: a wrong judgment fixes the Method on this computer, with the user's own Claude Code or Codex, and prints one line about what changed or why nothing did. `method changes FILE` lists what it changed.\n- **Explain the scripts:** `method explain FILE` writes a card for each script step.\n";
+export declare const afterRules = "# After it works\n\n- **Put it in an app:** `method connect APP_FOLDER` publishes it and prints the code to add.\n- **Record each reaction:** after you show a result, run `method judge RUN_ID wrong --note \"THEIR WORDS\"` (with `--corrected FILE` when they gave the right result) when the user corrects it or asks to change the Method because of it, and `method judge RUN_ID right` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction. A wrong judgment returns at once and tests a fix in the background with the user's own Claude Code or Codex. Run `method wait` for the result and tell the user its line. After a fix, show the tested output that `method wait` prints; never run a Method that sends or changes things again just to show it. When it prints a question, show it to the user word for word, never answer it yourself, and send their words with `method answer JUDGMENT_ID \"THEIR WORDS\"`. `method learned FILE` lists what the agent learned from corrections; `method undo` restores the Method as it was before Method's last change.\n- **Explain the scripts:** `method explain FILE` writes a card for each script step.\n";
 export declare const exampleSelection = "After choosing the step types, read the examples that fit the design. Use their syntax; choose the steps for this task yourself.";

package/dist/packages/sdk/src/authoring-instructions.js

@@ -152,7 +152,7 @@ export const watchRules = `# Watch it
 export const afterRules = `# After it works
 
 - **Put it in an app:** \`method connect APP_FOLDER\` publishes it and prints the code to add.
-- **Record each reaction:** after you show a result, run \`method judge RUN_ID wrong --note "THEIR WORDS"\` (with \`--corrected FILE\` when they gave the right result) when the user corrects it or asks to change the Method because of it, and \`method judge RUN_ID right\` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction: a wrong judgment fixes the Method on this computer, with the user's own Claude Code or Codex, and prints one line about what changed or why nothing did. \`method changes FILE\` lists what it changed.
+- **Record each reaction:** after you show a result, run \`method judge RUN_ID wrong --note "THEIR WORDS"\` (with \`--corrected FILE\` when they gave the right result) when the user corrects it or asks to change the Method because of it, and \`method judge RUN_ID right\` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction. A wrong judgment returns at once and tests a fix in the background with the user's own Claude Code or Codex. Run \`method wait\` for the result and tell the user its line. After a fix, show the tested output that \`method wait\` prints; never run a Method that sends or changes things again just to show it. When it prints a question, show it to the user word for word, never answer it yourself, and send their words with \`method answer JUDGMENT_ID "THEIR WORDS"\`. \`method learned FILE\` lists what the agent learned from corrections; \`method undo\` restores the Method as it was before Method's last change.
 - **Explain the scripts:** \`method explain FILE\` writes a card for each script step.
 `;
 export const exampleSelection = "After choosing the step types, read the examples that fit the design. Use their syntax; choose the steps for this task yourself.";

package/dist/packages/sdk/src/current-inspection.js

@@ -33,6 +33,7 @@ export function inspectCurrentRun(root, activeSnapshot = false, includeFiles = f
     const start = events.find(e => e.event === "run.started");
     const invocations = {};
     const setup = existsSync(join(root, 'setup.json')) ? read('setup.json') : [];
+    const ids = (value) => (Array.isArray(value) ? value : []).filter((id) => typeof id === 'string').slice(0, 500).map(id => id.slice(0, 100));
     const runEvents = setup;
     for (const event of events) {
         // Keep useful trace fields; do not upload tool arguments, environment values, or process stdout.
@@ -58,6 +59,8 @@ export function inspectCurrentRun(root, activeSnapshot = false, includeFiles = f
             ...(Number.isSafeInteger(event.total) ? { total: event.total, ...(typeof event.unit === "string" ? { unit: event.unit } : {}) } : {}),
             ...(typeof event.key === "string" ? { key: event.key } : {}),
             ...(Number.isSafeInteger(event.attempt) ? { attempt: event.attempt } : {}), ...(Number.isSafeInteger(event.attempts) ? { attempts: event.attempts } : {}),
+            // Rule IDs only: the server counts how often each learned rule applied.
+            ...(event.event === "learned.applied" ? { considered: ids(event.considered), applied: ids(event.applied) } : {}),
             ...(event.entrypoint ? { command: [event.runtime, event.entrypoint, ...(event.args ?? [])].filter(Boolean).join(" ") } : typeof event.command === "string" ? { command: event.command } : {}),
             ...(event.exit_code !== undefined ? { exit_code: event.exit_code } : {}),
             ...(typeof event.diagnostics === "string" && event.diagnostics ? { diagnostics: event.diagnostics.length <= 4000 ? event.diagnostics : event.diagnostics.slice(0, 1000) + "\n[middle omitted]\n" + event.diagnostics.slice(-3000) } : {}),

package/dist/packages/sdk/src/fix-lines.d.ts

@@ -0,0 +1,82 @@
+/** What the fix loop did with one correction. */
+export type OutcomeKind = 'fixed' | 'no_fix_found' | 'could_not_test' | 'question' | 'held' | 'not_reproduced' | 'not_fixable_here' | 'already_changed' | 'retry' | 'elsewhere';
+export type CouldNotTestReason = 'missing_file' | 'can_send' | 'too_large' | 'no_live_step';
+/** The output that a tested fix gave, so the agent can show it without running the Method again. */
+export type TestedOutput = {
+    result?: unknown;
+    files?: Record<string, string>;
+    held_back?: Array<{
+        tool: string;
+        args: unknown;
+    }>;
+};
+export type CorrectionOutcome = {
+    id: string;
+    outcome: OutcomeKind;
+    /** fixed: what is different now, in the person's words ("replies now include the redline"). */
+    summary?: string;
+    /** could_not_test: why. */
+    reason?: CouldNotTestReason;
+    /** question: one question in the person's terms. */
+    question?: string;
+    /** no_fix_found: how many changes were tried. */
+    tried?: number;
+    /** fixed: how often the fix passed on this result, and on how many earlier results it was checked. */
+    tested?: {
+        times: number;
+        earlier: number;
+    };
+    /** The thing the Method works on, as a plain noun ("NDA", "reply"); the lines say "result" without it. */
+    subject?: string;
+    /** could_not_test can_send: what the agent can send ("email"). */
+    sends?: string;
+    /** could_not_test: the note was added as a learned rule that later runs check. */
+    rule_added?: boolean;
+    /** held and already_changed: the other person; held: what they asked for. */
+    by?: string;
+    detail?: string;
+    /** missing_file: the file that is gone. For --json only; never in a line. */
+    path?: string;
+    tested_output?: TestedOutput;
+    /** retry: another correction's fix changed the same part, so this one is fixed again on the new file in the next pass. */
+    again?: boolean;
+};
+/** The line after method judge: the fix runs in the background. */
+export declare const workingLine = "Working on it. I'll test a fix on this run.";
+export declare const workingAnswerLine = "Thanks. Working on it with your answer. I'll test a fix on this run.";
+export declare const waitingLine: (n: number) => string;
+export declare const stillWorkingLine = "Still working on it. Run method wait again.";
+export declare const nothingWaitingLine = "Nothing is being fixed on this computer.";
+export declare const notHereLine = "Noted. The agent is not on this computer, so the next time it runs on a computer I'll test a fix there.";
+export declare const approvedLine = "Noted: this result is right.";
+export declare const stoppedLine = "The fix stopped before it finished. I'll try again on the next run.";
+export declare const errorLine: (message: string) => string;
+export declare const undoneLine: (what?: string) => string;
+export declare const removedRuleLine: (rule: string) => string;
+/** The line after a pruning change: what the sweep says it did (improve.method's summary), and how to undo it. */
+export declare const prunedLine: (summary: string) => string;
+/** A fix that broke an earlier result in the later check is undone, and its correction waits for a new fix. */
+export declare const fixUndoneLine: (note: string | undefined) => string;
+/** A rule that a pruning change removed came back because its problem came back. */
+export declare const ruleBackLine: (rule: string) => string;
+export declare const cameBackLine: (note: string | undefined) => string;
+export declare const testedOutputHeading = "What the fixed agent gives now (tested; nothing was sent):";
+export declare const heldBackHeading = "What it would send (held back during the test):";
+/** The one line for what the loop did with a correction. */
+export declare function outcomeLine(o: CorrectionOutcome): string;
+/** The line for the agent after a question: it shows the question and sends the answer. Not for the person. */
+export declare const answerNext: (judgmentId: string) => string;
+/** Two people judged the same result in opposite ways. */
+export type HeldPerson = {
+    verdict: string;
+    noted_by: string | null;
+    note: string | null;
+};
+export declare function heldPairLine(people: HeldPerson[]): string;
+/** A correction as a person reads it: "Gráinne's correction ("the note")", or "A correction ("the note")". */
+export declare const correctionName: (c: {
+    author?: string | null;
+    note?: unknown;
+}) => string;
+/** The run notice when the Method changed since its earlier corrections were checked. */
+export declare const uncheckedLine: (count: number, named: string[], command: string) => string;

package/dist/packages/sdk/src/fix-lines.js

@@ -0,0 +1,63 @@
+// Every line that a fix shows to the person. The words are about the person's work: no Method internals (no case,
+// step, criterion, judge, version, IDs, paths or run counts). testkit/sdk/fix-lines.test.ts scans these lines.
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const thing = (o) => o.subject?.trim() ? `this ${o.subject.trim()}` : 'this result';
+const sentence = (text) => text.trim().replace(/[.\s]+$/, '');
+const kept = (o) => o.rule_added ? 'I added your note as a rule and will check it on the next runs.' : "I'll keep your note.";
+const quoted = (text) => text?.trim() ? ` ("${sentence(text).slice(0, 200)}")` : '';
+/** The line after method judge: the fix runs in the background. */
+export const workingLine = 'Working on it. I\'ll test a fix on this run.';
+export const workingAnswerLine = 'Thanks. Working on it with your answer. I\'ll test a fix on this run.';
+export const waitingLine = (n) => n === 1 ? 'Working on a correction that was waiting. I\'ll test a fix for it.' : `Working on ${n} corrections that were waiting. I'll test a fix for each.`;
+export const stillWorkingLine = 'Still working on it. Run method wait again.';
+export const nothingWaitingLine = 'Nothing is being fixed on this computer.';
+export const notHereLine = 'Noted. The agent is not on this computer, so the next time it runs on a computer I\'ll test a fix there.';
+export const approvedLine = 'Noted: this result is right.';
+export const stoppedLine = 'The fix stopped before it finished. I\'ll try again on the next run.';
+export const errorLine = (message) => `The fix stopped: ${sentence(message)}. I'll try again on the next run.`;
+export const undoneLine = (what) => what?.trim() ? `Undone: ${sentence(what)}. The agent works as it did before.` : 'Undone. The agent works as it did before the last change.';
+export const removedRuleLine = (rule) => `Removed: "${sentence(rule)}". Undo: method undo.`;
+/** The line after a pruning change: what the sweep says it did (improve.method's summary), and how to undo it. */
+export const prunedLine = (summary) => `${sentence(summary)}. Undo: method undo.`;
+/** A fix that broke an earlier result in the later check is undone, and its correction waits for a new fix. */
+export const fixUndoneLine = (note) => `I undid the fix for your correction${quoted(note)}: it changed a result that was right before. I'll try a new fix on the next run.`;
+/** A rule that a pruning change removed came back because its problem came back. */
+export const ruleBackLine = (rule) => `I put back the rule "${sentence(rule)}": without it, a problem you corrected came back.`;
+export const cameBackLine = (note) => `A problem you corrected came back twice${quoted(note)}. I'll test a new fix. To go back to how it worked before the last change: method undo.`;
+export const testedOutputHeading = 'What the fixed agent gives now (tested; nothing was sent):';
+export const heldBackHeading = 'What it would send (held back during the test):';
+/** The one line for what the loop did with a correction. */
+export function outcomeLine(o) {
+    switch (o.outcome) {
+        case 'fixed': {
+            const tested = o.tested ? ` Tested ${plural(o.tested.times, 'time')} on ${thing(o)}${o.tested.earlier ? ` and on ${plural(o.tested.earlier, 'earlier one')}` : ''}.` : '';
+            return `Fixed${o.summary?.trim() ? `: ${sentence(o.summary)}` : ''}.${tested} Undo: method undo.`;
+        }
+        case 'no_fix_found':
+            return `No fix found yet: I tried ${o.tried ? plural(o.tried, 'change') : 'several changes'}; none fixed ${thing(o)} reliably. ${kept(o)}`;
+        case 'could_not_test': {
+            const why = o.reason === 'can_send' ? `this agent can send ${o.sends?.trim() || 'messages'}`
+                : o.reason === 'missing_file' ? `a file that ${thing(o)} came from is no longer on this computer`
+                    : o.reason === 'too_large' ? `${thing(o)} came from more files than I can copy to test with`
+                        : 'my change did not reach the part of the agent that made this result';
+            return `Could not test a fix safely: ${why}. ${kept(o)}`;
+        }
+        case 'question': return `I have one question before I change anything: ${o.question?.trim() ?? ''}`;
+        case 'held': return `Not changed: ${o.by ?? 'someone else'} wants a different result here${quoted(o.detail)}. Decide with them which one is right.`;
+        case 'not_reproduced': return `This mistake happens only sometimes, and I could not make it happen again. ${kept(o)} Tell me if you see it again.`;
+        case 'not_fixable_here': return 'This does not come from how the agent works: it likely comes from the input, the data, or a tool it uses. I\'ll keep your note.';
+        case 'already_changed': return `Not changed: ${o.by ? `${o.by} changed` : 'someone changed'} this part of the agent after this result, which may already fix it.`;
+        case 'retry': return 'Not changed yet: the agent changed while I tested a fix. I\'ll try again on the next run.';
+        case 'elsewhere': return 'Another computer is testing a fix for this.';
+    }
+}
+/** The line for the agent after a question: it shows the question and sends the answer. Not for the person. */
+export const answerNext = (judgmentId) => `Show this question to the person word for word, and do not answer it yourself. Send their answer with: method answer ${judgmentId} "THEIR WORDS"`;
+export function heldPairLine(people) {
+    const said = (j) => `${j.noted_by ?? 'Someone'} says it is ${j.verdict}${quoted(j.note ?? undefined)}`;
+    return `Two people disagree about this result: ${people.map(said).join('; ')}. Nothing changes until one is kept.`;
+}
+/** A correction as a person reads it: "Gráinne's correction ("the note")", or "A correction ("the note")". */
+export const correctionName = (c) => `${c.author ? `${c.author}'s correction` : 'A correction'}${quoted(String(c.note ?? ''))}`;
+/** The run notice when the Method changed since its earlier corrections were checked. */
+export const uncheckedLine = (count, named, command) => `${plural(count, 'earlier correction')} ${count === 1 ? 'was' : 'were'} not checked since this agent changed${named.length ? ` (${named.join('; ')})` : ''}. Check ${count === 1 ? "it" : "them"}: ${command}`;

package/dist/packages/sdk/src/fix-outcomes.d.ts

@@ -0,0 +1,72 @@
+import { type CorrectionOutcome } from './fix-lines.js';
+export type StoredOutcome = {
+    judgment: string;
+    method_id: string;
+    file: string;
+    status: 'working' | 'done' | 'stopped';
+    started_at: string;
+    pid?: number | undefined;
+    finished_at?: string;
+    outcome?: CorrectionOutcome;
+    error?: string;
+    log?: string;
+    shown: boolean;
+    /** A record that is not about one correction: a pruning change, or a fix that stopped holding. */
+    kind?: 'prune' | 'came_back';
+    line?: string;
+};
+export declare const fixFolder: (methodId: string) => string;
+/** Mark corrections as being fixed now: method wait waits for them. */
+export declare function markWorking(methodId: string, file: string, ids: string[], pid?: number): void;
+/** The fix process that works on these corrections. */
+export declare function setWorker(methodId: string, ids: string[], pid: number): void;
+export declare function saveOutcome(methodId: string, file: string, outcome: CorrectionOutcome, log?: string): void;
+export declare function saveError(methodId: string, file: string, id: string, error: string, log?: string): void;
+/** A line that is not about one correction (a pruning change; a fix that came back). */
+export declare function saveNotice(methodId: string, file: string, kind: 'prune' | 'came_back', line: string): void;
+export declare function storedOutcome(methodId: string, id: string): StoredOutcome | undefined;
+/** Every stored record, of one Method or of all; a working record whose process stopped reads as stopped. */
+export declare function storedOutcomes(methodId?: string): StoredOutcome[];
+export declare function markShown(record: StoredOutcome): void;
+/** The lines of a record: the person's line, the tested output after a fix, and for a question the agent's next step. */
+export declare function recordLines(record: StoredOutcome, options?: {
+    brief?: boolean;
+}): string[];
+/** The JSON of a record for --json: the outcome as the agent reads it, with the person's line. */
+export declare const recordJson: (record: StoredOutcome) => {
+    next?: string;
+    lines: string[];
+    kind?: "prune" | "came_back";
+    error?: string;
+    outcome?: CorrectionOutcome;
+    judgment: string;
+    status: "done" | "stopped" | "working";
+};
+/** The lines of the outcomes of a Method that nobody has seen yet (without the tested output), marked seen. */
+export declare function unshownLines(methodId: string): string[];
+/** Starts the fix of these corrections in its own process; tests replace it. */
+export declare const fixStarter: {
+    start(file: string, methodId: string, ids: string[], server: string, options?: {
+        prune?: boolean;
+    }): Promise<void>;
+    /** Judges the run's output against the corrections that recent fixes answered, in its own process. */
+    watch(file: string, runDir: string, server: string): void;
+};
+/**
+ * `method wait [JUDGMENT_ID] [--timeout SECONDS] [--json]`: wait for the fix of a correction (or of every correction
+ * that is being fixed on this computer) and print what it did. A wait that ends before the fix says so in one line;
+ * the fix goes on, and method wait can run again.
+ */
+export declare function waitCommand(args: string[], options?: {
+    pollMs?: number;
+}): Promise<void>;
+export declare function recordLastChange(file: string): void;
+export declare function lastChangedFile(): string | undefined;
+/** Fix state of a Method: fixes applied since the last pruning pass, and the agent that ran the last fix. */
+export type FixState = {
+    fixes_since_prune: number;
+    agent: string | null;
+};
+export declare function readFixState(methodId: string): FixState;
+export declare function writeFixState(methodId: string, state: FixState): void;
+export declare function forgetOutcome(methodId: string, id: string): void;

package/dist/packages/sdk/src/fix-outcomes.js

@@ -0,0 +1,201 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { methodCache } from './prepare.js';
+import { writePrivateJson } from './files.js';
+import { valueText } from '@withmethod/runtime/rubric.js';
+import { answerNext, errorLine, heldBackHeading, outcomeLine, stoppedLine, testedOutputHeading, workingLine } from './fix-lines.js';
+export const fixFolder = (methodId) => join(methodCache(), 'fixes', methodId);
+const outcomesDir = (methodId) => join(fixFolder(methodId), 'outcomes');
+const recordPath = (methodId, id) => join(outcomesDir(methodId), `${id}.json`);
+const read = (path) => { try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+catch {
+    return undefined;
+} };
+function write(record) {
+    mkdirSync(outcomesDir(record.method_id), { recursive: true, mode: 0o700 });
+    const path = recordPath(record.method_id, record.judgment), temporary = `${path}.${process.pid}.tmp`;
+    writePrivateJson(temporary, record);
+    renameSync(temporary, path);
+}
+/** Mark corrections as being fixed now: method wait waits for them. */
+export function markWorking(methodId, file, ids, pid) {
+    for (const id of ids)
+        write({ judgment: id, method_id: methodId, file: resolve(file), status: 'working', started_at: new Date().toISOString(), ...(pid ? { pid } : {}), shown: false });
+}
+/** The fix process that works on these corrections. */
+export function setWorker(methodId, ids, pid) {
+    for (const id of ids) {
+        const record = read(recordPath(methodId, id));
+        if (record?.status === 'working')
+            write({ ...record, pid });
+    }
+}
+export function saveOutcome(methodId, file, outcome, log) {
+    const before = read(recordPath(methodId, outcome.id));
+    write({ judgment: outcome.id, method_id: methodId, file: resolve(file), status: 'done', started_at: before?.started_at ?? new Date().toISOString(), finished_at: new Date().toISOString(), outcome, ...(log ? { log } : {}), shown: false });
+}
+export function saveError(methodId, file, id, error, log) {
+    const before = read(recordPath(methodId, id));
+    write({ judgment: id, method_id: methodId, file: resolve(file), status: 'stopped', started_at: before?.started_at ?? new Date().toISOString(), finished_at: new Date().toISOString(), error, ...(log ? { log } : {}), shown: false });
+}
+/** A line that is not about one correction (a pruning change; a fix that came back). */
+export function saveNotice(methodId, file, kind, line) {
+    const id = `${kind}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+    write({ judgment: id, method_id: methodId, file: resolve(file), status: 'done', kind, line, started_at: new Date().toISOString(), finished_at: new Date().toISOString(), shown: false });
+}
+export function storedOutcome(methodId, id) { return read(recordPath(methodId, id)); }
+const alive = (pid) => { if (!pid)
+    return true; try {
+    process.kill(pid, 0);
+    return true;
+}
+catch (error) {
+    return error.code !== 'ESRCH';
+} };
+/** Every stored record, of one Method or of all; a working record whose process stopped reads as stopped. */
+export function storedOutcomes(methodId) {
+    const root = join(methodCache(), 'fixes');
+    const methods = methodId ? [methodId] : (() => { try {
+        return readdirSync(root);
+    }
+    catch {
+        return [];
+    } })();
+    const records = [];
+    for (const id of methods) {
+        let names = [];
+        try {
+            names = readdirSync(outcomesDir(id)).filter(name => name.endsWith('.json'));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const record = read(join(outcomesDir(id), name));
+            if (!record)
+                continue;
+            records.push(record.status === 'working' && !alive(record.pid) ? { ...record, status: 'stopped' } : record);
+        }
+    }
+    return records.sort((a, b) => a.started_at.localeCompare(b.started_at));
+}
+export function markShown(record) { const now = read(recordPath(record.method_id, record.judgment)); if (now)
+    write({ ...now, shown: true }); }
+/** The lines of a record: the person's line, the tested output after a fix, and for a question the agent's next step. */
+export function recordLines(record, options = {}) {
+    if (record.line)
+        return [record.line];
+    if (record.status === 'working')
+        return [workingLine];
+    if (record.status === 'stopped')
+        return [record.error ? errorLine(record.error) : stoppedLine];
+    const o = record.outcome, lines = [outcomeLine(o)];
+    if (o.outcome === 'question')
+        lines.push(answerNext(record.judgment));
+    const shown = o.tested_output;
+    if (o.outcome === 'fixed' && shown && !options.brief) {
+        const parts = [...(shown.result !== undefined && shown.result !== null ? [clip(valueText(shown.result))] : []), ...Object.entries(shown.files ?? {}).map(([name, text]) => `${name}:\n${clip(text)}`)];
+        if (parts.length)
+            lines.push(testedOutputHeading, ...parts);
+        if (shown.held_back?.length)
+            lines.push(heldBackHeading, ...shown.held_back.map(call => clip(valueText(call.args))));
+    }
+    return lines;
+}
+const clip = (text, max = 4000) => text.length > max ? `${text.slice(0, max)}…` : text;
+/** The JSON of a record for --json: the outcome as the agent reads it, with the person's line. */
+export const recordJson = (record) => ({ judgment: record.judgment, status: record.status, ...(record.outcome ? { outcome: record.outcome } : {}), ...(record.error ? { error: record.error } : {}),
+    ...(record.kind ? { kind: record.kind } : {}), lines: recordLines(record), ...(record.outcome?.outcome === 'question' ? { next: `method answer ${record.judgment} "THEIR WORDS"` } : {}) });
+/** The lines of the outcomes of a Method that nobody has seen yet (without the tested output), marked seen. */
+export function unshownLines(methodId) {
+    const lines = [];
+    for (const record of storedOutcomes(methodId).filter(r => !r.shown && r.status !== 'working')) {
+        lines.push(...recordLines(record, { brief: true }));
+        markShown(record);
+    }
+    return lines;
+}
+/** Starts the fix of these corrections in its own process; tests replace it. */
+export const fixStarter = {
+    async start(file, methodId, ids, server, options = {}) {
+        const folder = fixFolder(methodId);
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        const out = openSync(join(folder, 'fix.log'), 'a', 0o600);
+        const suffix = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
+        const entry = fileURLToPath(new URL(`./method${suffix}`, import.meta.url));
+        const child = spawn(process.execPath, [...process.execArgv, entry, '__fix', resolve(file), '--server', server, ...ids.flatMap(id => ['--judgment', id]), ...(options.prune ? ['--prune'] : [])], { detached: true, stdio: ['ignore', out, out], cwd: process.cwd(), env: { ...process.env, METHOD_RUN_WORKER: '' } });
+        closeSync(out);
+        await new Promise((yes, no) => { child.once('spawn', yes); child.once('error', no); });
+        if (child.pid)
+            setWorker(methodId, ids, child.pid);
+        child.unref();
+    },
+    /** Judges the run's output against the corrections that recent fixes answered, in its own process. */
+    watch(file, runDir, server) {
+        try {
+            const suffix = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
+            const entry = fileURLToPath(new URL(`./method${suffix}`, import.meta.url));
+            const child = spawn(process.execPath, [...process.execArgv, entry, '__watch', resolve(file), resolve(runDir), '--server', server], { detached: true, stdio: 'ignore', cwd: process.cwd(), env: { ...process.env, METHOD_RUN_WORKER: '' } });
+            child.on('error', () => { });
+            child.unref();
+        }
+        catch { /* watching never delays or fails a run */ }
+    },
+};
+/**
+ * `method wait [JUDGMENT_ID] [--timeout SECONDS] [--json]`: wait for the fix of a correction (or of every correction
+ * that is being fixed on this computer) and print what it did. A wait that ends before the fix says so in one line;
+ * the fix goes on, and method wait can run again.
+ */
+export async function waitCommand(args, options = {}) {
+    const { parseArgs } = await import('node:util');
+    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { timeout: { type: 'string' }, json: { type: 'boolean' } } });
+    const id = positionals[0];
+    const timeout = values.timeout !== undefined ? Number(values.timeout) : 100;
+    if (!Number.isFinite(timeout) || timeout < 0)
+        throw Error('Use method wait [JUDGMENT_ID] [--timeout SECONDS].');
+    const deadline = Date.now() + timeout * 1000;
+    const chosen = () => storedOutcomes().filter(r => id ? r.judgment === id : !r.shown);
+    let records = chosen();
+    if (id && !records.length)
+        throw Error(`This computer is not fixing ${id}. Its outcome is on the run's page on the dashboard.`);
+    while (records.some(r => r.status === 'working') && Date.now() < deadline) {
+        await new Promise(done => setTimeout(done, options.pollMs ?? 500));
+        records = chosen();
+    }
+    const finished = records.filter(r => r.status !== 'working'), working = records.filter(r => r.status === 'working');
+    for (const record of finished)
+        markShown(record);
+    if (values.json) {
+        process.stdout.write(JSON.stringify({ outcomes: records.map(recordJson) }, null, 2) + '\n');
+        return;
+    }
+    const lines = finished.flatMap(record => recordLines(record));
+    if (working.length)
+        lines.push((await import('./fix-lines.js')).stillWorkingLine);
+    if (!records.length)
+        lines.push((await import('./fix-lines.js')).nothingWaitingLine);
+    process.stdout.write(lines.join('\n') + '\n');
+}
+// The global pointer to the Method file of the last change on this computer, for method undo with no file.
+const lastChangeFile = () => join(methodCache(), 'fixes', 'last-change.json');
+export function recordLastChange(file) { mkdirSync(join(methodCache(), 'fixes'), { recursive: true, mode: 0o700 }); writePrivateJson(lastChangeFile(), { file: resolve(file) }); }
+export function lastChangedFile() { try {
+    const file = JSON.parse(readFileSync(lastChangeFile(), 'utf8')).file;
+    return existsSync(file) ? file : undefined;
+}
+catch {
+    return undefined;
+} }
+export function readFixState(methodId) { try {
+    return { fixes_since_prune: 0, agent: null, ...JSON.parse(readFileSync(join(fixFolder(methodId), 'state.json'), 'utf8')) };
+}
+catch {
+    return { fixes_since_prune: 0, agent: null };
+} }
+export function writeFixState(methodId, state) { mkdirSync(fixFolder(methodId), { recursive: true, mode: 0o700 }); writeFileSync(join(fixFolder(methodId), 'state.json'), JSON.stringify(state), { mode: 0o600 }); }
+export function forgetOutcome(methodId, id) { rmSync(recordPath(methodId, id), { force: true }); }