@method-ai-hq/sdk 0.18.2 → 0.20.0

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

@@ -1,46 +1,50 @@
 /**
  * Each Method has one home file on this computer: the file its versions are saved from. A copy in a temporary folder,
  * or in another folder while the home file still exists, is not saved, so one Method never grows two histories.
- * Git worktrees and clones of one repository share a home. The home record also holds what the last save or checkout
- * wrote, so an unchanged home file can take a newer version from the account.
+ * Git worktrees and clones of one repository share a home.
  */
 export type Home = {
     path: string;
     key: string;
-    version_id?: string;
-    files?: Record<string, string>;
 };
 export declare function readHome(server: string, methodId: string): Home | undefined;
 export declare const temporary: (path: string) => boolean;
 /** The same file in every checkout of one repository has the same key. */
 export declare function homeKey(file: string): string;
-/** What a save or checkout wrote: the Method file and each package file, by hash. */
-export declare function writtenFiles(file: string, packageFiles: Array<{
-    path: string;
-    sha256: string;
-}>): {
-    [x: string]: string;
-};
-export declare function recordHome(server: string, methodId: string, file: string, version?: {
-    version_id: string;
-    files: Record<string, string>;
-}): void;
+export declare function recordHome(server: string, methodId: string, file: string): void;
 /**
  * Throws, with the home file named, when this file may not save the Method. Otherwise this file is the home after
  * the call. A home that is gone, holds another Method, or is a temporary copy gives way to a file outside a
  * temporary folder.
  */
 export declare function claimHome(server: string, methodId: string, file: string): void;
-/** True when every file that the last save or checkout wrote is still unchanged in the home folder. */
-export declare function unchangedSinceSave(home: Home): boolean;
+type Client = Pick<import('./method-client.js').MethodClient, 'server' | 'token' | 'request' | 'transfer'>;
+/** Both texts of one part that this computer and a teammate changed in different ways. */
+export type CombineConflict = {
+    part: string;
+    file: string;
+    yours: unknown;
+    theirs: unknown;
+};
+export type CatchUp = {
+    status: 'skipped' | 'current';
+} | {
+    status: 'offline' | 'updated';
+    line: string;
+} | {
+    status: 'conflict';
+    result: {
+        status: 'needs_you';
+        failure: import('../../workflow-language/src/inspection.js').RunFailure;
+        conflicts: CombineConflict[];
+    };
+};
 /**
- * Before a run of the home file: when nothing in it changed since the last save or checkout on this computer and the
- * account has a newer version (saved from another computer or folder), write that version here first. Says nothing;
- * any problem leaves the files as they are.
+ * Before a run, a fix or a publish of a Method file: bring the file to the newest version of its Method. base is the
+ * version this computer last saved or got, ours the file, theirs the newest version. An unchanged file takes theirs;
+ * a changed one combines step by step and file by file (an empty base when this computer has none). A part that both
+ * sides changed in different ways is a conflict: nothing changes, and the result has both texts. Offline, the file
+ * runs as it is. Signed out, a file with no id: line, or a Method with no version yet: nothing.
  */
-export declare function followAccount(client: {
-    server: string;
-    token(): string | null | undefined;
-    request<T>(path: string): Promise<T>;
-    transfer(path: string): Promise<Uint8Array>;
-}, file: string): Promise<boolean>;
+export declare function catchUp(client: Client, file: string, doing?: string): Promise<CatchUp>;
+export {};

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

@@ -43,13 +43,8 @@ export function homeKey(file) {
     const path = real(authoringPath(file)), repo = repository(path);
     return repo ? `${repo.main}:${relative(repo.root, path)}` : path;
 }
-/** What a save or checkout wrote: the Method file and each package file, by hash. */
-export function writtenFiles(file, packageFiles) {
-    const path = authoringPath(file);
-    return { [relative(dirname(path), path)]: fileHash(readFileSync(path)), ...Object.fromEntries(packageFiles.map(f => [f.path, f.sha256])) };
-}
-export function recordHome(server, methodId, file, version) {
-    writePrivateJson(homeFile(server, methodId), { path: authoringPath(file), key: homeKey(file), ...version });
+export function recordHome(server, methodId, file) {
+    writePrivateJson(homeFile(server, methodId), { path: authoringPath(file), key: homeKey(file) });
 }
 /**
  * Throws, with the home file named, when this file may not save the Method. Otherwise this file is the home after
@@ -60,7 +55,7 @@ export function claimHome(server, methodId, file) {
     const home = readHome(server, methodId), key = homeKey(file);
     if (home && home.key === key) {
         if (home.path !== authoringPath(file))
-            recordHome(server, methodId, file, home.version_id ? { version_id: home.version_id, files: home.files ?? {} } : undefined);
+            recordHome(server, methodId, file);
         return;
     }
     const homeLives = (() => { try {
@@ -73,65 +68,174 @@ export function claimHome(server, methodId, file) {
         throw Object.assign(Error(`This Method is saved from ${home.path}. Make the change in that file and run it there; this copy was not run or saved.`), { code: 'other_home', home: home.path });
     recordHome(server, methodId, file);
 }
-/** True when every file that the last save or checkout wrote is still unchanged in the home folder. */
-export function unchangedSinceSave(home) {
-    if (!home.version_id || !home.files)
-        return false;
-    const root = dirname(home.path);
-    return Object.entries(home.files).every(([name, hash]) => { try {
-        return fileHash(readFileSync(join(root, name))) === hash;
-    }
-    catch {
-        return false;
-    } });
-}
+const list = (word, items) => items.length ? `${word}${items.length === 1 ? '' : 's'} ${items.join(', ')}` : '';
+const parts = (steps, files) => [list('step', steps), list('file', files)].filter(Boolean).join(' and ');
+const clock = (at) => { const date = at ? new Date(at) : undefined; return date && !isNaN(+date) ? ` from ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}` : ''; };
+const clip = (text) => text.length > 20_000 ? `${text.slice(0, 20_000)}…` : text;
+const unreachable = (error) => error?.code === 'network' || error?.code === 'stalled' || error?.name === 'TimeoutError' || error?.name === 'AbortError' || error?.status >= 500 || error?.status === 429;
 /**
- * Before a run of the home file: when nothing in it changed since the last save or checkout on this computer and the
- * account has a newer version (saved from another computer or folder), write that version here first. Says nothing;
- * any problem leaves the files as they are.
+ * Before a run, a fix or a publish of a Method file: bring the file to the newest version of its Method. base is the
+ * version this computer last saved or got, ours the file, theirs the newest version. An unchanged file takes theirs;
+ * a changed one combines step by step and file by file (an empty base when this computer has none). A part that both
+ * sides changed in different ways is a conflict: nothing changes, and the result has both texts. Offline, the file
+ * runs as it is. Signed out, a file with no id: line, or a Method with no version yet: nothing.
  */
-export async function followAccount(client, file) {
-    const path = authoringPath(file);
+export async function catchUp(client, file, doing = 'running') {
+    const path = authoringPath(file), root = dirname(path);
+    const { methodContent, methodIdPattern, versionIdFor } = await import('./versions.js');
+    let document;
+    try {
+        document = readDocument(path);
+        if (typeof document.id !== 'string' || !methodIdPattern.test(document.id) || !client.token())
+            return { status: 'skipped' };
+    }
+    catch {
+        return { status: 'skipped' };
+    }
+    const id = document.id, options = { signal: AbortSignal.timeout(5000), stallMs: 5000 };
+    const methodPath = `/api/cli/methods/${encodeURIComponent(id)}`;
+    const { lastSaved, recordCheckout } = await import('./outbox.js');
+    const record = lastSaved(client.server, id);
+    // merge_base: the newest version that the server has as an ancestor of both this computer's version and the newest one.
+    let theirs;
+    try {
+        theirs = await client.request(record?.version_id ? `${methodPath}?base=${encodeURIComponent(record.version_id)}` : methodPath, 'GET', undefined, true, options);
+    }
+    catch (error) {
+        return unreachable(error) ? { status: 'offline', line: `Could not check for a newer version; ${doing} this file.` } : { status: 'skipped' };
+    }
+    const { loadWorkflow } = await import('../../workflow-language/src/validate.js');
+    const { buildPackage } = await import('./method-files.js');
+    // A file that does not load fails its run with its own error.
+    let ours;
     try {
-        const id = (await import('./authoring.js')).readDocument(path).id;
-        if (typeof id !== 'string' || !client.token())
-            return false;
-        const home = readHome(client.server, id);
-        if (!home || home.key !== homeKey(path) || !unchangedSinceSave(home))
-            return false;
-        const latest = await client.request(`/api/cli/methods/${encodeURIComponent(id)}`);
-        if (!latest?.version_id || latest.version_id === home.version_id)
-            return false;
-        const { mkdtempSync, rmSync, copyFileSync, mkdirSync } = await import('node:fs');
-        const { restorePackage } = await import('./method-files.js');
-        const staging = mkdtempSync(join(methodCache(), 'follow-'));
+        const workflow = loadWorkflow(methodContent(document)), { pack } = await buildPackage(path, workflow);
+        ours = { workflow, files: pack.files, version_id: versionIdFor(id, pack.digest) };
+    }
+    catch {
+        return { status: 'skipped' };
+    }
+    const savedBy = theirs.saved_by ?? null;
+    if (ours.version_id === theirs.version_id) {
+        if (record?.version_id !== theirs.version_id)
+            recordCheckout(client.server, id, theirs.version_id, theirs.version_number, theirs.workflow, { saved_by: savedBy });
+        return { status: 'current' };
+    }
+    if (record?.version_id === theirs.version_id)
+        return { status: 'current' };
+    let base = { workflow: {}, files: [] };
+    // An older server sends no merge_base: then the version this computer last saved or got is the base.
+    const baseId = theirs.merge_base !== undefined ? theirs.merge_base : record?.version_id;
+    // This computer's version was kept beside the newest one (an earlier CLI recorded it as its last save): it is combined now.
+    const beside = record?.version_id && baseId !== record.version_id ? record.version_id : undefined;
+    if (record?.version_id && baseId) {
         try {
-            await restorePackage(latest, staging, client);
-            const root = dirname(path), incoming = latest.package?.files ?? [];
-            // A local file that the last save did not write, and that differs, is the user's: then nothing changes.
-            for (const f of incoming) {
-                const local = join(root, f.path);
-                if (existsSync(local) && !home.files?.[f.path] && fileHash(readFileSync(local)) !== f.sha256)
-                    return false;
-            }
-            for (const f of incoming) {
-                mkdirSync(dirname(join(root, f.path)), { recursive: true, mode: 0o700 });
-                copyFileSync(join(staging, f.path), join(root, f.path));
-            }
+            const saved = await client.request(`${methodPath}?version=${encodeURIComponent(baseId)}`, 'GET', undefined, true, options);
+            base = { workflow: saved.workflow, files: saved.package?.files ?? [] };
         }
-        finally {
-            rmSync(staging, { recursive: true, force: true });
+        catch (error) {
+            if (unreachable(error))
+                return { status: 'offline', line: `Could not check for a newer version; ${doing} this file.` };
+            base = { workflow: record.workflow ?? {}, files: [] };
         }
-        const { writeDocument } = await import('./authoring.js');
-        const { methodContent, writeMethodId } = await import('./versions.js');
-        writeDocument(path, methodContent(latest.workflow));
-        (await import('./legacy.js')).convertLegacy(path);
-        writeMethodId(path, id);
-        (await import('./outbox.js')).recordCheckout(client.server, id, latest.version_id, latest.version_number, methodContent(latest.workflow));
-        recordHome(client.server, id, path, { version_id: latest.version_id, files: writtenFiles(path, latest.package?.files ?? []) });
-        return true;
+    }
+    const { mergeMethod, mergeFiles, changedSteps } = await import('./merge.js');
+    const theirFiles = theirs.package?.files ?? [];
+    const steps = mergeMethod(base.workflow, ours.workflow, theirs.workflow), files = mergeFiles(base.files, ours.files, theirFiles);
+    const ourHashes = new Map(ours.files.map(f => [f.path, f.sha256]));
+    // Files that come from theirs. A file here that no save wrote and that differs is the person's own: a conflict too.
+    const incoming = files.files.filter(f => ourHashes.get(f.path) !== f.sha256);
+    const local = (name) => { try {
+        return fileHash(readFileSync(join(root, name)));
     }
     catch {
-        return false;
+        return undefined;
+    } };
+    const { isDeepStrictEqual } = await import('node:util');
+    // After a combine stopped, a part whose text changed on this computer since then is combined by the person: theirs is used.
+    const stop = record?.conflict?.theirs === theirs.version_id ? record.conflict : undefined;
+    const combinedStep = (at, now) => !!stop && at in stop.parts && !isDeepStrictEqual(now, stop.parts[at]);
+    const combinedFile = (at) => !!stop && at in stop.files && (local(at) ?? null) !== stop.files[at];
+    const fileConflicts = [...files.conflicts.map(c => c.path), ...incoming.filter(f => !ourHashes.has(f.path) && local(f.path) !== undefined && local(f.path) !== f.sha256).map(f => f.path)];
+    const stepConflicts = steps.clean ? [] : steps.conflicts;
+    const openSteps = stepConflicts.filter(c => !combinedStep(c.path, c.ours)), openFiles = fileConflicts.filter(at => !combinedFile(at));
+    const keepLocal = new Set(fileConflicts.filter(combinedFile));
+    const take = incoming.filter(f => !keepLocal.has(f.path));
+    const download = async (f) => {
+        const bytes = await client.transfer(`${methodPath}/files/${f.sha256}?version=${encodeURIComponent(theirs.version_id)}`);
+        if (fileHash(bytes) !== f.sha256)
+            throw Error(`The newer version's file ${f.path} does not match its checksum.`);
+        return bytes;
+    };
+    const who = savedBy ?? 'A teammate', name = relative(root, path);
+    if (openSteps.length || openFiles.length) {
+        // Remember this computer's text of each part, so that the next run sees which parts the person combined.
+        const { recordCombineStop } = await import('./outbox.js');
+        recordCombineStop(client.server, id, {
+            theirs: theirs.version_id,
+            parts: Object.fromEntries(stepConflicts.map(c => [c.path, combinedStep(c.path, c.ours) ? stop.parts[c.path] : c.ours])),
+            files: Object.fromEntries(fileConflicts.map(at => [at, combinedFile(at) ? stop.files[at] : local(at) ?? null])),
+        });
+        const conflicts = [];
+        for (const c of openSteps)
+            conflicts.push({ part: c.path.replace(/^steps\./, 'step '), file: name, yours: c.ours, theirs: c.theirs });
+        for (const at of openFiles) {
+            const theirFile = theirFiles.find(f => f.path === at);
+            const text = async () => { try {
+                return clip(Buffer.from(await download(theirFile)).toString('utf8'));
+            }
+            catch (error) {
+                return `(not read: ${error.message})`;
+            } };
+            conflicts.push({ part: `file ${at}`, file: at, yours: (() => { try {
+                    return clip(readFileSync(join(root, at), 'utf8'));
+                }
+                catch {
+                    return null;
+                } })(), theirs: theirFile ? await text() : null });
+        }
+        const where = [...new Set(conflicts.map(c => c.file))];
+        const headline = `${who} also changed ${conflicts.map(c => c.part).join(', ')}. Combine the two texts in ${where.join(' and ')}, then run again.`;
+        return { status: 'conflict', result: { status: 'needs_you', failure: combineFailure(headline, conflicts, who), conflicts } };
     }
+    try {
+        loadWorkflow(steps.workflow);
+    }
+    catch (error) {
+        const headline = `Your changes and ${savedBy ? `${savedBy}'s` : 'the newest'} version combine into a Method that does not load: ${error.message} Combine them in ${name} by hand, then run again.`;
+        return { status: 'conflict', result: { status: 'needs_you', failure: combineFailure(headline, [], who), conflicts: [] } };
+    }
+    // Every file is read before any file changes, so a failed download changes nothing.
+    let written;
+    try {
+        written = await Promise.all(take.map(async (f) => ({ path: f.path, bytes: await download(f) })));
+    }
+    catch (error) {
+        return unreachable(error) ? { status: 'offline', line: `Could not check for a newer version; ${doing} this file.` } : { status: 'skipped' };
+    }
+    const { mkdirSync, renameSync, writeFileSync } = await import('node:fs');
+    const { packagePath } = await import('../../contracts/src/method-package.js');
+    for (const f of written) {
+        const target = resolve(root, packagePath(f.path));
+        mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+        writeFileSync(`${target}.download`, f.bytes, { mode: 0o600 });
+        renameSync(`${target}.download`, target);
+    }
+    if (!isDeepStrictEqual(steps.workflow, ours.workflow))
+        (await import('./proposals.js')).writeMethodFile(path, id, steps.workflow);
+    (await import('./legacy.js')).convertLegacy(path);
+    const fileChanges = (from, to) => [...new Set([...from, ...to].map(f => f.path))].filter(at => from.find(f => f.path === at)?.sha256 !== to.find(f => f.path === at)?.sha256);
+    const yours = parts(changedSteps(base.workflow, ours.workflow), fileChanges(base.files, ours.files));
+    const kept = !isDeepStrictEqual(ours.workflow, base.workflow) || fileChanges(base.files, ours.files).length > 0;
+    // theirs is the parent of the next save; a side version of this computer that the file now combines goes with it.
+    recordCheckout(client.server, id, theirs.version_id, theirs.version_number, theirs.workflow, { saved_by: savedBy, ...(kept && (record?.side_version_id ?? beside) ? { merged_version_id: (record?.side_version_id ?? beside) } : {}) });
+    const changed = parts(changedSteps(base.workflow, theirs.workflow), fileChanges(base.files, theirFiles));
+    return { status: 'updated', line: `Updated to ${savedBy ? `${savedBy}'s` : 'the newest'} version${clock(theirs.saved_at)}${changed ? ` (changed ${changed})` : ''}.${kept ? ` Your changes${yours ? ` to ${yours}` : ''} are kept.` : ''}` };
+}
+/** The failure record of a combine that needs the person: needs_you, with both texts of each part as evidence. */
+function combineFailure(headline, conflicts, who) {
+    const text = (value) => typeof value === 'string' ? value : JSON.stringify(value);
+    return { owner: 'needs_you', code: 'combine_versions', headline, step: null, step_name: null, iteration: null, failed_iterations: [], total: null, phase: 'setup', check_name: null,
+        next: { action: 'fix_method', text: 'Edit the file so that each part keeps both changes, then run again. No run started and no file changed.' },
+        evidence: conflicts.flatMap(c => [`Your ${c.part}: ${text(c.yours)}`, `${who}'s ${c.part}: ${text(c.theirs)}`]) };
 }

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

@@ -1,4 +1,5 @@
 import type { MethodClient } from './method-client.js';
+import type { CorrectionOutcome } from './fix-lines.js';
 /** A judgment as improve.method reads it. new marks the corrections to fix now; run is the account record of a run with no folder here. */
 export type ImproveJudgment = {
     id: string;
@@ -13,7 +14,12 @@ export type ImproveJudgment = {
     created_at: string;
     new?: boolean;
     run?: unknown;
+    noted_by?: string | null;
+    /** The question that an earlier fix asked about this correction, and the person's answer. */
+    question?: string;
+    answer?: string;
 };
+export type { CorrectionOutcome };
 /** Runs a local Method file; the default is the runtime that `method run FILE` uses. */
 export type RunFile = (file: string, flags: Record<string, unknown>, syncFactory: undefined, onEvent: undefined, client: MethodClient, baseConfig: undefined, secrets: Record<string, string>) => Promise<{
     status: string;
@@ -35,12 +41,17 @@ export type ImproveProposal = {
         [key: string]: unknown;
     };
 };
+export type ImproveResult = ImproveProposal & {
+    capped: string;
+    outcomes: CorrectionOutcome[];
+    background_cases: string[];
+    summary: string;
+};
 export type FixOutcome = {
     file: string;
-    corrections: number;
-    from_dashboard: number;
+    judgments: string[];
     kind: 'change' | 'none';
-    line: string;
+    applied: boolean;
     cause: string;
     steps: string[];
     cases: {
@@ -50,11 +61,9 @@ export type FixOutcome = {
             reason: string;
         }[];
     };
-    earlier_passed: number;
     version?: {
         version_id: string;
         url: string;
-        undo: string;
     } | undefined;
     usage: {
         model_calls: number;
@@ -63,15 +72,31 @@ export type FixOutcome = {
     } | null;
     capped: string;
     log: string;
-    changed?: string;
+    outcomes: CorrectionOutcome[];
+    /** The cases that run after an applied change, and the undo record of that change. */
+    background_cases: string[];
+    undo_id?: string | undefined;
+    /** The corrections that the applied change answered, with their notes. */
+    fixed: {
+        id: string;
+        note: string | null;
+    }[];
 };
 /**
- * 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 declare function readImproveResult(result: unknown): ImproveProposal & {
-    capped: string;
-};
+export declare function loopOutcome(o: any): CorrectionOutcome;
+/**
+ * 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 declare function readImproveResult(result: unknown, options?: {
+    prune?: boolean;
+}): ImproveResult;
 /**
  * Download the published improve.method and its files into the Method cache, once per version. For developers of
  * improve.method: METHOD_IMPROVE_METHOD=PATH runs that local improve.method file instead, from its own folder.
@@ -82,13 +107,12 @@ export declare function cachedImproveMethod(client: MethodClient): Promise<{
     version_id: string;
 }>;
 /**
- * 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 declare function runImprovement(client: MethodClient, file: string, judgments: ImproveJudgment[], runFolders: string[], run?: RunFile): Promise<{
+export declare function runImprovement(client: MethodClient, file: string, judgments: ImproveJudgment[], runFolders: string[], run?: RunFile, mode?: 'prune'): Promise<{
     log: string;
-    summary: any;
     cause: string;
     workflow: unknown | null;
     files: {
@@ -102,31 +126,129 @@ export declare function runImprovement(client: MethodClient, file: string, judgm
         [key: string]: unknown;
     };
     capped: string;
+    outcomes: CorrectionOutcome[];
+    background_cases: string[];
+    summary: string;
 }>;
 /** The ID of the regression case that a correction makes: one per judgment, so a later loop finds it. */
 export declare const correctionCaseId: (judgmentId: string) => string;
+/** One thing that the person saw: the result, a step output, a file the run wrote, or a call or effect it made. */
+type Seen = {
+    ref: string;
+    label: string;
+    value: unknown;
+};
+/** What the person saw of a run, with the ref that a case uses for each thing (runtime 0.16.0 refs). */
+export declare function seenOfRun(outcome: any): 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 declare function caseFromCorrection(file: string, judgment: {
     id: string;
     note: string | null;
     corrected?: unknown;
-}, runDir: string): Promise<{
+    noted_by?: string | null;
+    answer?: string | null;
+}, runDir: string, options?: {
+    approvedRuns?: string[];
+}): Promise<{
     id: string;
     made: boolean;
 }>;
+/** The corrections of a Method that wait for a fix. */
+export declare function waitingCorrections(client: MethodClient, file: string, methodId: string, waitMs?: number): Promise<{
+    note: string | null;
+    corrected: {} | null;
+    answer: string | null;
+    run_dir: string | undefined;
+    id: string;
+    run_id: string;
+    step_id: string | null;
+    verdict: "right" | "wrong";
+    source: string;
+    created_at: string;
+    pending: boolean;
+    noted_by?: string | null;
+    outcome?: string | null;
+    handled_by?: string | null;
+    held_with?: string | null;
+    question?: string | null;
+}[]>;
 /**
- * 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 declare function fixCorrections(client: MethodClient, file: string, options?: {
     run?: RunFile;
     waitMs?: number;
+    skip?: Set<string>;
 }): Promise<FixOutcome | undefined>;
-/** The one line for corrections that waited, printed before method run or method judge goes on. */
-export declare function waitingLine(outcome: FixOutcome): string;
+/** Whether a fix of the Method runs on this computer now. */
+export declare function fixRunning(methodId: string): boolean;
+/**
+ * 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 declare function fixWaiting(client: MethodClient, file: string, options?: {
+    run?: RunFile;
+    waitMs?: number;
+    runCases?: RunCases;
+}): Promise<FixOutcome[] | undefined>;
+/** Runs cases of a Method file (quality.ts runCases); tests replace it. */
+export type RunCases = (file: string, flags: Record<string, never>, options: {
+    ids: string[];
+}) => Promise<{
+    cases: {
+        id: string;
+        verdict: string;
+    }[];
+}>;
+/**
+ * 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 declare function checkBackground(client: MethodClient, file: string, fix: Pick<FixOutcome, 'background_cases' | 'undo_id' | 'fixed' | 'cause'>, options?: {
+    runCases?: RunCases;
+}): Promise<{
+    failed: string[];
+    restored: string[];
+    undone: boolean;
+    reopened: string[];
+}>;
+/**
+ * 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 declare function pruneMethod(client: MethodClient, file: string, options?: {
+    run?: RunFile;
+}): Promise<{
+    changed: boolean;
+} | undefined>;
+/**
+ * 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 declare function fixCorrection(client: MethodClient, file: string, judgmentId: string, options?: {
+    run?: RunFile;
+    pollMs?: number;
+}): Promise<import("./fix-outcomes.js").StoredOutcome | undefined>;
+/**
+ * `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 declare function backgroundFix(client: MethodClient, file: string, ids: string[], options?: {
+    run?: RunFile;
+    prune?: boolean;
+    pollMs?: number;
+}): Promise<void>;