@method-ai-hq/sdk 0.18.2 → 0.20.0

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

@@ -1,5 +1,5 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join, resolve, sep } from 'node:path';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { MethodPackageSchema, packageDigest, packagePath } from '../../contracts/src/method-package.js';
@@ -9,13 +9,62 @@ import { fileHash } from './method-files.js';
 import { methodCache } from './prepare.js';
 import { writePrivateJson } from './files.js';
 import { currentVersion, methodContent, methodIdPattern } from './versions.js';
-import { changedSteps, localRuns, saveLocalProposal, writeMethodFile } from './proposals.js';
+import { localRuns, saveLocalProposal, writeMethodFile } from './proposals.js';
+import { changedSteps } from './merge.js';
 import { localJudgments, runFolderIndex } from './local-judgments.js';
+import { fixFolder, readFixState, saveError, saveNotice, saveOutcome, setWorker, storedOutcome, writeFixState } from './fix-outcomes.js';
+import { recordChange, saveVersion, snapshot, undoLast } from './undo.js';
+import { fixUndoneLine, ruleBackLine } from './fix-lines.js';
+const outcomeKinds = ['fixed', 'no_fix_found', 'could_not_test', 'question', 'held', 'not_reproduced', 'not_fixable_here'];
+const reasons = ['missing_file', 'can_send', 'too_large', 'no_live_step'];
+const plainText = (value) => typeof value === 'string' && value.trim() ? value.trim() : undefined;
 /**
- * Read the result of improve.method: {proposal: <SubmitProposal as JSON text>, kind, proposal_id, capped}. A change has
- * the tested workflow (and a changed package file for a script change); none has no workflow.
+ * One outcome of improve.method in the form the lines read: {id, outcome, detail, reason?, question?, held_with?,
+ * learned_rule?, again?, tests?: {case, base, candidate: {passes, runs}, guards: []}, tried?}. A fixed outcome's detail
+ * says what is different now; a held outcome's detail is about the loop, so the line names only the other person.
  */
-export function readImproveResult(result) {
+export function loopOutcome(o) {
+    if (typeof o?.id !== 'string' || !outcomeKinds.includes(o.outcome))
+        throw Error('The improvement run has no outcome for each correction.');
+    const out = { id: o.id, outcome: o.outcome };
+    const detail = plainText(o.detail);
+    if (o.outcome === 'fixed') {
+        if (detail)
+            out.summary = detail;
+    }
+    else if (o.outcome !== 'held' && detail)
+        out.detail = detail;
+    if (o.outcome === 'could_not_test')
+        out.reason = reasons.includes(o.reason) ? o.reason : 'missing_file';
+    if (out.reason === 'missing_file' && typeof o.path === 'string' && o.path)
+        out.path = o.path;
+    if (o.outcome === 'question')
+        out.question = plainText(o.question) ?? 'What should the result have said instead?';
+    if (o.outcome === 'held' && plainText(o.held_with))
+        out.by = plainText(o.held_with);
+    if (typeof o.learned_rule === 'string' && o.learned_rule)
+        out.rule_added = true;
+    if (Number.isSafeInteger(o.tried) && o.tried > 0)
+        out.tried = o.tried;
+    const passes = o.tests?.candidate?.passes;
+    if (o.outcome === 'fixed' && Number.isSafeInteger(passes) && passes > 0)
+        out.tested = { times: passes, earlier: Array.isArray(o.tests?.guards) ? o.tests.guards.length : 0 };
+    if (o.again === true)
+        out.again = true;
+    // Optional words for the lines, when the loop gives them: the plain noun of what the Method works on, and the tested output.
+    if (plainText(o.subject))
+        out.subject = plainText(o.subject);
+    if (o.tested_output && typeof o.tested_output === 'object')
+        out.tested_output = o.tested_output;
+    return out;
+}
+/**
+ * Read the result of improve.method: {proposal: <SubmitProposal as JSON text>, kind, proposal_id, outcomes: <JSON text,
+ * one outcome per new correction>, background_cases: [case ids], summary: one plain line}. A change has the tested
+ * workflow and the changed package files (a script, learned.json). A pruning sweep (mode prune) has no outcomes; its
+ * summary says what it removed, and what it left because nothing checks it.
+ */
+export function readImproveResult(result, options = {}) {
     const value = result;
     if (!value || typeof value.proposal !== 'string')
         throw Error('The improvement run gave no proposal.');
@@ -35,8 +84,20 @@ export function readImproveResult(result) {
         throw Error(`The improvement run says kind ${String(value.kind)}, but its proposal is kind ${evidence.kind}.`);
     if (evidence.kind === 'change' && (!proposal.workflow || typeof proposal.workflow !== 'object'))
         throw Error('The improvement proposal is a change without a workflow.');
+    let outcomes = [];
+    if (!options.prune) {
+        try {
+            outcomes = typeof value.outcomes === 'string' ? JSON.parse(value.outcomes) : undefined;
+        }
+        catch {
+            outcomes = undefined;
+        }
+        if (!Array.isArray(outcomes))
+            throw Error('The improvement run has no outcome for each correction.');
+    }
+    const background = Array.isArray(value.background_cases) ? value.background_cases.filter((c) => typeof c === 'string' && !!c) : [];
     return { cause: proposal.cause.trim(), workflow: evidence.kind === 'change' ? proposal.workflow : null, files: Array.isArray(proposal.files) ? proposal.files : [], evidence,
-        capped: typeof value.capped === 'string' ? value.capped : '' };
+        capped: typeof value.capped === 'string' ? value.capped : '', outcomes: outcomes.map(loopOutcome), background_cases: [...new Set(background)], summary: plainText(value.summary) ?? '' };
 }
 /**
  * Download the published improve.method and its files into the Method cache, once per version. For developers of
@@ -76,11 +137,11 @@ export async function cachedImproveMethod(client) {
     return { file, root, version_id: saved.version_id };
 }
 /**
- * Run improve.method on this computer. Its model steps and its scripts' model requests follow the rule of every run:
+ * Run improve.method on this computer (mode prune: the pruning pass). Its model steps and its scripts' model requests follow the rule of every run:
  * the user's own Claude Code or Codex first, hosted models only without one. The run gets the signed-in key and server
  * as its IMPROVE_API_KEY and IMPROVE_SERVER secrets, for this run only. Its output goes to a log file.
  */
-export async function runImprovement(client, file, judgments, runFolders, run) {
+export async function runImprovement(client, file, judgments, runFolders, run, mode) {
     const token = client.token();
     if (!token)
         throw Error('Sign in with method login, then run method judge again.');
@@ -90,7 +151,7 @@ export async function runImprovement(client, file, judgments, runFolders, run) {
     const judgmentsFile = join(runDir, 'judgments.json'), inputs = join(runDir, 'improve-inputs.json'), log = join(runDir, 'improve.log');
     // The judgments with their notes go in a private file of this run; they stay on this computer.
     writePrivateJson(judgmentsFile, judgments);
-    writePrivateJson(inputs, { method_file: file, grant_id: '', judgment_id: '', judgments_file: judgmentsFile, run_folders: runFolders });
+    writePrivateJson(inputs, { method_file: file, grant_id: '', judgment_id: '', judgments_file: judgmentsFile, run_folders: runFolders, ...(mode ? { mode } : {}) });
     const runFile = run ?? (await import('./current-runtime.js')).runCurrentFile;
     // The run prints its own result and progress; they go to the log, so the person reads one line.
     const out = process.stdout.write, err = process.stderr.write;
@@ -110,52 +171,141 @@ export async function runImprovement(client, file, judgments, runFolders, run) {
     }
     if (result.status !== 'completed')
         throw Object.assign(Error(result.failure?.headline ?? `The improvement stopped with status ${result.status}.`), { log });
-    const summary = (() => { try {
-        return JSON.parse(readFileSync(join(runDir, 'run', 'summary.json'), 'utf8'));
-    }
-    catch {
-        return {};
-    } })();
-    return { ...readImproveResult(result.result), log, summary };
+    return { ...readImproveResult(result.result, { prune: mode === 'prune' }), log };
 }
 /** The ID of the regression case that a correction makes: one per judgment, so a later loop finds it. */
 export const correctionCaseId = (judgmentId) => `correction-${judgmentId.replace(/^jdg_/, '').slice(0, 12)}`;
-const caseSchema = { type: 'object', properties: { criteria: { type: 'array', items: { type: 'string', description: 'One plain sentence that a right result meets.' } } } };
+const caseSchema = { type: 'object', properties: {
+        criteria: { type: 'array', items: { type: 'object', properties: {
+                    text: { type: 'string', description: 'One plain sentence that a right result meets.' },
+                    ref: { type: 'string', description: 'The name, from "What the person saw", of the thing the sentence is about.' }
+                } } },
+        check_script: { type: 'string', description: 'A Node.js script that checks the form or the action, or an empty text.' },
+        check_says: { type: 'string', description: 'One plain sentence: what the script checks. Empty when there is no script.' },
+    } };
+const textOf = (path) => {
+    const bytes = readFileSync(path);
+    return bytes.subarray(0, 8192).includes(0) ? `[a binary file of ${bytes.length} bytes]` : bytes.toString('utf8');
+};
+/** What the person saw of a run, with the ref that a case uses for each thing (runtime 0.16.0 refs). */
+export function seenOfRun(outcome) {
+    const seen = [];
+    if (outcome.result !== undefined && outcome.result !== null)
+        seen.push({ ref: 'result', label: 'The result', value: outcome.result });
+    for (const [name, value] of Object.entries(outcome.outputs ?? {}))
+        seen.push({ ref: `outputs.${name}`, label: `The output ${name}`, value });
+    const files = [];
+    const walk = (dir, prefix) => {
+        let entries = [];
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= 20 || entry.name.startsWith('.'))
+                continue;
+            const path = join(dir, entry.name), name = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                walk(path, name);
+            else if (entry.isFile() && statSync(path).size <= 2_000_000)
+                files.push({ ref: `file:${name}`, label: `The file ${name}, which the run wrote`, value: textOf(path) });
+        }
+    };
+    if (typeof outcome.artifacts === 'string')
+        walk(outcome.artifacts, '');
+    for (const [path, copy] of Object.entries(outcome.files ?? {})) {
+        if (files.length >= 20)
+            break;
+        try {
+            if (statSync(copy).isFile())
+                files.push({ ref: `file:${path}`, label: `The file ${path}, which the run wrote`, value: textOf(copy) });
+        }
+        catch { /* the copy is gone */ }
+    }
+    seen.push(...files);
+    const calls = new Map();
+    for (const call of outcome.tool_calls ?? [])
+        calls.set(call.tool, [...(calls.get(call.tool) ?? []), call.arguments]);
+    for (const [tool, args] of calls)
+        seen.push({ ref: `effect:${tool}`, label: `The calls of ${tool} (their arguments)`, value: args });
+    for (const effect of outcome.effect_inputs ?? [])
+        seen.push({ ref: `effect:${effect.effect}`, label: `What ${effect.effect} sent or changed`, value: effect.inputs });
+    return seen;
+}
 /**
- * Make the regression case of a correction, even from vague words such as "it's not even redlined": a model writes 1 to
- * 3 plain sentences from the note and the run's result, and method case new keeps them only when they fail on the run.
- * A rule that fails nothing gets one more try with the reason. The person's words decide a conflict with an instruction.
+ * Make the regression case of a correction, even from vague words such as "it's not even redlined". A model reads what
+ * the person saw (the result, the files the run wrote, and the calls and effects it made) and writes 1 to 3 plain
+ * sentences, each about one of those things; for a note about form or a missing action, also a small check script. A
+ * sentence is kept only when it fails on the corrected run and passes on every approved run of the same part, with two
+ * judges when both Claude Code and Codex are signed in. Sentences that do not fail get one more try with the reason.
  */
-export async function caseFromCorrection(file, judgment, runDir) {
-    const id = correctionCaseId(judgment.id);
-    if (existsSync(join(dirname(file), 'cases', id, 'case.json')))
+export async function caseFromCorrection(file, judgment, runDir, options = {}) {
+    const id = correctionCaseId(judgment.id), folder = dirname(resolve(file));
+    if (existsSync(join(folder, 'cases', id, 'case.json')))
         return { id, made: false };
     const { outcomeOfRun, createCase } = await import('@withmethod/runtime/cases.js');
     const outcome = await outcomeOfRun(runDir);
+    const approved = [];
+    for (const dir of options.approvedRuns ?? []) {
+        try {
+            approved.push(await outcomeOfRun(dir));
+        }
+        catch { /* not a finished run */ }
+    }
+    const seen = seenOfRun(outcome), refs = new Set(seen.map(s => s.ref));
+    const fallback = refs.has('result') ? 'result' : seen[0]?.ref ?? 'result';
     const method = readDocument(file);
-    const ref = typeof method.result === 'string' ? method.result.split('.')[0] : undefined;
-    if (!ref)
-        throw Error('The Method has a result with several values, so the case needs an output to judge.');
-    const value = outcome.outputs?.[ref] ?? outcome.result;
-    const note = judgment.note?.trim() || 'The person marked this result wrong.';
+    const note = [judgment.note?.trim() || 'The person marked this result wrong.', judgment.answer?.trim() ? `Asked what they meant, the person answered: ${judgment.answer.trim()}` : ''].filter(Boolean).join('\n');
     const { callModel } = await import('./model-call.js');
-    const { preparedConfig } = await import('./quality.js');
+    const { preparedConfig, judgeProfiles, evaluateWithJudges } = await import('./quality.js');
     const prepared = await preparedConfig(file, {}, { judge: true });
+    const profiles = await judgeProfiles(prepared.config);
+    const runOptions = { processPath: prepared.processPath, ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) };
+    let budget = 60_000;
+    const shown = seen.map(s => { const text = clip(typeof s.value === 'string' ? s.value : JSON.stringify(s.value, null, 2), Math.max(500, Math.min(20_000, budget))); budget -= text.length; return `[${s.ref}] ${s.label}:\n${text}`; });
     const user = [`The person's correction, in their words:\n${note}`,
         judgment.corrected !== undefined && judgment.corrected !== null ? `The result the person says is right:\n${clip(typeof judgment.corrected === 'string' ? judgment.corrected : JSON.stringify(judgment.corrected, null, 2), 20_000)}` : '',
-        `The Method's goal: ${String(method.goal ?? '')}`, `The result of the run (${ref}):\n${clip(typeof value === 'string' ? value : JSON.stringify(value, null, 2), 40_000)}`].filter(Boolean).join('\n\n');
+        `The Method's goal: ${String(method.goal ?? '')}`, `What the person saw (each with its name in brackets):\n\n${shown.join('\n\n')}`].filter(Boolean).join('\n\n');
+    const system = [
+        'A person corrected the result of a run of a Method. Write 1 to 3 plain sentences that a right result of this run meets and that this result does not meet, so a later version can be checked against the correction.',
+        'The person\'s words may be vague, such as "the Ashby one\'s wrong" or "it\'s not even redlined": use what the person saw to find what they mean.',
+        'Each sentence is about one thing the person saw: give its name in brackets as ref (result, outputs.NAME, file:PATH or effect:NAME). Judge a file or a message by the file or the message itself, not by a summary of it.',
+        'Each sentence names one checkable thing, without names or numbers that only this run has unless the correction is about them. Do not ask for anything that the correction does not ask for.',
+        'When the correction is about form or a missing action (a document with no tracked changes, a message with no attachment, a message that was not sent, a missing field), also write check_script: a Node.js ES module that reads JSON from standard input with result, outputs, tool_calls (a list of {tool, arguments, standin}), effect_inputs (a list of {effect, inputs}) and files (an object: each file the run wrote, by the name in brackets after file:, mapped to an absolute path the script can read, for example a .docx to unzip), and prints {"pass": true or false, "reason": "one sentence"}. It must fail on this result, pass on a right one, and fail when the thing it checks is missing. In check_says, say in one plain sentence what it checks. Otherwise leave both empty.',
+    ].join(' ');
     let reason = '';
     for (let attempt = 0; attempt < 2; attempt++) {
-        const answer = await callModel({ schema: caseSchema, user: reason ? `${user}\n\nYour last sentences could not be used: ${reason}` : user,
-            system: 'A person corrected the result of a run of a Method. Write 1 to 3 plain sentences that a right result of this run meets and that this result does not meet, so a later version can be checked against the correction. The person\'s words may be vague, such as "the Ashby one\'s wrong" or "it\'s not even redlined": use the result to find what they mean. Each sentence names one checkable thing in the result, without names or numbers that only this run has unless the correction is about them. Do not ask for anything that the correction does not ask for.' });
-        const criteria = (Array.isArray(answer.value?.criteria) ? answer.value.criteria : []).map((c) => String(c).trim()).filter(Boolean).slice(0, 3);
-        if (!criteria.length) {
+        const answer = await callModel({ schema: caseSchema, system, user: reason ? `${user}\n\nYour last answer could not be used: ${reason}` : user });
+        const written = (Array.isArray(answer.value?.criteria) ? answer.value.criteria : [])
+            .map((c) => typeof c === 'string' ? { text: c.trim(), ref: fallback } : { text: String(c?.text ?? '').trim(), ref: refs.has(String(c?.ref ?? '').trim()) ? String(c.ref).trim() : fallback })
+            .filter((c) => c.text).slice(0, 3);
+        const script = typeof answer.value?.check_script === 'string' ? answer.value.check_script.trim() : '';
+        if (!written.length && !script) {
             reason = 'There were no sentences.';
             continue;
         }
+        // The sentences grouped by what they judge, with IDs that stay the same when the case is saved.
+        const expect = [];
+        written.forEach((c, i) => {
+            const item = expect.find(e => e.ref === c.ref) ?? (expect.push({ kind: 'rubric', ref: c.ref, criteria: [] }), expect.at(-1));
+            item.criteria.push({ id: `c${i + 1}`, text: c.text });
+        });
+        // A check script is written next to the Method file for createCase to copy into the case, then removed.
+        const entrypoint = `check-${id}.mjs`, scriptPath = join(folder, entrypoint);
+        if (script) {
+            writeFileSync(scriptPath, script + '\n', { mode: 0o600 });
+            expect.push({ kind: 'predicate', runtime: 'node', entrypoint, ...(answer.value?.check_says ? { text: String(answer.value.check_says).trim() } : {}) });
+        }
         try {
-            await createCase({ methodFile: file, runDir, id, note, rubric: criteria, ref: `outputs.${ref}`, acceptConflict: note, config: prepared.config,
-                options: { runOptions: { processPath: prepared.processPath, ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) } } });
+            const context = { caseDir: folder, config: prepared.config, options: { runOptions } };
+            const kept = await keptExpectations(expect, outcome, approved, context, profiles, evaluateWithJudges);
+            if (!kept.expect.length) {
+                reason = kept.reason;
+                continue;
+            }
+            await createCase({ methodFile: file, runDir, id, note, author: judgment.noted_by ?? null, expect: kept.expect, acceptConflict: note, config: prepared.config, options: { runOptions } });
             return { id, made: true };
         }
         catch (error) {
@@ -163,26 +313,74 @@ export async function caseFromCorrection(file, judgment, runDir) {
                 throw error;
             reason = error.message;
         }
+        finally {
+            rmSync(scriptPath, { force: true });
+        }
     }
     throw Object.assign(Error(reason), { code: 'case_not_made' });
 }
 const clip = (text, max) => text.length > max ? `${text.slice(0, max)}…` : text;
-/** The Method's judgments: the account's, with the notes that stay on this computer for a device Method. */
+/**
+ * The expectations that capture the correction: each sentence that fails on the corrected run and passes on every
+ * approved run, and the check script when it does the same. A sentence the judges disagree on does not fail and is dropped.
+ */
+async function keptExpectations(expect, bad, approved, context, profiles, judge) {
+    const onBad = await judge(expect, bad, context, profiles);
+    const onGood = await Promise.all(approved.map(outcome => judge(expect, outcome, context, profiles)));
+    const reasons = [];
+    const kept = expect.flatMap((item, i) => {
+        const badResult = onBad.results[i], goodResults = onGood.map(r => r.results[i]);
+        if (item.kind === 'predicate') {
+            if (badResult?.status !== 'fail') {
+                reasons.push('The check script passes on the corrected run.');
+                return [];
+            }
+            if (goodResults.some(r => r?.status !== 'pass')) {
+                reasons.push('The check script fails on a run the person approved.');
+                return [];
+            }
+            return [item];
+        }
+        if (badResult?.status === 'unverifiable') {
+            reasons.push(`${item.ref} is not in the corrected run.`);
+            return [];
+        }
+        const criteria = item.criteria.filter((c) => {
+            const failsBad = badResult?.criteria?.find((x) => x.id === c.id)?.pass === false && !badResult.criteria.find((x) => x.id === c.id)?.unsure;
+            if (!failsBad) {
+                reasons.push(`"${c.text}" does not fail on the corrected run.`);
+                return false;
+            }
+            if (goodResults.some(r => r?.status === 'unverifiable' || r?.criteria?.find((x) => x.id === c.id)?.pass !== true)) {
+                reasons.push(`"${c.text}" fails on a run the person approved.`);
+                return false;
+            }
+            return true;
+        });
+        return criteria.length ? [{ ...item, criteria }] : [];
+    });
+    return { expect: kept, reason: reasons.join(' ') || 'Nothing could be checked.' };
+}
+/** The Method's judgments: the account's, with the notes and answers that stay on this computer for a device Method. */
 async function methodJudgments(client, file, methodId, waitMs) {
     const { judgments } = await client.request(`/api/cli/methods/${encodeURIComponent(methodId)}/judgments`, 'GET', undefined, true, waitMs ? { signal: AbortSignal.timeout(waitMs), stallMs: waitMs } : {});
     const local = new Map(localJudgments(file).map(j => [j.id, j]));
     const folders = runFolderIndex();
     return judgments.map(j => {
         const kept = local.get(j.id);
-        return { ...j, note: j.note ?? kept?.note ?? null, corrected: j.corrected ?? kept?.corrected ?? null, run_dir: kept?.run_dir && existsSync(kept.run_dir) ? kept.run_dir : folders.get(j.run_id) };
+        return { ...j, note: j.note ?? kept?.note ?? null, corrected: j.corrected ?? kept?.corrected ?? null, answer: j.answer ?? kept?.answer ?? null,
+            run_dir: kept?.run_dir && existsSync(kept.run_dir) ? kept.run_dir : folders.get(j.run_id) };
     });
 }
-const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+/** The corrections of a Method that wait for a fix. */
+export async function waitingCorrections(client, file, methodId, waitMs) {
+    return (await methodJudgments(client, file, methodId, waitMs)).filter(j => j.pending && j.verdict === 'wrong');
+}
 /**
- * Fix the pending corrections of a Method file on this computer: the loop. Returns undefined when nothing waits. It
- * takes the pending corrections in the account first, so two computers never fix one correction twice, and gives them
- * back when the loop stops before it decides. A subscription limit or another failure of the model service is a plain
- * error.
+ * Fix the pending corrections of a Method file on this computer: one pass of the loop. Returns undefined when nothing
+ * waits. It takes the pending corrections in the account first, so two computers never fix one correction twice, and
+ * gives them back when the loop stops before it decides. Each correction gets its own outcome. A subscription limit or
+ * another failure of the model service is a plain error.
  */
 export async function fixCorrections(client, file, options = {}) {
     const document = readDocument(file);
@@ -190,28 +388,40 @@ export async function fixCorrections(client, file, options = {}) {
     if (!methodId || !client.token())
         return undefined;
     const all = await methodJudgments(client, file, methodId, options.waitMs);
-    const waiting = all.filter(j => j.pending && j.verdict === 'wrong');
+    // skip: corrections that this process opened again after a later check undid their fix; the next method run takes them.
+    const waiting = all.filter(j => j.pending && j.verdict === 'wrong' && !options.skip?.has(j.id));
     if (!waiting.length)
         return undefined;
     const handled = (ids, value) => client.request(`/api/cli/methods/${encodeURIComponent(methodId)}/judgments/handled`, 'POST', { ids, handled: value });
     const taken = new Set((await handled(waiting.map(j => j.id), true)).changed);
-    const fresh = waiting.filter(j => taken.has(j.id));
-    if (!fresh.length)
+    const claimed = waiting.filter(j => taken.has(j.id));
+    if (!claimed.length)
         return undefined;
-    const fromDashboard = fresh.filter(j => j.source === 'dashboard').length;
-    process.stderr.write(`Fixing ${basename(file)} from ${plural(fresh.length, 'correction')} on this computer. This takes a few minutes.\n`);
     const base = methodContent(document), baseVersion = await currentVersion(file).catch(() => undefined);
     let decided = false;
+    const outcomes = [];
+    const empty = { file, judgments: claimed.map(j => j.id), cause: '', steps: [], cases: { made: [], not_made: [] }, usage: null, capped: '', log: '', outcomes, background_cases: [], fixed: [] };
     try {
-        // A regression case per correction, so every later change is checked against it.
+        // A correction of a step whose text changed since its run is not fixed: the change may already answer it.
+        outcomes.push(...await changedSinceRun(client, methodId, claimed, base));
+        const fresh = claimed.filter(j => !outcomes.some(c => c.id === j.id));
+        if (!fresh.length) {
+            decided = true;
+            await reportOutcomes(client, methodId, outcomes);
+            return { ...empty, kind: 'none', applied: false };
+        }
+        process.stderr.write(`Testing fixes for ${fresh.length} correction${fresh.length === 1 ? '' : 's'} of ${file}.\n`);
+        // A regression case per correction, so every later change is checked against it; approved runs of the same step must still pass it.
         const cases = { made: [], not_made: [] };
+        const approved = all.filter(j => j.verdict === 'right' && j.run_dir);
         for (const j of fresh) {
             if (!j.run_dir) {
                 cases.not_made.push({ id: j.id, reason: 'The run is not on this computer.' });
                 continue;
             }
+            const approvedRuns = approved.filter(a => !j.step_id || !a.step_id || a.step_id === j.step_id).map(a => a.run_dir);
             try {
-                const made = await caseFromCorrection(file, j, j.run_dir);
+                const made = await caseFromCorrection(file, j, j.run_dir, { approvedRuns });
                 if (made.made)
                     cases.made.push(made.id);
             }
@@ -229,52 +439,426 @@ export async function fixCorrections(client, file, options = {}) {
             const run = !j.run_dir && (freshIds.has(j.id) || j.verdict === 'wrong') ? await client.request(`/api/workspace/runs/${encodeURIComponent(j.run_id)}`).then(r => r.run).catch(() => undefined) : undefined;
             judgments.push({ id: j.id, run_id: j.run_id, ...(j.run_dir ? { run_dir: j.run_dir } : {}), step_id: j.step_id, verdict: j.verdict, note: j.note, ...(j.corrected !== null ? { corrected: j.corrected } : {}),
                 ...(existsSync(join(dirname(file), 'cases', caseId, 'case.json')) ? { case_id: caseId } : {}), source: j.source, created_at: j.created_at, ...(freshIds.has(j.id) ? { new: true } : {}),
+                ...(j.noted_by ? { noted_by: j.noted_by } : {}), ...(j.question ? { question: j.question } : {}), ...(j.answer ? { answer: j.answer } : {}),
                 ...(run ? { run: { id: run.id, status: run.status, created_at: run.created_at, version_id: run.workflow_version_id, inspection: run.inspection } } : {}) });
         }
         const runFolders = (await localRuns(file)).map(r => r.dir);
         const improved = await runImprovement(client, file, judgments, runFolders, options.run);
         decided = true;
         const evidence = improved.evidence;
-        const earlier = (evidence.cases ?? []).filter((c) => !c.target && c.after === 'pass').length;
-        const usage = evidence.budget ?? null;
-        const used = usage ? ` (${plural(usage.model_calls, 'model call')}, ${usage.minutes < 1 ? 'under a minute' : `${Math.round(usage.minutes)} min`}${typeof usage.usd === 'number' ? `, $${usage.usd.toFixed(2)}` : ''})` : '';
-        const outcome = { file, corrections: fresh.length, from_dashboard: fromDashboard, cause: improved.cause, cases, earlier_passed: earlier, usage, capped: improved.capped, log: improved.log };
+        const fromLoop = new Map(improved.outcomes.map(o => [o.id, o]));
+        // again: another correction's fix changed the same part; this one waits for the next pass, on the changed file.
+        const decidedNow = fresh.map(j => { const o = fromLoop.get(j.id); return o?.again ? { id: j.id, outcome: 'retry', again: true } : { ...(o ?? { outcome: 'no_fix_found' }), id: j.id }; });
+        const changes = (o) => o.outcome === 'fixed' || (o.outcome === 'could_not_test' && !!o.rule_added);
+        const result = { ...empty, cause: improved.cause, cases, usage: evidence.budget ?? null, capped: improved.capped, log: improved.log, steps: evidence.steps ?? [] };
         const record = (kind, extra = {}) => saveLocalProposal(file, { id: `lp_${randomBytes(8).toString('hex')}`, method_id: methodId, base_version_id: baseVersion?.version_id ?? null,
-            status: kind, cause: improved.cause, evidence, created_at: new Date().toISOString(), base_workflow: base, proposed_workflow: improved.workflow, judgments: [...freshIds], ...extra });
-        if (evidence.kind !== 'change') {
+            status: kind, cause: improved.cause, evidence, created_at: new Date().toISOString(), base_workflow: base, proposed_workflow: improved.workflow, judgments: [...freshIds], outcomes: decidedNow, ...extra });
+        // Nothing is applied: the corrections that the change would have answered wait for the next pass.
+        const notApplied = (why) => decidedNow.map(o => why.find(h => h.id === o.id) ?? (changes(o) ? { id: o.id, outcome: 'retry' } : o));
+        // A change that passes only by breaking another person's case is held: two people want different results.
+        const held = heldBy(file, fresh.filter(j => changes(fromLoop.get(j.id) ?? { id: j.id, outcome: 'no_fix_found' })), evidence);
+        let final, applied = false, version, undoId;
+        if (held.length) {
+            record('none', { reason: 'held' });
+            final = notApplied(held);
+        }
+        else if (evidence.kind !== 'change') {
             record('none');
-            const why = improved.cause.replace(/^No safe change was found\.\s*/, '').split('\n')[0].slice(0, 300);
-            return { ...outcome, kind: 'none', steps: evidence.steps ?? [], line: `No safe change found: ${why}${used}` };
+            final = decidedNow.map(o => changes(o) ? { ...o, rule_added: false } : o);
         }
-        // The file must be the one the loop started from; a change made meanwhile is not overwritten.
-        if (!isDeepStrictEqual(methodContent(readDocument(file)), base)) {
+        else if (!isDeepStrictEqual(methodContent(readDocument(file)), base)) {
+            // The file must be the one the loop started from; a change made meanwhile is not overwritten.
             record('none', { reason: 'The file changed while Method fixed it.' });
-            return { ...outcome, kind: 'none', steps: evidence.steps ?? [], line: `No change applied: ${basename(file)} changed while Method fixed it. Run method judge again to fix it on the new file.` };
-        }
-        // The version before the change is saved too, so the Method's history has it to restore.
-        const { Outbox } = await import('./outbox.js');
-        const outbox = new Outbox(client);
-        const before = await (await import('./versions.js')).prepareVersion(client, outbox, file).catch(() => undefined);
-        const steps = applyChange(file, methodId, improved);
-        const version = await saveFixedVersion(client, outbox, file, methodId, improved.cause, before?.version_id);
-        record('applied', { applied_at: new Date().toISOString(), ...(version ? { applied_version_id: version.version_id } : {}) });
-        const changed = `Changed ${steps.length ? `step ${steps.join(', ')}` : 'its files'} of ${basename(file)}: ${improved.cause}`, undo = version ? ` ${version.undo}` : '';
-        return { ...outcome, kind: 'change', steps, version, changed: `${changed}${undo}${used}`,
-            line: `${changed} It fixes the corrected run and passes ${plural(earlier, 'earlier correction')}.${undo}${used}` };
+            final = notApplied([]);
+        }
+        else {
+            const before = snapshot(file, improved.files.map(f => f.path));
+            applyChange(file, methodId, improved);
+            const notes = fresh.filter(j => changes(decidedNow.find(o => o.id === j.id))).map(j => j.note?.trim()).filter(Boolean);
+            undoId = recordChange(file, 'fix', improved.cause, notes.length ? `the fix for "${notes.join('" and "').slice(0, 300)}"` : 'the last fix', before).id;
+            version = await saveVersion(client, file, `Method fixed it from a correction: ${improved.cause}`.slice(0, 500));
+            record('applied', { applied_at: new Date().toISOString(), ...(version ? { applied_version_id: version.version_id } : {}) });
+            final = decidedNow;
+            applied = true;
+        }
+        outcomes.push(...final);
+        const retry = outcomes.filter(o => o.outcome === 'retry').map(o => o.id);
+        if (retry.length)
+            await handled(retry, false).catch(() => undefined);
+        await reportOutcomes(client, methodId, outcomes.filter(o => o.outcome !== 'retry' && o.outcome !== 'elsewhere'));
+        const fixed = applied ? fresh.filter(j => changes(final.find(o => o.id === j.id) ?? { id: j.id, outcome: 'no_fix_found' })).map(j => ({ id: j.id, note: j.note })) : [];
+        return { ...result, kind: applied ? 'change' : 'none', applied, ...(version ? { version } : {}), background_cases: applied ? improved.background_cases : [], fixed, ...(undoId ? { undo_id: undoId } : {}) };
     }
     catch (error) {
         // Stopped before it decided: the corrections wait for the next loop.
         if (!decided)
-            await handled([...taken], false).catch(() => undefined);
-        throw error;
+            await handled([...taken].filter(id => !outcomes.some(o => o.id === id)), false).catch(() => undefined);
+        if (!decided && outcomes.length)
+            await reportOutcomes(client, methodId, outcomes);
+        throw Object.assign(error instanceof Error ? error : Error(String(error)), { judgments: [...taken] });
     }
 }
-/** Write the tested change: the Method content (its id: line kept) and a changed package file of a script change. */
+// One fix at a time per Method on this computer. A correction that arrives while a fix runs joins it: the running fix
+// takes every waiting correction in one more pass before it finishes, and writes the outcome of each correction for
+// method wait and the next method run.
+const fileMethodId = (file) => { const id = readDocument(file).id; return typeof id === 'string' && methodIdPattern.test(id) ? id : undefined; };
+/** Take the Method's lock: a file with this process ID. A lock whose process has stopped is taken over. */
+function takeLock(path) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            writeFileSync(path, JSON.stringify({ pid: process.pid }), { flag: 'wx', mode: 0o600 });
+            return true;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        let pid;
+        try {
+            pid = JSON.parse(readFileSync(path, 'utf8')).pid;
+        }
+        catch { /* written now, or gone */ }
+        if (pid === undefined) {
+            try {
+                if (Date.now() - statSync(path).mtimeMs < 10_000)
+                    return false;
+            }
+            catch {
+                continue;
+            }
+        }
+        else {
+            try {
+                process.kill(pid, 0);
+                return false;
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH')
+                    return false;
+            }
+        }
+        rmSync(path, { force: true });
+    }
+    return false;
+}
+/** Whether a fix of the Method runs on this computer now. */
+export function fixRunning(methodId) {
+    try {
+        const pid = JSON.parse(readFileSync(join(fixFolder(methodId), 'lock'), 'utf8')).pid;
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** After 5 applied fixes, or when the agent that runs the fixes changed, the loop prunes the Method. */
+const pruneEvery = 5;
+/**
+ * Fix the waiting corrections of a Method file while holding its lock, pass after pass until none waits, so the
+ * corrections that arrive during a pass join the next. Each correction's outcome is saved for method wait. After a pass
+ * that changed the file, the other cases run (improve.method's background_cases): a failure undoes that change. Then a
+ * pruning pass runs when it is due. Returns undefined when another fix of the Method holds the lock.
+ */
+export async function fixWaiting(client, file, options = {}) {
+    const methodId = fileMethodId(file);
+    if (!methodId || !client.token())
+        return [];
+    const lock = join(fixFolder(methodId), 'lock');
+    if (!takeLock(lock))
+        return undefined;
+    const fixes = [], skip = new Set();
+    try {
+        for (;;) {
+            let fix;
+            try {
+                fix = await fixCorrections(client, file, { ...options, skip });
+            }
+            catch (error) {
+                for (const id of error.judgments ?? [])
+                    saveError(methodId, file, id, error.message, error.log);
+                throw error;
+            }
+            if (!fix)
+                break;
+            // A correction given back with again stays "working": the next pass fixes it on the changed file.
+            for (const outcome of fix.outcomes)
+                if (!outcome.again)
+                    saveOutcome(methodId, file, outcome, fix.log);
+            fixes.push(fix);
+            if (fix.applied && fix.background_cases.length) {
+                const checked = await checkBackground(client, file, fix, options).catch(error => { process.stderr.write(`The later check stopped: ${error.message}\n`); return undefined; });
+                for (const id of checked?.reopened ?? [])
+                    skip.add(id);
+            }
+        }
+        const { localAgent } = await import('@withmethod/runtime/agents.js');
+        const state = readFixState(methodId), agent = (await localAgent().catch(() => undefined)) ?? null;
+        // Every 5 corrections that a change answered, the loop prunes the Method.
+        const count = state.fixes_since_prune + fixes.filter(f => f.applied).reduce((n, f) => n + f.fixed.length, 0);
+        const due = count >= pruneEvery || (!!fixes.length && !!state.agent && !!agent && agent !== state.agent);
+        writeFixState(methodId, { fixes_since_prune: due ? 0 : count, agent: fixes.length ? agent : state.agent });
+        if (due)
+            await pruneMethod(client, file, options).catch(error => process.stderr.write(`The pruning pass stopped: ${error.message}\n`));
+        return fixes;
+    }
+    finally {
+        rmSync(lock, { force: true });
+    }
+}
+/**
+ * The later check of an applied change: the Method's other cases (improve.method's background_cases) run on the changed
+ * file. A failing case that belongs to a retired learned rule (its from.case) brings that rule back. Any other failure
+ * undoes the change, saves the restored file as a new version, and opens the corrections it answered again, so the next
+ * method run fixes them anew. Each of these says one line on the next method run or method wait.
+ */
+export async function checkBackground(client, file, fix, options = {}) {
+    const methodId = fileMethodId(file);
+    const { listCases } = await import('@withmethod/runtime/cases.js');
+    const active = new Set((await listCases(file)).filter((c) => c.status === 'active').map((c) => c.id));
+    const ids = fix.background_cases.filter(id => active.has(id));
+    const done = { failed: [], restored: [], undone: false, reopened: [] };
+    if (!ids.length)
+        return done;
+    const run = options.runCases ?? (await import('./quality.js')).runCases;
+    const report = await run(file, {}, { ids });
+    done.failed = report.cases.filter(c => c.verdict === 'fail' || c.verdict === 'regression').map(c => c.id);
+    if (!done.failed.length)
+        return done;
+    const { readLearned, learnedFile, ruleText } = await import('./learned.js');
+    const ruleCases = new Set();
+    try {
+        for (const rules of Object.values(readLearned(file).steps))
+            for (const r of rules)
+                if (r.status === 'retired' && r.from?.case)
+                    ruleCases.add(r.from.case);
+    }
+    catch { /* no readable learned rules */ }
+    const broken = done.failed.filter(id => !ruleCases.has(id));
+    if (broken.length && fix.undo_id) {
+        try {
+            undoLast(file, fix.undo_id);
+            done.undone = true;
+        }
+        catch (error) {
+            process.stderr.write(`The fix broke an earlier result, but it could not be undone: ${error.message}\n`);
+        }
+        if (done.undone) {
+            await saveVersion(client, file, `Undid a fix that broke an earlier result: ${fix.cause}`.slice(0, 500));
+            const answered = fix.fixed.map(f => f.id);
+            if (answered.length) {
+                try {
+                    done.reopened = (await client.request(`/api/cli/methods/${encodeURIComponent(methodId)}/judgments/reopen`, 'POST', { ids: answered, detail: 'The fix changed a result that was right before, so it was undone. Method will fix it again.' })).changed;
+                }
+                catch (error) {
+                    process.stderr.write(`The account did not open the corrections again: ${error.message}\n`);
+                }
+            }
+            for (const f of fix.fixed)
+                saveNotice(methodId, file, 'came_back', fixUndoneLine(f.note ?? undefined));
+        }
+    }
+    // A retired rule whose case fails again comes back (after the undo, which may have restored learned.json).
+    const restoredRules = [];
+    const learned = (() => { try {
+        return readLearned(file);
+    }
+    catch {
+        return undefined;
+    } })();
+    if (learned) {
+        const before = snapshot(file, ['learned.json']);
+        for (const rules of Object.values(learned.steps))
+            for (const rule of rules) {
+                if (rule.status !== 'retired' || !rule.from?.case || !done.failed.includes(rule.from.case))
+                    continue;
+                Object.assign(rule, { status: 'active', retired_at: null, retired_reason: null });
+                done.restored.push(rule.id);
+                restoredRules.push(ruleText(rule));
+            }
+        if (done.restored.length) {
+            writeFileSync(learnedFile(file), JSON.stringify(learned, null, 2) + '\n');
+            recordChange(file, 'learned', `Put back ${done.restored.length} learned rule${done.restored.length === 1 ? '' : 's'}`, 'the rules that came back', before);
+            await saveVersion(client, file, `Put back learned rules whose problem came back: ${restoredRules.join(' ')}`.slice(0, 500));
+            for (const rule of restoredRules)
+                saveNotice(methodId, file, 'came_back', ruleBackLine(rule));
+        }
+    }
+    return done;
+}
+/**
+ * The pruning pass (improve.method with mode prune): it retires learned rules and deletes prompt text that tests show
+ * no longer change any result, and reports text that no test covers without deleting it. The change applies at once,
+ * with undo; the next method run or method wait shows the sweep's summary line.
+ */
+export async function pruneMethod(client, file, options = {}) {
+    const methodId = fileMethodId(file);
+    if (!methodId || !client.token())
+        return undefined;
+    const base = methodContent(readDocument(file));
+    const all = await methodJudgments(client, file, methodId);
+    const judgments = all.map(j => ({ id: j.id, run_id: j.run_id, ...(j.run_dir ? { run_dir: j.run_dir } : {}), step_id: j.step_id, verdict: j.verdict, note: j.note,
+        ...(existsSync(join(dirname(file), 'cases', correctionCaseId(j.id), 'case.json')) ? { case_id: correctionCaseId(j.id) } : {}), source: j.source, created_at: j.created_at,
+        ...(j.noted_by ? { noted_by: j.noted_by } : {}) }));
+    const improved = await runImprovement(client, file, judgments, (await localRuns(file)).map(r => r.dir), options.run, 'prune');
+    const { prunedLine } = await import('./fix-lines.js');
+    if (improved.evidence.kind !== 'change') {
+        // Nothing removed; the summary can still say which instructions nothing checks.
+        if (improved.summary)
+            saveNotice(methodId, file, 'prune', improved.summary);
+        return { changed: false };
+    }
+    if (!isDeepStrictEqual(methodContent(readDocument(file)), base))
+        return { changed: false };
+    const before = snapshot(file, improved.files.map(f => f.path));
+    applyChange(file, methodId, improved);
+    recordChange(file, 'prune', improved.cause, 'the cleanup of rules and instructions that no longer changed any result', before);
+    await saveVersion(client, file, `Method removed what no longer changed any result: ${improved.cause}`.slice(0, 500));
+    if (improved.summary)
+        saveNotice(methodId, file, 'prune', prunedLine(improved.summary));
+    return { changed: true };
+}
+/**
+ * Fix the Method for one correction: run the fix, or, when a fix of the Method already runs on this computer, wait for
+ * the fix that takes this correction. Returns the stored outcome, or undefined when no fix here took it.
+ */
+export async function fixCorrection(client, file, judgmentId, options = {}) {
+    const methodId = fileMethodId(file);
+    if (!methodId || !client.token())
+        return undefined;
+    const done = () => { const record = storedOutcome(methodId, judgmentId); return record && record.status !== 'working' ? record : undefined; };
+    for (;;) {
+        const saved = done();
+        if (saved)
+            return saved;
+        const ran = await fixWaiting(client, file, options);
+        if (ran)
+            return done();
+        await new Promise(wait => setTimeout(wait, options.pollMs ?? 500));
+    }
+}
+/**
+ * `method __fix FILE --judgment ID... [--prune]`: the fix of method judge, method answer and method run, in its own
+ * process. Every correction it was started for ends with a stored outcome or error.
+ */
+export async function backgroundFix(client, file, ids, options = {}) {
+    const methodId = fileMethodId(file);
+    if (!methodId)
+        return;
+    setWorker(methodId, ids, process.pid);
+    if (options.prune) {
+        const lock = join(fixFolder(methodId), 'lock');
+        while (!takeLock(lock))
+            await new Promise(wait => setTimeout(wait, options.pollMs ?? 500));
+        try {
+            await pruneMethod(client, file, options);
+        }
+        finally {
+            rmSync(lock, { force: true });
+        }
+    }
+    for (const id of ids) {
+        try {
+            if (!await fixCorrection(client, file, id, options))
+                saveOutcome(methodId, file, { id, outcome: 'elsewhere' });
+        }
+        catch (error) {
+            if (storedOutcome(methodId, id)?.status === 'working')
+                saveError(methodId, file, id, error.message, error.log);
+        }
+    }
+}
+/** Send what the loop did with each correction, with the reason or the question. */
+async function reportOutcomes(client, methodId, outcomes) {
+    if (!outcomes.length)
+        return;
+    try {
+        await client.request(`/api/cli/methods/${encodeURIComponent(methodId)}/judgments/outcomes`, 'POST', { outcomes: outcomes.map(o => {
+                const detail = o.outcome === 'held' ? [o.by ?? 'Someone', o.detail].filter(Boolean).join(': ') : o.outcome === 'already_changed' ? (o.by ? `${o.by} changed it after this run.` : undefined) : o.summary ?? o.detail;
+                return { id: o.id, outcome: o.outcome, ...(o.outcome === 'could_not_test' && o.reason ? { reason: o.reason } : {}), ...(o.outcome === 'question' && o.question ? { question: o.question.slice(0, 1000) } : {}),
+                    ...(detail?.trim() ? { detail: detail.trim().slice(0, 500) } : {}) };
+            }) });
+    }
+    catch (error) {
+        process.stderr.write(`The account did not record what happened to the corrections: ${error.message}\n`);
+    }
+}
+/** The version that a judged run ran: from its run folder here, else from its account record. */
+async function runVersion(client, j) {
+    if (j.run_dir) {
+        try {
+            const sync = JSON.parse(readFileSync(join(j.run_dir, 'method-sync.json'), 'utf8'));
+            if (typeof sync.version_id === 'string')
+                return sync.version_id;
+        }
+        catch { /* no account link */ }
+    }
+    try {
+        return (await client.request(`/api/workspace/runs/${encodeURIComponent(j.run_id)}`)).run?.workflow_version_id;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The corrections of a step whose text in the run's version differs from the file: outcome already_changed, with the
+ * person who saved the newest version when that version has the file's text of the step.
+ */
+async function changedSinceRun(client, methodId, judgments, current) {
+    const changed = [], versions = new Map();
+    let file;
+    try {
+        file = loadWorkflow(current);
+    }
+    catch {
+        return changed;
+    }
+    const saved = (version) => {
+        const key = version ?? '';
+        if (!versions.has(key))
+            versions.set(key, client.request(`/api/cli/methods/${encodeURIComponent(methodId)}${version ? `?version=${encodeURIComponent(version)}` : ''}`).catch(() => undefined));
+        return versions.get(key);
+    };
+    for (const j of judgments) {
+        if (!j.step_id || !Object.hasOwn(file.steps ?? {}, j.step_id))
+            continue;
+        const version = await runVersion(client, j), ran = version ? await saved(version) : undefined;
+        if (!ran?.workflow?.steps || isDeepStrictEqual(ran.workflow.steps[j.step_id], file.steps[j.step_id]))
+            continue;
+        const newest = await saved();
+        const by = newest?.saved_by && isDeepStrictEqual(newest.workflow?.steps?.[j.step_id], file.steps[j.step_id]) ? newest.saved_by : undefined;
+        changed.push({ id: j.id, outcome: 'already_changed', ...(by ? { by } : {}) });
+    }
+    return changed;
+}
+/**
+ * The corrections whose tested change breaks a case that another person made (a case that passed before and fails
+ * after), with the other person and what they asked for. A case or a correction with no name is not held.
+ */
+function heldBy(file, fresh, evidence) {
+    const broken = (Array.isArray(evidence?.cases) ? evidence.cases : []).filter((c) => !c.target && c.before === 'pass' && c.after !== 'pass').map((c) => {
+        try {
+            const made = JSON.parse(readFileSync(join(dirname(file), 'cases', c.id, 'case.json'), 'utf8'));
+            return { author: made.author, note: String(made.note ?? '') };
+        }
+        catch {
+            return undefined;
+        }
+    }).filter((c) => c?.author);
+    return fresh.flatMap(j => {
+        const other = j.noted_by ? broken.find((c) => c.author !== j.noted_by) : undefined;
+        return other ? [{ id: j.id, outcome: 'held', by: other.author, detail: other.note.slice(0, 200) }] : [];
+    });
+}
+/** Write the tested change: the Method content (its id: line kept) and the changed package files (a script, learned.json). */
 function applyChange(file, methodId, improved) {
     const before = methodContent(readDocument(file));
-    loadWorkflow(improved.workflow);
-    if (!isDeepStrictEqual(improved.workflow, before))
-        writeMethodFile(file, methodId, improved.workflow);
+    if (improved.workflow) {
+        loadWorkflow(improved.workflow);
+        if (!isDeepStrictEqual(improved.workflow, before))
+            writeMethodFile(file, methodId, improved.workflow);
+    }
     const folder = dirname(resolve(file));
     for (const changed of improved.files) {
         const path = resolve(folder, packagePath(changed.path));
@@ -283,32 +867,8 @@ function applyChange(file, methodId, improved) {
         const bytes = Buffer.from(changed.content_base64, 'base64');
         if (fileHash(bytes) !== changed.sha256)
             throw Error(`The changed file ${changed.path} does not match its sha256.`);
+        mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, bytes);
     }
-    return changedSteps(before, improved.workflow);
-}
-/**
- * Save the fixed file as a new version of the Method, with the cause as its reason. The version before stays in the
- * Method's history: restoring it on the Method page undoes the change.
- */
-async function saveFixedVersion(client, outbox, file, methodId, cause, previous) {
-    try {
-        const { savedVersions } = await import('./outbox.js');
-        const { prepareVersion } = await import('./versions.js');
-        const version = await prepareVersion(client, outbox, file, `Method fixed it from a correction: ${cause}`.slice(0, 500));
-        await outbox.drain();
-        if (!await outbox.whenSaved(version.version_id))
-            return undefined;
-        const number = previous && await outbox.whenSaved(previous) ? savedVersions(client.server)[previous]?.version_number : undefined;
-        const undo = previous && number ? `To undo it, restore version ${number}: ${client.server}/methods/${methodId}?version=${previous}` : 'The version before it is in its history on the Method page.';
-        return { version_id: version.version_id, url: version.url, undo };
-    }
-    catch {
-        return undefined;
-    }
-}
-/** The one line for corrections that waited, printed before method run or method judge goes on. */
-export function waitingLine(outcome) {
-    const what = outcome.from_dashboard === outcome.corrections ? `${plural(outcome.corrections, 'correction')} from the dashboard` : plural(outcome.corrections, 'correction');
-    return outcome.kind === 'change' ? `${what}: fixed, passes ${plural(outcome.earlier_passed, 'earlier correction')}. ${outcome.changed}` : `${what}: ${outcome.line}`;
+    return improved.workflow ? changedSteps(before, improved.workflow) : [];
 }