@method-ai-hq/sdk 0.18.2 → 0.20.0

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

@@ -32,13 +32,20 @@ export function recordKnownVersion(server, methodId, versionId, versionNumber) {
         writePrivateJson(savedFile(server), { ...savedVersions(server), [versionId]: { method_id: methodId, version_number: versionNumber } });
 }
 /** A checkout of a saved version: the next save of this Method on this computer has it as its parent. */
-export function recordCheckout(server, methodId, versionId, versionNumber, workflow) {
+export function recordCheckout(server, methodId, versionId, versionNumber, workflow, extra = {}) {
     recordKnownVersion(server, methodId, versionId, versionNumber);
-    writePrivateJson(methodFile(server, methodId), { version_id: versionId, version_number: versionNumber, workflow });
+    writePrivateJson(methodFile(server, methodId), { version_id: versionId, version_number: versionNumber, workflow, ...extra });
 }
-function recordSaved(item, versionNumber) {
-    writePrivateJson(savedFile(item.server), { ...savedVersions(item.server), [item.version_id]: { method_id: item.method_id, version_number: versionNumber } });
-    writePrivateJson(methodFile(item.server, item.method_id), { version_id: item.version_id, version_number: versionNumber, workflow: item.body.workflow });
+/** A combine that stopped: the parts that both sides changed, as they were on this computer. */
+export function recordCombineStop(server, methodId, conflict) {
+    writePrivateJson(methodFile(server, methodId), { ...lastSaved(server, methodId), conflict });
+}
+/** A save that the server kept beside a newer version stays off the base: the next run combines it with the newer one. */
+function recordSaved(item, saved) {
+    const beside = saved.newest === false;
+    writePrivateJson(savedFile(item.server), { ...savedVersions(item.server), [item.version_id]: { method_id: item.method_id, version_number: saved.version_number, ...(beside ? { beside: saved.newer?.saved_by ?? null } : {}) } });
+    writePrivateJson(methodFile(item.server, item.method_id), beside ? { ...lastSaved(item.server, item.method_id), side_version_id: item.version_id }
+        : { version_id: item.version_id, version_number: saved.version_number, workflow: item.body.workflow });
 }
 /** Errors that a retry can fix: no connection, a stalled transfer, a server error, or too many requests. */
 export function retryable(error) {
@@ -274,7 +281,7 @@ export class Outbox {
             const saved = await this.client.request(`/api/cli/methods/${encodeURIComponent(item.method_id)}/versions/${encodeURIComponent(item.version_id)}`, 'PUT', item.body, true, { stallMs, onProgress });
             if (saved.version_id !== item.version_id)
                 throw Object.assign(Error('The server saved another version ID than this content has.'), { status: 409 });
-            recordSaved(item, saved.version_number);
+            recordSaved(item, saved);
             return;
         }
         if (!existsSync(join(item.run_dir, 'method-sync.json')))

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

@@ -12,27 +12,6 @@ export type ProposalRecord = {
     base_workflow: unknown;
     proposed_workflow: unknown | null;
 };
-export type MergeConflict = {
-    path: string;
-    base: unknown;
-    ours: unknown;
-    theirs: unknown;
-};
-export type MergeResult = {
-    clean: true;
-    workflow: any;
-} | {
-    clean: false;
-    conflicts: MergeConflict[];
-};
-/**
- * Three-way merge of Method documents, per step and per top-level key. base is the version the proposal started from,
- * ours is the local file, and theirs is the proposed version. A part that only one side changed takes that change; a part
- * that both sides changed in different ways is a conflict.
- */
-export declare function mergeMethod(base: any, ours: any, theirs: any): MergeResult;
-/** The steps whose definition differs between two documents. */
-export declare function changedSteps(before: any, after: any): string[];
 /** Write Method content to a file and keep its id: line. A JSON file stays JSON. */
 export declare function writeMethodFile(file: string, id: string | undefined, content: any): void;
 export declare const localProposalFolder: (file: string) => string;
@@ -41,13 +20,6 @@ export declare function saveLocalProposal(file: string, record: Omit<ProposalRec
 export declare function localProposals(file: string): (ProposalRecord & {
     path: string;
 })[];
-/**
- * Before a command that takes a .method FILE: when this computer is signed in and Method changed the Method in the
- * account (keeping run data in the account, or a fix of a Method that had not run on a computer), merge the change into
- * the file and print one line. A conflict leaves the file unchanged and writes both versions of each conflicting part
- * to a file for the coding agent to merge; the command goes on. Offline, signed out, or on any error, it does nothing.
- */
-export declare function autoApply(args: string[], clientFactory: (server: string) => MethodClient): Promise<void>;
 /** Run folders of this Method on this computer, newest first, with the account run ID of each run that was saved to the account. */
 export declare function localRuns(file: string): Promise<{
     dir: string;

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

@@ -1,61 +1,11 @@
 import { existsSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
-import { isDeepStrictEqual, parseArgs } from 'node:util';
-import { loadWorkflow } from '../../workflow-language/src/validate.js';
+import { parseArgs } from 'node:util';
 import { authoringPath, readDocument, writeDocument } from './authoring.js';
 import { DEFAULT_SERVER } from './method-client.js';
 import { writePrivateJson } from './files.js';
-import { currentVersion, methodContent, methodIdPattern } from './versions.js';
+import { methodIdPattern } from './versions.js';
 import { localMethodFolder } from './local-judgments.js';
-const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
-/** Keys of ours in their order; a key that only theirs has goes after the key before it in theirs. */
-function keyOrder(ours, theirs) {
-    const keys = Object.keys(ours), theirKeys = Object.keys(theirs);
-    theirKeys.forEach((key, index) => {
-        if (keys.includes(key))
-            return;
-        const before = theirKeys.slice(0, index).reverse().find(other => keys.includes(other));
-        keys.splice(before === undefined ? 0 : keys.indexOf(before) + 1, 0, key);
-    });
-    return keys;
-}
-/**
- * Three-way merge of Method documents, per step and per top-level key. base is the version the proposal started from,
- * ours is the local file, and theirs is the proposed version. A part that only one side changed takes that change; a part
- * that both sides changed in different ways is a conflict.
- */
-export function mergeMethod(base, ours, theirs) {
-    if (isDeepStrictEqual(ours, base))
-        return { clean: true, workflow: theirs };
-    if (isDeepStrictEqual(theirs, base) || isDeepStrictEqual(ours, theirs))
-        return { clean: true, workflow: ours };
-    const conflicts = [];
-    const pick = (path, b, o, t) => {
-        if (isDeepStrictEqual(o, t) || isDeepStrictEqual(b, t))
-            return o;
-        if (isDeepStrictEqual(b, o))
-            return t;
-        conflicts.push({ path, base: b, ours: o, theirs: t });
-        return o;
-    };
-    const merge = (path, b, o, t, nested) => {
-        const result = {};
-        for (const key of keyOrder(o, t)) {
-            const at = path ? `${path}.${key}` : key;
-            const value = nested(key) && isObject(o[key]) && isObject(t[key]) && isObject(b?.[key] ?? {})
-                ? merge(at, b?.[key] ?? {}, o[key], t[key], () => false) : pick(at, b?.[key], o[key], t[key]);
-            if (value !== undefined)
-                result[key] = value;
-        }
-        return result;
-    };
-    const workflow = merge('', isObject(base) ? base : {}, ours, theirs, key => key === 'steps');
-    return conflicts.length ? { clean: false, conflicts } : { clean: true, workflow };
-}
-/** The steps whose definition differs between two documents. */
-export function changedSteps(before, after) {
-    return [...new Set([...Object.keys(before?.steps ?? {}), ...Object.keys(after?.steps ?? {})])].filter(id => !isDeepStrictEqual(before?.steps?.[id], after?.steps?.[id]));
-}
 /** Write Method content to a file and keep its id: line. A JSON file stays JSON. */
 export function writeMethodFile(file, id, content) {
     const { format, ...rest } = content;
@@ -91,83 +41,6 @@ export function localProposals(file) {
         return { ...record, proposed_workflow: record.proposed_workflow ?? null, path };
     }).filter(record => record.file === basename(file)).sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
 }
-async function accountProposal(client, id, options = {}) {
-    const { proposal } = await client.request(`/api/proposals/${encodeURIComponent(id)}`, 'GET', undefined, true, options);
-    return { ...proposal, source: 'account', proposed_workflow: proposal.proposed_workflow ?? null };
-}
-async function newestAccepted(client, methodId, options = {}) {
-    const { proposals } = await client.request(`/api/methods/${encodeURIComponent(methodId)}/proposals?status=accepted`, 'GET', undefined, true, options);
-    const accepted = (proposals ?? []).filter(p => p?.status === 'accepted').sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
-    return accepted[0] ? accountProposal(client, accepted[0].id, options) : undefined;
-}
-/** Merge a change Method made in the account into the file. A clean merge writes the file and records the change as applied. Never publishes. */
-async function applyProposal(client, file, proposal, options = {}) {
-    const document = readDocument(file), ours = methodContent(document);
-    const merged = mergeMethod(proposal.base_workflow, ours, proposal.proposed_workflow);
-    if (!merged.clean)
-        return { status: 'conflict', conflicts: merged.conflicts };
-    try {
-        loadWorkflow(merged.workflow);
-    }
-    catch (error) {
-        return { status: 'invalid', error: error.message };
-    }
-    if (!isDeepStrictEqual(merged.workflow, ours))
-        writeMethodFile(file, typeof document.id === 'string' ? document.id : undefined, merged.workflow);
-    return { status: 'applied', steps: changedSteps(ours, merged.workflow), ...await markApplied(client, file, proposal, options) };
-}
-async function markApplied(client, file, proposal, options = {}) {
-    const version_id = (await currentVersion(file).catch(() => undefined))?.version_id;
-    try {
-        await client.request(`/api/proposals/${encodeURIComponent(proposal.id)}/applied`, 'POST', version_id ? { version_id } : {}, true, options);
-        return { version_id };
-    }
-    catch (error) {
-        return { version_id, warning: `The file is changed, but Method did not record the proposal as applied: ${error.message}` };
-    }
-}
-const serverFlag = (args) => { const at = args.findIndex(arg => arg === '--server' || arg.startsWith('--server=')); return at < 0 ? undefined : args[at].startsWith('--server=') ? args[at].slice(9) : args[at + 1]; };
-const skipAutoApply = new Set(['changes', 'judge', 'init', 'new-id', 'diff', 'help', 'authoring', 'schema', '__worker', '__checks', '__model', 'worker', 'keys', 'secret', 'models', 'login', 'logout', 'sync', 'progress']);
-/**
- * Before a command that takes a .method FILE: when this computer is signed in and Method changed the Method in the
- * account (keeping run data in the account, or a fix of a Method that had not run on a computer), merge the change into
- * the file and print one line. A conflict leaves the file unchanged and writes both versions of each conflicting part
- * to a file for the coding agent to merge; the command goes on. Offline, signed out, or on any error, it does nothing.
- */
-export async function autoApply(args, clientFactory) {
-    if (!args[0] || skipAutoApply.has(args[0]) || args.includes('--help') || process.env.METHOD_RUN_WORKER === '1')
-        return;
-    const target = args.slice(1).find(arg => !arg.startsWith('-') && /\.method$/i.test(arg));
-    if (!target || !existsSync(target))
-        return;
-    try {
-        const file = authoringPath(target), id = readDocument(file).id;
-        if (typeof id !== 'string' || !methodIdPattern.test(id))
-            return;
-        const client = clientFactory(serverFlag(args) ?? DEFAULT_SERVER);
-        if (!client.token())
-            return;
-        const options = { signal: AbortSignal.timeout(3000), stallMs: 3000 };
-        const proposal = await newestAccepted(client, id, options);
-        if (!proposal?.proposed_workflow)
-            return;
-        const result = await applyProposal(client, file, proposal, options);
-        if (result.status === 'applied') {
-            if (result.steps.length || result.warning)
-                process.stderr.write(`Method changed ${target} (${proposal.id}): ${proposal.cause}${result.steps.length ? ` Changed steps: ${result.steps.join(', ')}.` : ''}${result.warning ? ` ${result.warning}` : ''}\n`);
-            return;
-        }
-        // The agent merges by hand from the saved versions; the change is recorded as applied, so it is not merged again.
-        localMethodFolder(file);
-        const path = join(dirname(file), '.method', `conflict-${proposal.id}.json`);
-        writePrivateJson(path, { proposal_id: proposal.id, cause: proposal.cause, ...(result.status === 'conflict' ? { conflicts: result.conflicts } : { error: result.error }), proposed_workflow: proposal.proposed_workflow });
-        await markApplied(client, file, proposal, options).catch(() => undefined);
-        process.stderr.write(result.status === 'conflict'
-            ? `Method's change ${proposal.id} (${proposal.cause}) conflicts with your edits of ${target} in ${result.conflicts.map(c => c.path).join(', ')}. The file is not changed. Both versions of each part are in ${path}: edit ${target} so each part keeps both changes.\n`
-            : `Method's change ${proposal.id} does not merge into a valid Method: ${result.error} The file is not changed. The changed version is in ${path}.\n`);
-    }
-    catch { /* offline or signed out: the command goes on without the change. */ }
-}
 /** Run folders of this Method on this computer, newest first, with the account run ID of each run that was saved to the account. */
 export async function localRuns(file) {
     const { recentRuns } = await import('./current-runtime.js');

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

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

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

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

package/dist/packages/sdk/src/run-saved.d.ts

@@ -1,5 +1,9 @@
 import { MethodClient } from './method-client.js';
 import type { parse } from './local-cli.js';
+/** How often a run that waits for the shared state checks again. Tests make it short. */
+export declare const stateWait: {
+    pollMs: number;
+};
 /** A run whose steps all finished: completed, or unconfirmed (an external change could not be confirmed). */
 export declare const finishedRun: (status: string) => status is "unconfirmed" | "completed";
 export declare function runSaved(saved: any, flags: ReturnType<typeof parse>['values'], client: MethodClient): Promise<any>;

package/dist/packages/sdk/src/run-saved.js

@@ -13,6 +13,37 @@ import { workerRunId } from './run-worker.js';
 import { readDocument } from './authoring.js';
 import { withInputsFrom } from './inputs-from.js';
 import { setupFailure } from './failure.js';
+/** How often a run that waits for the shared state checks again. Tests make it short. */
+export const stateWait = { pollMs: 10_000 };
+const clock = (at) => { const date = at ? new Date(at) : undefined; return date && !isNaN(+date) ? `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}` : undefined; };
+/**
+ * Take the shared state. While another run that still runs (or lost its connection) holds it, say so once and check
+ * again until it is free: there is no time limit, and method cancel stops the wait. A run that stopped while it held
+ * the state stops this one: a person must check that run's actions before releasing it.
+ */
+async function acquireState(client, statePath, runId, methodId) {
+    let told = false;
+    for (;;) {
+        try {
+            return await client.request(statePath, 'POST', { action: 'acquire', run_id: runId });
+        }
+        catch (error) {
+            const owner = error?.body?.owner;
+            if (error?.code !== 'state_owned')
+                throw error;
+            if (owner && (owner.status === 'finished' || owner.status === 'failed')) {
+                const name = owner.started_by ?? 'Another person';
+                throw Object.assign(Error(`${name}'s run stopped while it held the shared state. ${name} must check its actions, then run \`method state ${methodId} --release ${owner.run_id}\`.`), { code: 'state_held', owner: 'setup' });
+            }
+            if (!told) {
+                const started = clock(owner?.started_at);
+                process.stderr.write(`Waiting for ${owner?.started_by ? `${owner.started_by}'s run` : 'another run'}${started ? ` (started ${started})` : ''} to finish with the shared state${owner?.link ? `: ${owner.link}` : '.'}\n`);
+                told = true;
+            }
+            await new Promise(resolve => setTimeout(resolve, stateWait.pollMs));
+        }
+    }
+}
 // Older versions are listed only after their saved-package tests pass.
 const supportedPackageRuntimes = new Set([runtimeVersion, '0.14.0', '0.12.0', '0.11.1', '0.11.0', '0.10.0', '0.9.5', '0.9.4', '0.9.3', '0.7.0', '0.7.1', '0.7.2', '0.8.0', '0.8.1', '0.8.2', '0.8.3']);
 /** A run whose steps all finished: completed, or unconfirmed (an external change could not be confirmed). */
@@ -100,7 +131,7 @@ export async function runSaved(saved, flags, client) {
         if (shared.enabled) {
             if (flags.state)
                 throw Error('This Method uses account state. Do not replace it with --state.');
-            const state = await client.request(statePath, 'POST', { action: 'acquire', run_id: request.run_id });
+            const state = await acquireState(client, statePath, request.run_id, saved.workflow_id);
             acquired = true;
             revision = state.revision;
             const pendingFile = join(directory, 'state-pending.json');
@@ -125,7 +156,7 @@ export async function runSaved(saved, flags, client) {
                 const result = await client.request(statePath, 'POST', commit);
                 revision = result.revision;
             }
-        }, client, config);
+        }, client, config, {}, saved.saved_by ?? null);
         // Every step finished (an unconfirmed run too), so the run no longer owns the shared state.
         if (acquired && finishedRun(result.status)) {
             await client.request(statePath, 'POST', { action: 'release', run_id: request.run_id });

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

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