@method-ai-hq/sdk 0.17.3 → 0.18.1

package/dist/packages/sdk/src/model-call.d.ts

@@ -0,0 +1,73 @@
+/**
+ * One model request that follows the same model rule as a run (the runtime's resolveModels): the model that the
+ * request names in `models`, else the user's own signed-in Claude Code or Codex (the calling agent first), else a
+ * hosted model on account credit. Each request is a fresh session.
+ */
+export type ModelRequest = {
+    system: string;
+    user: string;
+    schema: JsonSchema;
+    /** A model name of `models`, or default. */
+    model?: string;
+    models?: Record<string, unknown>;
+};
+export type ModelAnswer = {
+    value: any;
+    agent: string;
+    usd: number | null;
+    duration_ms: number;
+};
+type JsonSchema = {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    enum?: string[];
+    description?: string;
+};
+/** A Method type for a JSON schema: object → record, array → list, string → text. */
+export declare function methodType(schema: JsonSchema): any;
+/** The one-step Method of a request. Instructions with prompt braces go in the inputs, so nothing in them is read as a variable. */
+export declare function requestMethod(request: ModelRequest): {
+    inputs: {
+        instructions?: {
+            type: string;
+            description: string;
+        };
+        request: {
+            type: string;
+            description: string;
+        };
+    };
+    steps: {
+        answer: {
+            name: string;
+            in: {
+                instructions?: string;
+                request: string;
+            };
+            do: {
+                kind: string;
+                model: string;
+                prompt: string;
+            };
+            out: {
+                [k: string]: any;
+            };
+        };
+    };
+    result: {
+        [k: string]: string;
+    };
+    models?: Record<string, unknown>;
+    format: string;
+    name: string;
+    goal: string;
+};
+/** Run one model request through the runtime, with the preparation of method run. */
+export declare function callModel(request: ModelRequest): Promise<ModelAnswer>;
+/**
+ * `method __model`: one model request from a script of a Method (improve.method), as JSON on stdin; the answer as
+ * JSON on stdout. A failure prints {error, code, owner} and exits 1.
+ */
+export declare function modelCallCommand(): Promise<void>;
+export {};

package/dist/packages/sdk/src/model-call.js

@@ -0,0 +1,74 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { methodCache } from './prepare.js';
+/** A Method type for a JSON schema: object → record, array → list, string → text. */
+export function methodType(schema) {
+    const described = (value) => schema.description || schema.enum ? { ...value, description: [schema.description, schema.enum ? `One of: ${schema.enum.join(', ')}.` : ''].filter(Boolean).join(' ') } : value;
+    if (schema.type === 'object')
+        return described({ type: 'record', fields: fieldsOf(schema) });
+    if (schema.type === 'array')
+        return described(schema.items?.type === 'object' ? { type: 'list', fields: fieldsOf(schema.items) } : { type: 'list', items: methodType(schema.items ?? { type: 'string' }) });
+    if (schema.type === 'number' || schema.type === 'integer')
+        return described({ type: 'number' });
+    if (schema.type === 'boolean')
+        return described({ type: 'boolean' });
+    return described({ type: 'text' });
+}
+const fieldsOf = (schema) => Object.fromEntries(Object.entries(schema.properties ?? {}).map(([name, value]) => [name, methodType(value)]));
+/** The one-step Method of a request. Instructions with prompt braces go in the inputs, so nothing in them is read as a variable. */
+export function requestMethod(request) {
+    if (request.schema.type !== 'object')
+        throw Error('A model request asks for a JSON object.');
+    const braces = /\{\{|\}\}/.test(request.system);
+    const model = request.model ?? 'default';
+    const fields = fieldsOf(request.schema);
+    return {
+        format: 'method/3.4', name: 'Model request', goal: 'Answer one request.',
+        ...(request.models ? { models: request.models } : {}),
+        inputs: { request: { type: 'text', description: 'The request.' }, ...(braces ? { instructions: { type: 'text', description: 'The instructions.' } } : {}) },
+        steps: { answer: { name: 'Answer', in: { request: 'inputs.request', ...(braces ? { instructions: 'inputs.instructions' } : {}) },
+                do: { kind: 'call', model, prompt: braces ? 'Follow the instructions in the step inputs, then answer the request.' : request.system }, out: fields } },
+        result: Object.fromEntries(Object.keys(fields).map(name => [name, name])),
+    };
+}
+/** Run one model request through the runtime, with the preparation of method run. */
+export async function callModel(request) {
+    const dir = join(methodCache(), 'model-requests', randomUUID());
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        const file = join(dir, 'request.method');
+        writeFileSync(file, JSON.stringify(requestMethod(request)), { mode: 0o600 });
+        const { preparedConfig } = await import('./quality.js');
+        const { runMethod } = await import('@withmethod/runtime/runner.js');
+        const prepared = await preparedConfig(file, {});
+        const started = performance.now();
+        const result = await runMethod(file, prepared.config, { runDir: join(dir, 'run'), inputs: { request: request.user, ...(/\{\{|\}\}/.test(request.system) ? { instructions: request.system } : {}) },
+            processPath: prepared.processPath, prepareBundle: prepared.prepareBundle, ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) });
+        if (result.status !== 'completed')
+            throw Object.assign(Error(result.failure?.headline ?? `The model request ended with status ${result.status}.`), { code: result.failure?.code ?? 'model_failed', owner: result.failure?.owner });
+        const profile = prepared.config.models?.[request.model ?? 'default'];
+        const hosted = profile?.backend === 'method';
+        return { value: result.result, agent: hosted ? `hosted:${profile.model}` : profile?.backend ?? 'unknown', usd: hosted && typeof result.usage?.cost_usd === 'number' ? result.usage.cost_usd : null,
+            duration_ms: Math.round(performance.now() - started) };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * `method __model`: one model request from a script of a Method (improve.method), as JSON on stdin; the answer as
+ * JSON on stdout. A failure prints {error, code, owner} and exits 1.
+ */
+export async function modelCallCommand() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    try {
+        process.stdout.write(JSON.stringify(await callModel(JSON.parse(Buffer.concat(chunks).toString('utf8')))) + '\n');
+    }
+    catch (error) {
+        process.stdout.write(JSON.stringify({ error: error.message, code: error.code ?? 'model_failed', owner: error.owner ?? null }) + '\n');
+        process.exitCode = 1;
+    }
+}

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

@@ -56,7 +56,7 @@ export declare function lastSaved(server: string, methodId: string): {
 export declare function recordKnownVersion(server: string, methodId: string, versionId: string, versionNumber: number): void;
 /** A checkout of a saved version: the next save of this Method on this computer has it as its parent. */
 export declare function recordCheckout(server: string, methodId: string, versionId: string, versionNumber: number, workflow: unknown): void;
-/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+/** Errors that a retry can fix: no connection, a stalled transfer, a server error, or too many requests. */
 export declare function retryable(error: any): boolean;
 export declare class Outbox {
     readonly client: MethodClient;

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

@@ -40,12 +40,13 @@ 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 });
 }
-/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+/** Errors that a retry can fix: no connection, a stalled transfer, a server error, or too many requests. */
 export function retryable(error) {
     const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
-    return !status || status >= 500 || status === 429 || status === 408;
+    return status ? status >= 500 || status === 429 || status === 408 : unreachable(error) || error?.code === 'stalled';
 }
-const networkError = (error) => !(error?.status ?? /^\d{3}:/.test(String(error?.message))) && error?.code !== 'stalled';
+/** The server cannot be reached. An error on this computer (an unreadable run folder) is not one. */
+const unreachable = (error) => error?.code === 'network';
 export class Outbox {
     client;
     options;
@@ -221,7 +222,7 @@ export class Outbox {
                     }
                     // No response, a server error, or too many requests: after 3 in a row, stop and keep the items for a later
                     // command. A finished run never waits for a server that keeps failing.
-                    if (networkError(error) || status >= 500 || status === 429)
+                    if (unreachable(error) || status >= 500 || status === 429)
                         this.networkFailures++;
                     const attempt = (this.retryAt.get(key)?.attempt ?? 0) + 1;
                     this.retryAt.set(key, { at: Date.now() + Math.min(30_000, 500 * 2 ** (attempt - 1)), attempt });
@@ -256,7 +257,7 @@ export class Outbox {
         }
         catch (error) {
             const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
-            if (networkError(error) || status >= 500 || status === 429)
+            if (unreachable(error) || status >= 500 || status === 429)
                 this.networkFailures++;
         }
     }

package/dist/packages/sdk/src/own-model-key.d.ts

@@ -1,6 +1,6 @@
 import type { HostedModels } from '@withmethod/runtime';
 export declare const ownKeyName = "OPENROUTER_API_KEY";
-/** The name of this computer's own model key, or undefined. A local agent (--agent) replaces it for model steps. */
+/** The name of this computer's own model key, or undefined. */
 export declare const ownKeyEnv: () => string | undefined;
 /** method config model-key [--off]: open the private form for the key, then use it for model and classify steps. */
 export declare function modelKeyCommand(args: string[], set?: (name: string) => Promise<unknown>): Promise<void>;

package/dist/packages/sdk/src/own-model-key.js

@@ -7,7 +7,7 @@ import { typesafeModel } from '@withmethod/runtime/classification.js';
 import { readComputerSettings, updateComputerSettings } from './computer-settings.js';
 import { findSecrets, importSecrets, resolveSecrets, setSecret } from './secrets.js';
 export const ownKeyName = 'OPENROUTER_API_KEY';
-/** The name of this computer's own model key, or undefined. A local agent (--agent) replaces it for model steps. */
+/** The name of this computer's own model key, or undefined. */
 export const ownKeyEnv = () => readComputerSettings().model_key_env;
 /** method config model-key [--off]: open the private form for the key, then use it for model and classify steps. */
 export async function modelKeyCommand(args, set = setSecret) {

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

@@ -1,5 +1,5 @@
 import { type MethodClient } from './method-client.js';
-/** A proposed change to a Method, from the account (a server proposal) or from `method improve` on this computer. */
+/** A change to a Method: from the account (a change Method made there), or from the improvement loop on this computer. */
 export type ProposalRecord = {
     id: string;
     source: 'account' | 'local';
@@ -33,34 +33,19 @@ export type MergeResult = {
 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;
-/** Save a local proposal as a private file. The .method folder is not for Git: its proposals can hold run content. */
+/** Record what the improvement loop on this computer did (applied, or none) as a private file in the .method folder: it can hold run content. */
 export declare function saveLocalProposal(file: string, record: Omit<ProposalRecord, 'source'> & Record<string, unknown>): string;
 export declare function localProposals(file: string): (ProposalRecord & {
     path: string;
 })[];
-type RequestOptions = {
-    signal?: AbortSignal;
-    stallMs?: number;
-};
-type Applied = {
-    status: 'applied';
-    steps: string[];
-    version_id: string | undefined;
-    warning?: string;
-} | {
-    status: 'conflict';
-    conflicts: MergeConflict[];
-} | {
-    status: 'invalid';
-    error: string;
-};
-/** Merge a proposal into the file. A clean merge writes the file and marks the proposal applied. Never publishes. */
-export declare function applyProposal(client: MethodClient | undefined, file: string, proposal: ProposalRecord, options?: RequestOptions): Promise<Applied>;
 /**
- * Before a command that takes a .method FILE: when this computer is signed in and Method applied a change to the Method
- * (an accepted proposal, from the person's judgments), merge it into the file and print one line. A conflict prints
- * what the coding agent must resolve; the command goes on. Offline, signed out, or on any error, it does nothing.
+ * 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. */
@@ -68,6 +53,5 @@ export declare function localRuns(file: string): Promise<{
     dir: string;
     account_run_id: string | null;
 }[]>;
-/** `method improve`, `method changes`, and `method apply`. */
-export declare function proposalCommand(args: string[], clientFactory: (server: string) => MethodClient): Promise<boolean | undefined>;
-export {};
+/** `method changes FILE [--json]`. */
+export declare function changesMain(args: string[], clientFactory: (server: string) => MethodClient): Promise<boolean | undefined>;

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

@@ -6,6 +6,7 @@ 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 { 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) {
@@ -56,7 +57,7 @@ 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. */
-function writeMethodFile(file, id, content) {
+export function writeMethodFile(file, id, content) {
     const { format, ...rest } = content;
     const document = { ...(format !== undefined ? { format } : {}), ...(id ? { id } : {}), ...rest };
     if (/^\s*\{/.test(readFileSync(file, 'utf8'))) {
@@ -74,13 +75,11 @@ function writeMethodFile(file, id, content) {
         writeDocument(file, document);
 }
 export const localProposalFolder = (file) => join(dirname(file), '.method', 'proposals');
-/** Save a local proposal as a private file. The .method folder is not for Git: its proposals can hold run content. */
+/** Record what the improvement loop on this computer did (applied, or none) as a private file in the .method folder: it can hold run content. */
 export function saveLocalProposal(file, record) {
-    const folder = localProposalFolder(file), ignore = join(dirname(folder), '.gitignore');
-    const path = join(folder, `${record.id}.json`);
+    localMethodFolder(file);
+    const path = join(localProposalFolder(file), `${record.id}.json`);
     writePrivateJson(path, { ...record, source: 'local', file: basename(file) });
-    if (!existsSync(ignore))
-        writeFileSync(ignore, '*\n', { mode: 0o600 });
     return path;
 }
 export function localProposals(file) {
@@ -101,8 +100,8 @@ async function newestAccepted(client, methodId, 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 proposal into the file. A clean merge writes the file and marks the proposal applied. Never publishes. */
-export async function applyProposal(client, file, proposal, options = {}) {
+/** 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)
@@ -119,11 +118,6 @@ export async function applyProposal(client, file, proposal, options = {}) {
 }
 async function markApplied(client, file, proposal, options = {}) {
     const version_id = (await currentVersion(file).catch(() => undefined))?.version_id;
-    if (proposal.source === 'local') {
-        const path = join(localProposalFolder(file), `${proposal.id}.json`), record = JSON.parse(readFileSync(path, 'utf8'));
-        writePrivateJson(path, { ...record, status: 'applied', applied_at: new Date().toISOString(), ...(version_id ? { applied_version_id: version_id } : {}) });
-        return { version_id };
-    }
     try {
         await client.request(`/api/proposals/${encodeURIComponent(proposal.id)}/applied`, 'POST', version_id ? { version_id } : {}, true, options);
         return { version_id };
@@ -133,11 +127,12 @@ async function markApplied(client, file, proposal, options = {}) {
     }
 }
 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(['apply', 'changes', 'judge', 'improve', 'init', 'new-id', 'diff', 'help', 'authoring', 'schema', '__worker', '__checks', 'worker', 'keys', 'secret', 'models', 'login', 'logout', 'sync', 'progress']);
+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 applied a change to the Method
- * (an accepted proposal, from the person's judgments), merge it into the file and print one line. A conflict prints
- * what the coding agent must resolve; the command goes on. Offline, signed out, or on any error, it does nothing.
+ * 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')
@@ -160,13 +155,18 @@ export async function autoApply(args, clientFactory) {
         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;
         }
-        else
-            process.stderr.write(result.status === 'conflict'
-                ? `Method's change ${proposal.id} conflicts with your edits of ${target} in ${result.conflicts.map(c => c.path).join(', ')}. The file is not changed. Run method apply ${target} ${proposal.id} to see both versions, merge them in the file, then run method apply ${target} ${proposal.id} --resolved.\n`
-                : `Method's change ${proposal.id} does not merge into a valid Method: ${result.error} The file is not changed. Run method apply ${target} ${proposal.id} to see it.\n`);
+        // 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 proposal. */ }
+    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) {
@@ -186,7 +186,7 @@ export async function localRuns(file) {
 }
 const print = (value) => process.stdout.write(JSON.stringify(value, null, 2) + '\n');
 const changeLine = (change) => `${change.date.slice(0, 10)}  ${change.version_id ?? 'not saved as a version'}  ${change.cause}`;
-/** `method changes FILE`: the changes that Method applied to the Method, newest first, and those applied on this computer. */
+/** `method changes FILE`: the changes that Method applied in the account and on this computer, newest first. */
 async function changesCommand(file, target, methodId, client, json) {
     const local = localProposals(file).filter(p => p.status === 'applied').map((p) => ({ id: p.id, source: 'local', cause: p.cause, date: String(p.applied_at ?? p.created_at), version_id: p.applied_version_id ?? null, steps: p.evidence?.steps ?? [] }));
     let account = [];
@@ -201,48 +201,16 @@ async function changesCommand(file, target, methodId, client, json) {
         return print({ file, method_id: methodId, changes });
     process.stdout.write(changes.length ? changes.map(changeLine).join('\n') + '\n' : `Method has not changed ${target} yet.\n`);
 }
-/** `method improve`, `method changes`, and `method apply`. */
-export async function proposalCommand(args, clientFactory) {
-    if (args[0] === 'improve')
-        return (await import('./improve.js')).improveCommand(args.slice(1), clientFactory);
-    const { values, positionals } = parseArgs({ args: args.slice(1), allowPositionals: true, options: { server: { type: 'string' }, resolved: { type: 'boolean' }, json: { type: 'boolean' } } });
-    const [target, wanted] = positionals;
-    if (!target || positionals.length > (args[0] === 'apply' ? 2 : 1))
-        throw Error(args[0] === 'apply' ? 'Use method apply FILE [PROPOSAL_ID] [--resolved].' : 'Use method changes FILE [--json].');
+/** `method changes FILE [--json]`. */
+export async function changesMain(args, clientFactory) {
+    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { server: { type: 'string' }, json: { type: 'boolean' } } });
+    const [target] = positionals;
+    if (!target || positionals.length !== 1)
+        throw Error('Use method changes FILE [--json].');
     const file = authoringPath(target), id = readDocument(file).id;
     const methodId = typeof id === 'string' && methodIdPattern.test(id) ? id : null;
     const client = clientFactory(values.server ?? DEFAULT_SERVER);
-    const signedIn = !!client.token();
-    if (args[0] === 'changes')
-        return changesCommand(file, target, methodId, client, !!values.json);
-    const local = localProposals(file);
-    let proposal = wanted ? local.find(p => p.id === wanted) : undefined;
-    if (!proposal && wanted) {
-        if (!signedIn)
-            await client.login();
-        proposal = await accountProposal(client, wanted);
-        if (methodId && proposal.method_id !== methodId)
-            throw Error(`Proposal ${wanted} is for another Method.`);
-    }
-    proposal ??= local.find(p => p.status === 'open');
-    if (!proposal)
-        throw Error(`${target} has no open proposal. Run method improve ${target} --note TEXT first.`);
-    if (proposal.status === 'applied')
-        return print({ status: 'applied', file, proposal_id: proposal.id, next: 'This proposal is already applied.' });
-    if (proposal.source === 'account' && proposal.status !== 'accepted')
-        throw Error(`Change ${proposal.id} is ${proposal.status}, so it has nothing to merge.`);
-    if (proposal.source === 'local' && proposal.status !== 'open')
-        throw Error(`Proposal ${proposal.id} is ${proposal.status}.`);
-    if (values.resolved)
-        return print({ status: 'applied', file, proposal_id: proposal.id, ...await markApplied(client, file, proposal), next: `Run method test ${target}. Publish it when it is right.` });
-    if (!proposal.proposed_workflow)
-        return print({ status: 'none', file, proposal_id: proposal.id, cause: proposal.cause, next: 'No change passed the tests; there is nothing to apply.' });
-    const result = await applyProposal(client, file, proposal);
-    if (result.status === 'applied')
-        return print({ ...result, file, proposal_id: proposal.id, cause: proposal.cause, next: `Run method test ${target}. Publish it when it is right.` });
-    process.exitCode = 1;
-    if (result.status === 'invalid')
-        return print({ status: 'invalid', file, proposal_id: proposal.id, error: result.error, next: 'The file is not changed. Merge the proposed version by hand.' });
-    print({ status: 'conflict', file, proposal_id: proposal.id, cause: proposal.cause, conflicts: result.conflicts,
-        next: `The file is not changed. Your edits and the proposal both change each listed part. Edit ${target} so that each part keeps both changes, then run method apply ${target} ${proposal.id} --resolved.` });
+    if (methodId && !client.token())
+        await client.login();
+    return changesCommand(file, target, methodId, client, !!values.json);
 }

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

@@ -1,7 +1,6 @@
 /** 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;
-    agent?: string;
 }, options?: {
     judge?: boolean;
 }): Promise<{
@@ -22,12 +21,12 @@ export declare function casesNotice(file: string): Promise<string | undefined>;
 /** Run the cases of a Method with the same preparation as method run. */
 export declare function runCases(file: string, flags: {
     workspace?: string;
-    agent?: string;
 }, options?: {
     casesDir?: string | undefined;
     ids?: string[] | undefined;
     baseline?: string | undefined;
     newIds?: string[];
+    once?: boolean;
 }): Promise<{
     counts: {
         [k: string]: number;

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

@@ -10,6 +10,7 @@ import { createCase, retireCase, listCases, testSuite } from "@withmethod/runtim
 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 { hostedModelsFor, managedModels } from "./hosted-models.js";
 import { managedClassification } from "./classification-client.js";
 import { MethodClient } from "./method-client.js";
@@ -30,21 +31,29 @@ export async function preparedConfig(file, flags, options = {}) {
     catch {
         return false;
     } })();
-    // A rubric judge is a model step too: without a local agent, a signed-in computer judges with the account's model.
-    const judge = options.judge && !setup.agent && !config.models?.judge;
-    if ((accountNeeds(method, config, setup.agent).models || judge) && signedIn) {
+    // A rubric judge is a model step too: it follows the same rule (the user's own local agent, else hosted).
+    const judge = options.judge && !config.models?.judge;
+    // The hosted model is asked for only when no local agent can run the model steps.
+    if ((accountNeeds(method, config).models || judge) && signedIn && !await localAgent()) {
         try {
             hostedModel = await managedModels(client).model();
         }
         catch (error) {
-            process.stderr.write(`Hosted models are unavailable (${error.message}). Using a local agent.\n`);
+            process.stderr.write(`Hosted models are unavailable (${error.message}).\n`);
+        }
+    }
+    config.models = await resolveAgentProfiles(method, config, hostedModel);
+    if (judge) {
+        try {
+            config.models.judge = (await resolveModels({ steps: { judge: { do: { kind: 'call', model: 'judge' } } } }, {}, { hostedModel })).judge;
+        }
+        catch (error) {
+            if (error.code !== 'needs_input')
+                throw error;
         }
     }
-    config.models = await resolveAgentProfiles(method, config, setup.agent, hostedModel);
-    if (judge && hostedModel)
-        config.models.judge = { backend: "method", model: hostedModel };
     // Classify steps that run live use the account's classifier, as method run does.
-    const classification = accountNeeds(method, config, setup.agent).classification && signedIn ? managedClassification(client) : undefined;
+    const classification = accountNeeds(method, config).classification && signedIn ? managedClassification(client) : undefined;
     if (classification)
         config.classification = await classification.resolve(new AbortController().signal);
     await checkAgents(config.models);
@@ -139,18 +148,18 @@ async function declaredSecrets(file) {
 export async function runCases(file, flags, options = {}) {
     const prepared = await preparedConfig(file, flags, { judge: true });
     const report = await testSuite(file, prepared.config, { ...options,
-        runOptions: { processPath: prepared.processPath, prepareBundle: prepared.prepareBundle, secrets: await declaredSecrets(file), ...(prepared.classification ? { classification: prepared.classification } : {}), ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}), ...(flags.agent ? { agent: flags.agent } : {}) } });
-    if (!options.ids && !options.casesDir)
+        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)
         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" }, agent: { type: "string" } } });
+    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 file = positionals[0];
     if (!file || positionals.length !== 1)
-        throw Error("Use method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]...");
+        throw Error("Use method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--once]");
     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 ?? [] });
+        baseline: values.baseline ? authoringPath(values.baseline) : undefined, newIds: values.new ?? [], once: !!values.once });
     print(report);
     process.exitCode = report.passed ? 0 : 1;
 }
@@ -178,7 +187,7 @@ export async function caseGate(file, accept = [], reason) {
 export async function caseCommand(args) {
     const text = { type: "string" };
     const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { run: text, "passing-run": text, id: text, note: text, rubric: { type: "string", multiple: true }, ref: text, context: { type: "string", multiple: true }, expect: text,
-            observations: text, redact: text, runs: text, "min-pass": text, author: text, reason: text, by: text, cases: text, workspace: text, agent: text,
+            observations: text, redact: text, runs: text, "min-pass": text, author: text, reason: text, by: text, cases: text, workspace: text,
             "retention-days": text, supersedes: { type: "string", multiple: true }, "accept-conflict": text } });
     const [action, file, id] = positionals;
     if (!file || !["new", "retire", "list"].includes(action ?? ""))
@@ -200,7 +209,7 @@ export async function caseCommand(args) {
         throw Error('Supply --id, --note "the person\'s words", and --run (the run that went wrong) or --passing-run (a run that was right).');
     if (!values.rubric?.length && !values.expect)
         throw Error('Say what must be true with --rubric "plain sentence" (repeatable), or give --expect FILE.');
-    const prepared = await preparedConfig(methodFile, { ...(values.workspace ? { workspace: values.workspace } : {}), ...(values.agent ? { agent: values.agent } : {}) }, { judge: true });
+    const prepared = await preparedConfig(methodFile, { ...(values.workspace ? { workspace: values.workspace } : {}) }, { judge: true });
     const privacy = casesPrivacyWarning(methodFile, casesDir);
     if (privacy)
         process.stderr.write(privacy + "\n");
@@ -208,7 +217,7 @@ export async function caseCommand(args) {
         id: values.id, note: values.note, author: values.author ?? null, 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 } : {}), ...(values.agent ? { agent: values.agent } : {}) } } }));
+        options: { runOptions: { processPath: prepared.processPath, secrets: await declaredSecrets(methodFile), ...(prepared.classification ? { classification: prepared.classification } : {}), ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) } } }));
 }
 /**
  * A case copies run data (inputs, outputs, written files) into cases/. When that folder would be committed to a Git

package/package.json

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