@method-ai-hq/sdk 0.17.3 → 0.18.1

package/README.md

@@ -3,7 +3,7 @@
 MIT-licensed JavaScript API and the `method` CLI. Source and releases: https://github.com/method-ai-hq/method-sdk
 
 ```sh
-npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.17.3/method-ai-hq-sdk-0.17.3.tgz
+npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.18.1/method-ai-hq-sdk-0.18.1.tgz
 npx method --version
 ```
 
@@ -15,7 +15,7 @@ const result = await runMethod('task.method', {allow_local_processes: true}, {in
 console.log(result.status, inspectRun('runs/first'));
 ```
 
-New Methods use method/3.4: models, limits, tools, secret names, and the Method ID are in the Method file. Documents in method/3.1 to 3.3 load and run unchanged. `runMethod` is the bare runtime: it does not sign in, save versions, or use hosted models; `method run` does. The executor is the pinned @withmethod/runtime dependency. Python uses method-bridge to call the same runtime.
+New Methods use method/3.4: models, limits, tools, secret names, and the Method ID are in the Method file. Documents in method/3.1 to 3.3 load and run unchanged. `runMethod` is the bare runtime: it does not sign in, save versions, or use hosted models; `method run` does. Steps that name no model run on your Claude Code or Codex subscription when one is signed in; hosted models on account credit are used only when none is. The executor is the pinned @withmethod/runtime dependency. Python uses method-bridge to call the same runtime.
 
 To run a published Method from an app, use `new Method().run({method: 'wf_…', inputs})`. See https://docs.withmethod.ai/guides/production.
 

package/dist/packages/sdk/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"

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

@@ -5,16 +5,16 @@ export declare const designProcedure = "# Choose the design\n\n| Requirement | S
 /** The full check rules; in concepts. */
 export declare const checkRules = "# Checks\n\nAdd a check only when it catches a concrete failure that matters to the result. Output types and the runtime already validate shapes; do not repeat them. Do not check wording, headings, keywords, lengths, or counts unless the task requires them: \"write accurate prose\" is not a reason to match strings.\n\nUse the simplest check that proves the fact: a built-in equals, count, present, or file check, a script, or an agent check. Local file writes need no check: the runtime observes files connections itself. A change to a service, an API, email, or a browser that sends needs an effect that reads the result back, because a receipt or a 200 status shows only that the request was accepted. Use a built-in observer (http, sqlite, file) when one fits. When a change cannot or need not be observed, such as a browser step that only reads, write no_effect_reason instead.\n\nExisting checks and tests are implementation choices, not user requirements. Remove a check that is unnecessary, repeats other validation, or enforces a requirement that nobody asked for. Delete the tests and instructions that exist only for it, and do not replace it. Do not change useful output only to satisfy a check.\n";
 /** The rules that make a first Method work quickly. They come before every other part of the guide. */
-export declare const firstMethodRules = "# Build a Method\n\n1. **Sign in first.** Run `method status`. If it is not signed in, run `method login` and let the user approve in the browser. Signed in, model and classification steps need no keys, each run saves a version when the file changed, and runs appear on the dashboard.\n2. **Each model or classifier request is its own step**: `call`, `agent`, or `classify`, with its prompt in the Method, so the user can change one prompt, run again, and compare. A script never calls a model API. When the user already has code that does the work, keep its fixed logic as `run` steps and move each prompt and rubric into its own step; do not wrap the code. \"The same thing\" means the same behavior in steps. If a request cannot become a step because Method lacks a feature, tell the user what is missing.\n3. **Show the design, then build it in the same turn.** Show each step with its type, purpose, and output, and a table of the prompts, instructions, and rubrics in the user's existing work, each with the steps that receive it. Do not wait for approval unless the user asked to approve first. Ask only for information that you cannot find and that would change the design.\n4. **Run early and often.** Write the first steps, validate, run, then add the next steps. Fix errors. Fix each warning, or accept it with the user's reason. Never add a check only to remove a warning. A new run reuses every step whose definition and inputs did not change, so each run executes only what changed. `--rerun STEP` runs a step again anyway; `--fresh` runs every step.\n5. **Keep the inputs of the existing code.** If the code takes an ID and looks up the record, the Method takes the same ID and looks it up the same way.\n6. **Keep the user's rules word for word.** When you convert an agent, a prompt, a playbook, or a guide that the user wrote, copy each of their instruction files unchanged beside the Method and list them in `files`. A run step reads them and returns their complete text, and every model step that applies them receives that text in `in`. Each step prompt says the step's own task and tells the model to follow every rule in that text. Do not reword, shorten, summarize, or split the user's rules, and do not leave one out as background: a reworded rule can change its meaning, for example when a condition (\"only when\", \"unless\", \"after\") or an exception is lost. In the table of rule 3, list each instruction file with the steps that receive it.\n7. **Compare with the old agent before the Method replaces it.** Choose 3 to 5 sample inputs from the user's data, including the hard ones. Run the old agent as the user runs it and run the Method on the same inputs, and show the user every difference side by side. Fix each difference that the user does not accept, and run again. Do not say that the Method replaces the old agent, or does what it did, until the user has seen this comparison.\n8. **Use the defaults without asking.** Model steps use the account's hosted models and `classify` uses Method's classifier, so no model or classifier keys are needed. To keep the model that existing code uses, add `models: {writer: provider/model}` to the Method and use `model: writer` in the steps (or `model: provider/model` on the step); it needs no key. Keep the models that the Method or the existing code names: when a model step fails, show the error and ask before you change its model. Run records go to the user's account. Set `run_data: device` only when the user explicitly asks for it. If they do ask for it, get confirmation from them and tell them in one line that the dashboard will no longer show inputs or results, and that improvements, Run now and Method Cloud stop working.\n9. **Keys stay out of chat.** Declare each key that a script needs under `secrets:` with its purpose; every script of the Method receives all of its declared secrets. Run `method secret find` in the Method's folder: it lists the key files nearby and the names in each, never the values, and prints the import command. Run that command and tell the user which file each key came from: the key stays on this computer, so there is nothing to ask. If it finds nothing, ask the user to run `method secret set NAME`, which opens a private form in their browser. Never open, print, or search a key file (`cat`, `grep`, an editor), including Method's own secret store, and never ask for a value in chat: the values would go into the chat. When a run says Method's model credit is used up, run `method config model-key` yourself: it takes the user's own OpenRouter key from the one nearby key file that holds it, or opens a private form for it. Then run again.\n10. **Choose a sample yourself** from the user's data, and check that it has the sources the Method needs. Ask only when there is no good sample.\n11. **Iterate.** `method run` prints a `dashboard` link when the run starts and again with its result. Give the user the link as soon as the run starts. After a good run, show the result and the link, and ask what to change. Change the step and run again. Show only results that a run made: never write or edit a result by hand, and fix a wrong result in the Method, not in the data it reads. If you cannot run, say so.\n12. **Publish** with `method publish FILE --reason TEXT` when the user wants to share or schedule a version. It runs the Method's cases first.\n13. **Talk about the work, not about Method.** Unless the user asks, do not mention Method's versions, formats, settings files, or other internal files, and do not ask the user about them, about models, or about which saved version to use. Method updates itself and converts older Method files when it runs them. When the user asks whether a Method works, or asks you to make it work, run it with the inputs of a recent run (`--inputs-from RUN_ID`) and show the result and the dashboard link in a few sentences. Say that it works only after a run completed.\n14. **One file for each Method.** Change and run a Method in its own file. Do not copy it to a temporary or other folder to change it: Method does not run or save the copy while the Method's file exists, and names that file.\n15. **Questions in a run are for the user.** When a run stops with `needs_input`, ask the user its `question` in plain words, wait for the answer, and continue the run with it as the output says. Never answer it yourself.\n16. **Make each run easy to find and to run again.** Give the Method a `run_label` that tells its runs apart, such as `inputs.topic`. When an input can be empty and a default picks the value, point `run_label` at the step output that holds the resolved value, not at the input. Put the readable output, such as the report text or the message, in `result`, not only in files. Write a `run_prompt` that says where each input comes from (for example \"as_of is today's date in YYYY-MM-DD\") and what to show at the end. Leave SDK, runtime, and version details out of it.\n17. **Run again from the dashboard.** When the user pastes a \"Run again\" prompt from the dashboard, run with `--inputs-from RUN_ID` and change only what the prompt names: put those values in a file and add `--inputs FILE`.\n\nWhen a run fails, read failure.headline and failure.next, change what they name, and run again.\n";
+export declare const firstMethodRules = "# Build a Method\n\n1. **Sign in first.** Run `method status`. If it is not signed in, run `method login` and let the user approve in the browser. Signed in, model and classification steps need no keys, each run saves a version when the file changed, and runs appear on the dashboard.\n2. **Each model or classifier request is its own step**: `call`, `agent`, or `classify`, with its prompt in the Method, so the user can change one prompt, run again, and compare. A script never calls a model API. When the user already has code that does the work, keep its fixed logic as `run` steps and move each prompt and rubric into its own step; do not wrap the code. \"The same thing\" means the same behavior in steps. If a request cannot become a step because Method lacks a feature, tell the user what is missing.\n3. **Show the design, then build it in the same turn.** Show each step with its type, purpose, and output, and a table of the prompts, instructions, and rubrics in the user's existing work, each with the steps that receive it. Do not wait for approval unless the user asked to approve first. Ask only for information that you cannot find and that would change the design.\n4. **Run early and often.** Write the first steps, validate, run, then add the next steps. Fix errors. Fix each warning, or accept it with the user's reason. Never add a check only to remove a warning. A new run reuses every step whose definition and inputs did not change, so each run executes only what changed. `--rerun STEP` runs a step again anyway; `--fresh` runs every step.\n5. **Keep the inputs of the existing code.** If the code takes an ID and looks up the record, the Method takes the same ID and looks it up the same way.\n6. **Keep the user's rules word for word.** When you convert an agent, a prompt, a playbook, or a guide that the user wrote, copy each of their instruction files unchanged beside the Method and list them in `files`. A run step reads them and returns their complete text, and every model step that applies them receives that text in `in`. Each step prompt says the step's own task and tells the model to follow every rule in that text. Do not reword, shorten, summarize, or split the user's rules, and do not leave one out as background: a reworded rule can change its meaning, for example when a condition (\"only when\", \"unless\", \"after\") or an exception is lost. In the table of rule 3, list each instruction file with the steps that receive it.\n7. **Compare with the old agent before the Method replaces it.** Choose 3 to 5 sample inputs from the user's data, including the hard ones. Run the old agent as the user runs it and run the Method on the same inputs, and show the user every difference side by side. Fix each difference that the user does not accept, and run again. Do not say that the Method replaces the old agent, or does what it did, until the user has seen this comparison.\n8. **Use the defaults without asking.** Model steps that name no model run on the user's own Claude Code or Codex subscription when one is signed in (hosted models on account credit only when none is), and `classify` uses Method's classifier, so no model or classifier keys are needed. To keep the model that existing code uses, add `models: {writer: provider/model}` to the Method and use `model: writer` in the steps (or `model: provider/model` on the step); it needs no key. Keep the models that the Method or the existing code names: when a model step fails, show the error and ask before you change its model. Run records go to the user's account. Set `run_data: device` only when the user explicitly asks for it. If they do ask for it, get confirmation from them and tell them in one line that the dashboard will no longer show inputs or results, and that improvements, Run now and Method Cloud stop working.\n9. **Keys stay out of chat.** Declare each key that a script needs under `secrets:` with its purpose; every script of the Method receives all of its declared secrets. Run `method secret find` in the Method's folder: it lists the key files nearby and the names in each, never the values, and prints the import command. Run that command and tell the user which file each key came from: the key stays on this computer, so there is nothing to ask. If it finds nothing, ask the user to run `method secret set NAME`, which opens a private form in their browser. Never open, print, or search a key file (`cat`, `grep`, an editor), including Method's own secret store, and never ask for a value in chat: the values would go into the chat. When a run says Method's model credit is used up, run `method config model-key` yourself: it takes the user's own OpenRouter key from the one nearby key file that holds it, or opens a private form for it. Then run again.\n10. **Choose a sample yourself** from the user's data, and check that it has the sources the Method needs. Ask only when there is no good sample.\n11. **Iterate.** `method run` prints a `dashboard` link when the run starts and again with its result. Give the user the link as soon as the run starts. After a good run, show the result and the link, and ask what to change. Change the step and run again. Show only results that a run made: never write or edit a result by hand, and fix a wrong result in the Method, not in the data it reads. If you cannot run, say so.\n12. **Publish** with `method publish FILE --reason TEXT` when the user wants to share or schedule a version. It runs the Method's cases first.\n13. **Talk about the work, not about Method.** Unless the user asks, do not mention Method's versions, formats, settings files, or other internal files, and do not ask the user about them, about models, or about which saved version to use. Method updates itself and converts older Method files when it runs them. When the user asks whether a Method works, or asks you to make it work, run it with the inputs of a recent run (`--inputs-from RUN_ID`) and show the result and the dashboard link in a few sentences. Say that it works only after a run completed.\n14. **One file for each Method.** Change and run a Method in its own file. Do not copy it to a temporary or other folder to change it: Method does not run or save the copy while the Method's file exists, and names that file.\n15. **Questions in a run are for the user.** When a run stops with `needs_input`, ask the user its `question` in plain words, wait for the answer, and continue the run with it as the output says. Never answer it yourself.\n16. **Make each run easy to find and to run again.** Give the Method a `run_label` that tells its runs apart, such as `inputs.topic`. When an input can be empty and a default picks the value, point `run_label` at the step output that holds the resolved value, not at the input. Put the readable output, such as the report text or the message, in `result`, not only in files. Write a `run_prompt` that says where each input comes from (for example \"as_of is today's date in YYYY-MM-DD\") and what to show at the end. Leave SDK, runtime, and version details out of it.\n17. **Run again from the dashboard.** When the user pastes a \"Run again\" prompt from the dashboard, run with `--inputs-from RUN_ID` and change only what the prompt names: put those values in a file and add `--inputs FILE`.\n\nWhen a run fails, read failure.headline and failure.next, change what they name, and run again.\n";
 /** How to write the prompt inside a call, agent, or classify step. */
 export declare const promptRules = "# Write each prompt\n\n- **One task per prompt.** If a prompt says \"then\" or has several jobs, make several steps. Split the tasks, not the user's rules: every step that applies them receives all of them, word for word.\n- **Say what to do.** Leave out background that does not change the output. The user's own rules and instructions are not background: pass them unchanged as an input, and do not restate them in your own words.\n- **Show 1 to 3 examples of good output.** Take them from the user's work: examples in an existing prompt, a past output that the user approved, or the first run that the user accepts. Pass a long example as an input, not as text in the prompt.\n- **Put the output shape in `out`**, not in the prompt.\n- **Say what to do when the input does not have the answer**, for example \"leave due empty\". For classify, add an option such as `unclear`.\n\nBefore:\n\n```text\nYou are an expert support analyst with years of experience. Our company values clear\ncommunication. Read the tickets, decide which ones are urgent, write a summary, and\nreturn JSON with a \"summary\" key. Make it good.\n```\n\nAfter (urgency is a classify step before this one; the shape is in `out`):\n\n```text\nWrite a five-sentence summary of this week's support tickets for the team.\nStart with the high-urgency tickets. Quote no customer names.\nWrite it in the style of this summary from an earlier week:\n\n{{example}}\n```\n";
 /** Enough of the format to write a Method without reading the JSON schema. */
-export declare const fieldReference = "# Field reference\n\n```text\nformat: method/3.4\nname, goal          text\ninputs              {NAME: DATA}           values the run receives (--inputs FILE)\nsecrets             {NAME: purpose}        keys that scripts receive as environment variables\nenvironment         {NAME: {type: files | service | browser | desktop | tool, description}}\nfiles               [PATH]                 helper files that scripts import or read\nsteps               {ID: STEP}\nresult              REF, or {NAME: REF}\nrun_data            account (default) | device   device only when the user explicitly asks; it turns off dashboard results, improvements, Run now and Method Cloud\n\nDATA   {type: text | number | boolean | record | list | file, description,\n        fields: {NAME: TYPE}   (a record, or a list of records)\n        items: TYPE            (a list of one type)\n        default: VALUE}        A bare type such as text works inside fields and items.\nREF    inputs.NAME | an output NAME | NAME.field | state.NAME | environment.NAME\n\nSTEP   name, purpose          give a run step both; purpose states its rules, result, and external changes\n       in: {ALIAS: REF}       the values that the step receives\n       each: {ITEM: LIST_REF} run once per item; ITEM is given to the step, so do not repeat it in in\n       concurrency: 1-32      items at once, for an each step that changes nothing\n       when: BOOLEAN_REF      after: ID or [ID]      repeat: {max_iterations, until: BOOLEAN_OUTPUT}\n       do: one of\n         {kind: run, runtime: python | node, entrypoint: FILE, args: [...]}\n             reads one JSON object (its in) on stdin, prints one JSON object (its out); files go under $METHOD_OUTPUT_DIR\n         {kind: call, model: NAME, prompt: TEXT}\n             the step's in go to the model as JSON; {{ALIAS}} puts a text, number, or boolean value into the prompt\n         {kind: agent, model: NAME, prompt: TEXT, tools: [TOOL]}\n         {kind: classify, question: TEXT, options: {ID: description}}   value: {choice, probabilities}\n         {kind: classify, question: TEXT, answer: yes_no}                value: {answer, probability} (of yes)\n         {kind: classify, question: TEXT, levels: [LOW, ..., HIGH]}      value: {level, score, probabilities}; 2-10 levels\n             Do counting, math, and date comparisons in a run step; the classifier reads the question literally. Choose thresholds from a few labeled samples.\n       ask: TEXT              in place of do: a question for the user\n       out: {NAME: DATA}      (classify: out: NAME)\n       changes: [state.NAME | environment.NAME]; a service change needs effects or no_effect_reason\n       check, limits: {timeout_ms, max_model_requests, max_agent_turns}\n       accept: {CODE: reason}   keep a warning or note with the user's reason\n\nmodels: {NAME: provider/model | {model, max_output_tokens, reasoning_effort}}   hosted models; no key. A step without model uses the account default.\n        NAME: {agent: codex | claude, model, reasoning_effort}   a step with model: NAME runs on that local agent (it must be installed); --agent still overrides.\nlimits: {timeout_ms, max_model_requests, max_invocations, max_tool_calls, max_concurrency, ..., step: {timeout_ms, max_agent_turns, max_model_requests}}\ntools:  {NAME: {description, in, out, run, effects}}   script tools that agent steps list in tools\nid: wf_...   written by the CLI at the first signed-in save; keep it. method new-id FILE makes a copy a new Method.\nConnections: a files connection uses the folder NAME beside the Method, or method bind FILE NAME --file PATH (this computer only).\nIssues: errors block; warnings and notes do not.\n```\n\n`method schema method` prints the complete JSON schema.\n";
+export declare const fieldReference = "# Field reference\n\n```text\nformat: method/3.4\nname, goal          text\ninputs              {NAME: DATA}           values the run receives (--inputs FILE)\nsecrets             {NAME: purpose}        keys that scripts receive as environment variables\nenvironment         {NAME: {type: files | service | browser | desktop | tool, description}}\nfiles               [PATH]                 helper files that scripts import or read\nsteps               {ID: STEP}\nresult              REF, or {NAME: REF}\nrun_data            account (default) | device   device only when the user explicitly asks; it turns off dashboard results, improvements, Run now and Method Cloud\n\nDATA   {type: text | number | boolean | record | list | file, description,\n        fields: {NAME: TYPE}   (a record, or a list of records)\n        items: TYPE            (a list of one type)\n        default: VALUE}        A bare type such as text works inside fields and items.\nREF    inputs.NAME | an output NAME | NAME.field | state.NAME | environment.NAME\n\nSTEP   name, purpose          give a run step both; purpose states its rules, result, and external changes\n       in: {ALIAS: REF}       the values that the step receives\n       each: {ITEM: LIST_REF} run once per item; ITEM is given to the step, so do not repeat it in in\n       concurrency: 1-32      items at once, for an each step that changes nothing\n       when: BOOLEAN_REF      after: ID or [ID]      repeat: {max_iterations, until: BOOLEAN_OUTPUT}\n       do: one of\n         {kind: run, runtime: python | node, entrypoint: FILE, args: [...]}\n             reads one JSON object (its in) on stdin, prints one JSON object (its out); files go under $METHOD_OUTPUT_DIR\n         {kind: call, model: NAME, prompt: TEXT}\n             the step's in go to the model as JSON; {{ALIAS}} puts a text, number, or boolean value into the prompt\n         {kind: agent, model: NAME, prompt: TEXT, tools: [TOOL]}\n         {kind: classify, question: TEXT, options: {ID: description}}   value: {choice, probabilities}\n         {kind: classify, question: TEXT, answer: yes_no}                value: {answer, probability} (of yes)\n         {kind: classify, question: TEXT, levels: [LOW, ..., HIGH]}      value: {level, score, probabilities}; 2-10 levels\n             Do counting, math, and date comparisons in a run step; the classifier reads the question literally. Choose thresholds from a few labeled samples.\n       ask: TEXT              in place of do: a question for the user\n       out: {NAME: DATA}      (classify: out: NAME)\n       changes: [state.NAME | environment.NAME]; a service change needs effects or no_effect_reason\n       check, limits: {timeout_ms, max_model_requests, max_agent_turns}\n       accept: {CODE: reason}   keep a warning or note with the user's reason\n\nmodels: {NAME: provider/model | {model, max_output_tokens, reasoning_effort}}   hosted models; no key. A step without model runs on your Claude Code or Codex, else the account default.\n        NAME: {agent: codex | claude, model, reasoning_effort}   a step with model: NAME runs on that local agent (it must be installed).\nlimits: {timeout_ms, max_model_requests, max_invocations, max_tool_calls, max_concurrency, ..., step: {timeout_ms, max_agent_turns, max_model_requests}}\ntools:  {NAME: {description, in, out, run, effects}}   script tools that agent steps list in tools\nid: wf_...   written by the CLI at the first signed-in save; keep it. method new-id FILE makes a copy a new Method.\nConnections: a files connection uses the folder NAME beside the Method, or method bind FILE NAME --file PATH (this computer only).\nIssues: errors block; warnings and notes do not.\n```\n\n`method schema method` prints the complete JSON schema.\n";
 export declare const designExamples = "# Contrasting design outlines\n\nThese are design outlines, not runnable Method files.\n\n| Request | Design | Explanation |\n| --- | --- | --- |\n| Summarize supplied text | call \u2192 return summary | The model receives all source text. Add a save step only if a saved file is requested. Use an agent if it must find or inspect additional sources. |\n| Investigate a claim | agent to research and assess \u2192 return findings | Add a separate planning, checking, or saving step only when the task needs that boundary or result. When the user requires that the findings say only what the sources say, add an agent check on the assess step (method authoring recipes). |\n| Route a message with human review for low confidence | classify \u2192 threshold run \u2192 conditional ask | Classification returns probabilities. Code applies the threshold. Human input resolves cases below the threshold. Add a separate action with an effect if the Method must send or change anything. |\n| Send a daily summary email | call to write \u2192 run to send, with an effect | The send script puts METHOD_OPERATION_ID in the Message-ID. A mail.delivery effect searches the bounce mailbox through its own read-only connection until a 5-day horizon. A bounce fails the run; no bounce by the horizon is unrefuted, not proven. |\n";
 /** Cost rules for a design; in concepts, not in the start of the guide. */
-export declare const costRules = "Before describing execution cost, check how the model steps run. With hosted models, a call is one request without tools, and an agent step can make several requests and use tools. With --agent, each model step starts a local agent process. State the expected model requests and agent processes when they are known; mark unknown counts as unknown.";
+export declare const costRules = "Before describing execution cost, check how the model steps run. A step that names no model runs on the user's Claude Code or Codex subscription when one is signed in on the computer (one local agent process per step; no account credit); otherwise on the account's hosted model. With hosted models, a call is one request without tools, and an agent step can make several requests and use tools, paid from account credit. A step on a models: entry with agent: codex or claude starts that local agent process. State the expected model requests and agent processes when they are known; mark unknown counts as unknown.";
 /** What to watch after a Method works. */
 export declare const watchRules = "# Watch it\n\n- Look at failed and unconfirmed runs on the dashboard. A run that needs attention says which step failed and why.\n- For classify, watch how often the choice is `unclear` or below your threshold. A rise means the inputs changed.\n- For slow effects such as email delivery, schedule `method observe --pending`.\n";
 /** What to do after a Method works: production, improvement, and script cards. */
-export declare const afterRules = "# After it works\n\n- **Put it in an app:** `method connect APP_FOLDER` publishes it and prints the code to add.\n- **Record each reaction:** after you show a result, run `method judge RUN_ID wrong --note \"THEIR WORDS\"` (with `--corrected FILE` when they gave the right result) when the user corrects it or asks to change the Method because of it, and `method judge RUN_ID right` when they use or approve it. Do not ask them to confirm it. Method fixes the Method from wrong judgments; `method changes FILE` lists what it changed. For a Method that keeps run content on this computer, `method improve FILE --note TEXT` makes a local proposal and `method apply FILE` merges it.\n- **Explain the scripts:** `method explain FILE` writes a card for each script step.\n";
+export declare const afterRules = "# After it works\n\n- **Put it in an app:** `method connect APP_FOLDER` publishes it and prints the code to add.\n- **Record each reaction:** after you show a result, run `method judge RUN_ID wrong --note \"THEIR WORDS\"` (with `--corrected FILE` when they gave the right result) when the user corrects it or asks to change the Method because of it, and `method judge RUN_ID right` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction: a wrong judgment fixes the Method on this computer, with the user's own Claude Code or Codex, and prints one line about what changed or why nothing did. `method changes FILE` lists what it changed.\n- **Explain the scripts:** `method explain FILE` writes a card for each script step.\n";
 export declare const exampleSelection = "After choosing the step types, read the examples that fit the design. Use their syntax; choose the steps for this task yourself.";

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

@@ -36,7 +36,7 @@ export const firstMethodRules = `# Build a Method
 5. **Keep the inputs of the existing code.** If the code takes an ID and looks up the record, the Method takes the same ID and looks it up the same way.
 6. **Keep the user's rules word for word.** When you convert an agent, a prompt, a playbook, or a guide that the user wrote, copy each of their instruction files unchanged beside the Method and list them in \`files\`. A run step reads them and returns their complete text, and every model step that applies them receives that text in \`in\`. Each step prompt says the step's own task and tells the model to follow every rule in that text. Do not reword, shorten, summarize, or split the user's rules, and do not leave one out as background: a reworded rule can change its meaning, for example when a condition ("only when", "unless", "after") or an exception is lost. In the table of rule 3, list each instruction file with the steps that receive it.
 7. **Compare with the old agent before the Method replaces it.** Choose 3 to 5 sample inputs from the user's data, including the hard ones. Run the old agent as the user runs it and run the Method on the same inputs, and show the user every difference side by side. Fix each difference that the user does not accept, and run again. Do not say that the Method replaces the old agent, or does what it did, until the user has seen this comparison.
-8. **Use the defaults without asking.** Model steps use the account's hosted models and \`classify\` uses Method's classifier, so no model or classifier keys are needed. To keep the model that existing code uses, add \`models: {writer: provider/model}\` to the Method and use \`model: writer\` in the steps (or \`model: provider/model\` on the step); it needs no key. Keep the models that the Method or the existing code names: when a model step fails, show the error and ask before you change its model. Run records go to the user's account. Set \`run_data: device\` only when the user explicitly asks for it. If they do ask for it, get confirmation from them and tell them in one line that the dashboard will no longer show inputs or results, and that improvements, Run now and Method Cloud stop working.
+8. **Use the defaults without asking.** Model steps that name no model run on the user's own Claude Code or Codex subscription when one is signed in (hosted models on account credit only when none is), and \`classify\` uses Method's classifier, so no model or classifier keys are needed. To keep the model that existing code uses, add \`models: {writer: provider/model}\` to the Method and use \`model: writer\` in the steps (or \`model: provider/model\` on the step); it needs no key. Keep the models that the Method or the existing code names: when a model step fails, show the error and ask before you change its model. Run records go to the user's account. Set \`run_data: device\` only when the user explicitly asks for it. If they do ask for it, get confirmation from them and tell them in one line that the dashboard will no longer show inputs or results, and that improvements, Run now and Method Cloud stop working.
 9. **Keys stay out of chat.** Declare each key that a script needs under \`secrets:\` with its purpose; every script of the Method receives all of its declared secrets. Run \`method secret find\` in the Method's folder: it lists the key files nearby and the names in each, never the values, and prints the import command. Run that command and tell the user which file each key came from: the key stays on this computer, so there is nothing to ask. If it finds nothing, ask the user to run \`method secret set NAME\`, which opens a private form in their browser. Never open, print, or search a key file (\`cat\`, \`grep\`, an editor), including Method's own secret store, and never ask for a value in chat: the values would go into the chat. When a run says Method's model credit is used up, run \`method config model-key\` yourself: it takes the user's own OpenRouter key from the one nearby key file that holds it, or opens a private form for it. Then run again.
 10. **Choose a sample yourself** from the user's data, and check that it has the sources the Method needs. Ask only when there is no good sample.
 11. **Iterate.** \`method run\` prints a \`dashboard\` link when the run starts and again with its result. Give the user the link as soon as the run starts. After a good run, show the result and the link, and ask what to change. Change the step and run again. Show only results that a run made: never write or edit a result by hand, and fix a wrong result in the Method, not in the data it reads. If you cannot run, say so.
@@ -117,8 +117,8 @@ STEP   name, purpose          give a run step both; purpose states its rules, re
        check, limits: {timeout_ms, max_model_requests, max_agent_turns}
        accept: {CODE: reason}   keep a warning or note with the user's reason
 
-models: {NAME: provider/model | {model, max_output_tokens, reasoning_effort}}   hosted models; no key. A step without model uses the account default.
-        NAME: {agent: codex | claude, model, reasoning_effort}   a step with model: NAME runs on that local agent (it must be installed); --agent still overrides.
+models: {NAME: provider/model | {model, max_output_tokens, reasoning_effort}}   hosted models; no key. A step without model runs on your Claude Code or Codex, else the account default.
+        NAME: {agent: codex | claude, model, reasoning_effort}   a step with model: NAME runs on that local agent (it must be installed).
 limits: {timeout_ms, max_model_requests, max_invocations, max_tool_calls, max_concurrency, ..., step: {timeout_ms, max_agent_turns, max_model_requests}}
 tools:  {NAME: {description, in, out, run, effects}}   script tools that agent steps list in tools
 id: wf_...   written by the CLI at the first signed-in save; keep it. method new-id FILE makes a copy a new Method.
@@ -140,7 +140,7 @@ These are design outlines, not runnable Method files.
 | Send a daily summary email | call to write → run to send, with an effect | The send script puts METHOD_OPERATION_ID in the Message-ID. A mail.delivery effect searches the bounce mailbox through its own read-only connection until a 5-day horizon. A bounce fails the run; no bounce by the horizon is unrefuted, not proven. |
 `;
 /** Cost rules for a design; in concepts, not in the start of the guide. */
-export const costRules = "Before describing execution cost, check how the model steps run. With hosted models, a call is one request without tools, and an agent step can make several requests and use tools. With --agent, each model step starts a local agent process. State the expected model requests and agent processes when they are known; mark unknown counts as unknown.";
+export const costRules = "Before describing execution cost, check how the model steps run. A step that names no model runs on the user's Claude Code or Codex subscription when one is signed in on the computer (one local agent process per step; no account credit); otherwise on the account's hosted model. With hosted models, a call is one request without tools, and an agent step can make several requests and use tools, paid from account credit. A step on a models: entry with agent: codex or claude starts that local agent process. State the expected model requests and agent processes when they are known; mark unknown counts as unknown.";
 /** What to watch after a Method works. */
 export const watchRules = `# Watch it
 
@@ -152,7 +152,7 @@ export const watchRules = `# Watch it
 export const afterRules = `# After it works
 
 - **Put it in an app:** \`method connect APP_FOLDER\` publishes it and prints the code to add.
-- **Record each reaction:** after you show a result, run \`method judge RUN_ID wrong --note "THEIR WORDS"\` (with \`--corrected FILE\` when they gave the right result) when the user corrects it or asks to change the Method because of it, and \`method judge RUN_ID right\` when they use or approve it. Do not ask them to confirm it. Method fixes the Method from wrong judgments; \`method changes FILE\` lists what it changed. For a Method that keeps run content on this computer, \`method improve FILE --note TEXT\` makes a local proposal and \`method apply FILE\` merges it.
+- **Record each reaction:** after you show a result, run \`method judge RUN_ID wrong --note "THEIR WORDS"\` (with \`--corrected FILE\` when they gave the right result) when the user corrects it or asks to change the Method because of it, and \`method judge RUN_ID right\` when they use or approve it. Do not ask them to confirm it, and do not edit the Method yourself for the same correction: a wrong judgment fixes the Method on this computer, with the user's own Claude Code or Codex, and prints one line about what changed or why nothing did. \`method changes FILE\` lists what it changed.
 - **Explain the scripts:** \`method explain FILE\` writes a card for each script step.
 `;
 export const exampleSelection = "After choosing the step types, read the examples that fit the design. Use their syntax; choose the steps for this task yourself.";

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

@@ -158,7 +158,7 @@ export async function localAuthoring(args) {
             }
             const workflow = loadWorkflow((await import("./versions.js")).methodContent(readDocument(file)));
             definition = "valid";
-            const { config, sourceRoot, agent } = await localSetup(file, v);
+            const { config, sourceRoot } = await localSetup(file, v);
             const declared = Object.keys(workflow.secrets ?? {});
             const secrets = (await import('./secrets.js')).resolveSecrets(declared);
             const { MethodClient } = await import("./method-client.js");
@@ -179,17 +179,19 @@ export async function localAuthoring(args) {
             // What each step executes, and what it still needs on this computer.
             const missingSecrets = declared.filter(name => !secrets[name]);
             const ownKey = (await import("./own-model-key.js")).ownKeyEnv();
+            // Steps that name no model run on the user's own Claude Code or Codex when one is signed in, as in method run.
+            const agent = await (await import("@withmethod/runtime/agents.js")).localAgent();
+            const agentName = agent === "claude" ? "Claude Code" : "Codex";
             const steps = Object.entries(workflow.steps).map(([id, step]) => {
                 const exec = step.do, named = workflow.models?.[exec?.model] ?? (isModelId(exec?.model) ? exec.model : undefined);
                 const profile = named?.agent ? { backend: named.agent, model: named.model } : named ? { backend: "method", model: typeof named === "string" ? named : named.model } : config.models?.[exec?.model] ?? (exec?.model === "default" ? undefined : config.models?.default);
                 const runs = step.ask ? "asks the user"
                     : exec.kind === "run" ? `${exec.runtime} ${exec.entrypoint}`
                         : exec.kind === "classify" ? (config.classification?.api_key_env || ownKey ? "Jev through OpenRouter with your own key" : "Method's classifier")
-                            // The computer's agent setting (or --agent) runs every model step, whatever model the Method names.
-                            : agent && ["call", "agent"].includes(exec.kind) ? agent
-                                : profile?.backend === "method" ? (ownKey && !agent ? `${profile.model} through OpenRouter with your own key` : `the hosted model ${profile.model}`)
-                                    : profile ? `${profile.backend}${profile.model ? ` ${profile.model}` : ""}`
-                                        : signedIn ? (ownKey && !agent ? "the account's default model through OpenRouter with your own key" : "the account's hosted model") : "a local Codex or Claude agent";
+                            : profile?.backend === "method" ? (ownKey ? `${profile.model} through OpenRouter with your own key` : `the hosted model ${profile.model}`)
+                                : profile ? `${profile.backend}${profile.model ? ` ${profile.model}` : ""}`
+                                    : agent ? `${agentName} with your own subscription`
+                                        : signedIn ? (ownKey ? "the account's default model through OpenRouter with your own key" : "the account's hosted model on account credit") : "Claude Code or Codex once one is signed in on this computer";
                 const needs = [...(exec?.kind === "run" ? missingSecrets.map(name => `secret ${name}`) : []),
                     ...(!signedIn && (exec?.kind === "classify" && !config.classification?.api_key_env && !ownKey || ["call", "agent"].includes(exec?.kind) && !profile && !agent) ? [`method login (for ${exec.kind === "classify" ? "classification" : "hosted models"})`] : [])];
                 return { id, runs, ...(needs.length ? { needs } : {}) };

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

@@ -1,13 +1,16 @@
 /** Check supported agent access without starting a model request. Custom commands remain operator-owned. */
 export declare function checkAgents(profiles: Record<string, any>): Promise<void>;
 /**
- * The model profiles of a run. With this computer's own model key (method config model-key) and no local agent,
- * hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
+ * The model profiles of a run, chosen by the runtime (resolveModels): a model that the Method names, else the user's
+ * own Claude Code or Codex, else hostedModel on account credit. With this computer's own model key (method config
+ * model-key), hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
  */
-export declare function resolveAgentProfiles(method: any, config: any, agent?: string, hostedModel?: string): Promise<any>;
-/** What a run needs from the Method account: hosted models for unconfigured call and agent steps, and classification. */
-export declare function accountNeeds(method: any, config: any, agent?: string): {
+export declare function resolveAgentProfiles(method: any, config: any, hostedModel?: string): Promise<any>;
+/**
+ * What a run may need from the Method account: hosted models for call and agent steps that name no model (used only
+ * when no local agent can run them), and classification.
+ */
+export declare function accountNeeds(method: any, config: any): {
     models: boolean;
     classification: boolean;
 };
-export declare function checkConfiguration(config: any): Promise<void>;

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

@@ -1,7 +1,4 @@
-import { resolveModels } from '@withmethod/runtime/agents.js';
-import { executable } from '@withmethod/runtime/io.js';
-import { directBackends } from '@withmethod/runtime/model.js';
-import { command } from './prepare.js';
+import { agentSignedIn, resolveModels } from '@withmethod/runtime/agents.js';
 import { announceOwnKey, loadOwnKey, ownKeyClassification, ownKeyEnv } from './own-model-key.js';
 /** Check supported agent access without starting a model request. Custom commands remain operator-owned. */
 export async function checkAgents(profiles) {
@@ -10,28 +7,22 @@ export async function checkAgents(profiles) {
         if (!['codex', 'claude'].includes(profile.backend) || profile.command || checked.has(profile.backend))
             continue;
         checked.add(profile.backend);
-        try {
-            const result = await command(profile.backend, profile.backend === 'codex' ? ['login', 'status'] : ['auth', 'status'], process.cwd());
-            if (profile.backend === 'claude' && JSON.parse(result.stdout).loggedIn !== true)
-                throw Error('Not signed in.');
-        }
-        catch (error) {
-            throw Object.assign(Error(`${profile.backend} access check failed. Sign in with ${profile.backend}, then continue this run. ${error.message}`), { code: 'needs_input' });
-        }
+        if (!await agentSignedIn(profile.backend))
+            throw Object.assign(Error(`${profile.backend} is not installed or not signed in. Sign in with ${profile.backend}, then continue this run.`), { code: 'needs_input' });
     }
 }
 /**
- * The model profiles of a run. With this computer's own model key (method config model-key) and no local agent,
- * hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
+ * The model profiles of a run, chosen by the runtime (resolveModels): a model that the Method names, else the user's
+ * own Claude Code or Codex, else hostedModel on account credit. With this computer's own model key (method config
+ * model-key), hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
  */
-export async function resolveAgentProfiles(method, config, agent, hostedModel) {
-    const profiles = await resolveModels(method, config, { agent, hostedModel });
+export async function resolveAgentProfiles(method, config, hostedModel) {
+    const profiles = await resolveModels(method, config, { hostedModel });
     const env = ownKeyEnv();
     if (!env)
         return profiles;
     const classifies = Object.values(method.steps ?? {}).some((step) => [step?.do, step?.check].some(exec => exec?.kind === 'classify'));
-    // A local agent (--agent) runs the model steps; the own key still classifies.
-    const hosted = !agent && Object.values(profiles).some((profile) => profile?.backend === 'method');
+    const hosted = Object.values(profiles).some((profile) => profile?.backend === 'method');
     if (!hosted && !classifies)
         return profiles;
     if (classifies && !config.classification?.api_key_env)
@@ -41,8 +32,11 @@ export async function resolveAgentProfiles(method, config, agent, hostedModel) {
     announceOwnKey();
     return profiles;
 }
-/** What a run needs from the Method account: hosted models for unconfigured call and agent steps, and classification. */
-export function accountNeeds(method, config, agent) {
+/**
+ * What a run may need from the Method account: hosted models for call and agent steps that name no model (used only
+ * when no local agent can run them), and classification.
+ */
+export function accountNeeds(method, config) {
     // Every run asks this first, a resumed one too: the own key's value comes from the device store by name.
     const env = ownKeyEnv();
     if (env)
@@ -51,18 +45,7 @@ export function accountNeeds(method, config, agent) {
     const execs = steps.flatMap(step => [step.do, step.check]).filter(exec => exec?.kind);
     return {
         // A step on a local-agent entry of the Method's models needs no account.
-        models: !agent && !config.models?.default && execs.some(exec => ['call', 'agent'].includes(exec.kind) && !config.models?.[exec.model] && !method.models?.[exec.model ?? 'default']?.agent),
+        models: !config.models?.default && execs.some(exec => ['call', 'agent'].includes(exec.kind) && !config.models?.[exec.model] && !method.models?.[exec.model ?? 'default']?.agent),
         classification: execs.some(exec => exec.kind === 'classify') && !config.classification?.api_key_env && !env,
     };
 }
-export async function checkConfiguration(config) {
-    for (const profile of Object.values(config.runtimes ?? {}))
-        await executable(profile.command);
-    for (const profile of Object.values(config.models ?? {})) {
-        if (directBackends.includes(profile.backend) && profile.backend !== 'method' && !process.env[profile.api_key_env])
-            throw Error(`Missing environment variable: ${profile.api_key_env}`);
-        if (['codex', 'claude'].includes(profile.backend))
-            await executable(profile.command ?? profile.backend);
-    }
-    await checkAgents(config.models ?? {});
-}

package/dist/packages/sdk/src/computer-settings.d.ts

@@ -3,26 +3,23 @@ import { z } from 'zod';
 export declare const configRoot: () => string;
 export declare const computerFile: () => string;
 declare const Settings: z.ZodObject<{
-    agent: z.ZodOptional<z.ZodEnum<["codex", "claude"]>>;
     bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
     classification_key_env: z.ZodOptional<z.ZodString>;
     model_key_env: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     bindings: Record<string, Record<string, string>>;
-    agent?: "codex" | "claude" | undefined;
     classification_key_env?: string | undefined;
     model_key_env?: string | undefined;
 }, {
-    agent?: "codex" | "claude" | undefined;
     bindings?: Record<string, Record<string, string>> | undefined;
     classification_key_env?: string | undefined;
     model_key_env?: string | undefined;
 }>;
 export type ComputerSettings = z.infer<typeof Settings>;
-/** The settings of this computer: the local agent, connection bindings, and an own model key. Nothing in a Method file. */
+/** The settings of this computer: connection bindings and an own model key. Nothing in a Method file. */
 export declare function readComputerSettings(): ComputerSettings;
 export declare function updateComputerSettings(change: (settings: ComputerSettings) => void): ComputerSettings;
 export declare function bindConnectionValue(methodId: string, name: string, value: string): void;
-/** method config: print the computer settings, set the local agent, or turn the own model key on or off. */
+/** method config: print the computer settings, or turn the own model key on or off. */
 export declare function configCommand(args: string[]): Promise<void>;
 export {};

package/dist/packages/sdk/src/computer-settings.js

@@ -8,7 +8,6 @@ export const configRoot = () => process.env.METHOD_CONFIG_DIR || join(homedir(),
 export const computerFile = () => join(configRoot(), 'computer.json');
 // Only settings of this computer. Run limits belong to each Method (format 3.4 limits), never to the computer.
 const Settings = z.object({
-    agent: z.enum(['codex', 'claude']).optional(),
     // METHOD_ID -> connection name -> a folder path, or a connection value (URL or method-browser:NAME).
     bindings: z.record(z.string(), z.record(z.string(), z.string())).default({}),
     // The environment variable with this computer's own OpenRouter key: classify then calls Jev directly with it.
@@ -16,7 +15,7 @@ const Settings = z.object({
     // The name of this computer's own OpenRouter key (method config model-key): hosted model and classify steps use it.
     model_key_env: z.string().regex(/^[A-Z_][A-Z0-9_]*$/).optional(),
 });
-/** The settings of this computer: the local agent, connection bindings, and an own model key. Nothing in a Method file. */
+/** The settings of this computer: connection bindings and an own model key. Nothing in a Method file. */
 export function readComputerSettings() {
     const file = computerFile();
     if (!existsSync(file))
@@ -38,20 +37,14 @@ export function updateComputerSettings(change) {
 export function bindConnectionValue(methodId, name, value) {
     updateComputerSettings(settings => { settings.bindings[methodId] = { ...settings.bindings[methodId], [name]: value }; });
 }
-/** method config: print the computer settings, set the local agent, or turn the own model key on or off. */
+/** method config: print the computer settings, or turn the own model key on or off. */
 export async function configCommand(args) {
-    const [key, value, extra] = args;
+    const [key] = args;
     if (!key) {
         process.stdout.write(JSON.stringify({ file: computerFile(), ...readComputerSettings() }, null, 2) + '\n');
         return;
     }
     if (key === 'model-key')
         return (await import('./own-model-key.js')).modelKeyCommand(args.slice(1));
-    if (key !== 'agent' || !value || extra !== undefined || !['codex', 'claude', 'none'].includes(value))
-        throw Error('Use method config, method config agent codex|claude|none, or method config model-key [--off].');
-    const saved = updateComputerSettings(settings => { if (value === 'none')
-        delete settings.agent;
-    else
-        settings.agent = value; });
-    process.stdout.write(saved.agent ? `Model steps run with the local ${saved.agent} agent on this computer.\n` : 'Model steps use the Method\'s models and the account default.\n');
+    throw Error('Use method config, or method config model-key [--off].');
 }

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

@@ -4,6 +4,7 @@ import { openBrowser } from './browser.js';
 import { readFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
 import { join, dirname, resolve } from 'node:path';
 import { hostedModelsFor, managedModels } from './hosted-models.js';
+import { localAgent } from '@withmethod/runtime/agents.js';
 import { resolveSecrets } from './secrets.js';
 import { randomUUID } from 'node:crypto';
 import { assertCheckpointExecutor } from '@withmethod/runtime/executor-version.js';
@@ -14,6 +15,7 @@ import { runMethod as executeMethod } from "@withmethod/runtime/runner.js";
 import { localSetup } from "./local-setup.js";
 import { authoringPath } from "./authoring.js";
 import { failureLines } from "./failure.js";
+import { methodFileRecord } from "./local-judgments.js";
 export { executeMethod as runCurrentMethod };
 /** Recent run folders on this computer, newest first. The runtime reuses only iterations whose key matches. */
 export function recentRuns(exclude, limit = 20) {
@@ -60,7 +62,6 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
         assertCheckpointExecutor(json(join(flags['run-dir'], 'checkpoint.json')));
     const setup = await localSetup(file, flags, baseConfig);
     let config = setup.config;
-    const agent = setup.agent;
     const sourceRoot = setup.sourceRoot;
     const method = (await import('./authoring.js')).readDocument(file);
     const controller = new AbortController();
@@ -78,10 +79,16 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
         catch (error) {
             process.stderr.write(`Run records stay on this computer: ${error.message}\n`);
         }
-        // Records the start; sends nothing. The outbox starts when the run starts.
-        await sync?.start(method, json(flags.inputs) ?? {}, {}, false);
+        // Records the start; sends nothing. The outbox starts when the run starts. An inputs file that cannot be read fails
+        // the run below, with this record and no inputs.
+        let inputs = {};
+        try {
+            inputs = json(flags.inputs) ?? {};
+        }
+        catch { /* the run's setup failure */ }
+        await sync?.start(method, inputs, {}, false);
         // A run with its own OpenRouter key (config.classification.api_key_env) needs no Method sign-in for classification.
-        const needs = accountNeeds(method, config, agent);
+        const needs = accountNeeds(method, config);
         const classification = needs.classification ? managedClassification(client) : undefined;
         // Classification uses the Method account. Hosted models are used when this computer is signed in.
         if (classification && !client.token())
@@ -99,15 +106,16 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
                 config = JSON.parse(readFileSync(resolvedFile, 'utf8'));
             else {
                 let hostedModel;
-                if (needs.models && client.token()) {
+                // The hosted model is asked for only when no local agent (Claude Code or Codex) can run the model steps.
+                if (needs.models && client.token() && !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, agent, hostedModel);
+                config.models = await resolveAgentProfiles(method, config, hostedModel);
                 if (classification)
                     config.classification = await classification.resolve(controller.signal);
             }
@@ -126,9 +134,12 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
         }
         browser = await openBrowser(method, config, flags['run-dir'], controller.signal);
         const hostedModels = Object.values(config.models ?? {}).some((profile) => profile.backend === 'method') ? await hostedModelsFor(client) : undefined;
+        // The run folder records its Method file, so method judge can keep a note next to it.
+        if (flags['run-dir'])
+            writePrivateJson(join(authoringPath(flags['run-dir']), methodFileRecord), { path: authoringPath(file) });
         const result = await executeMethod(authoringPath(file), config, {
             runDir: flags["run-dir"] ? authoringPath(flags["run-dir"]) : undefined,
-            agent: agent, inputs: json(flags.inputs), state: json(flags.state), resume: flags.resume, retry: flags.retry,
+            inputs: json(flags.inputs), state: json(flags.state), resume: flags.resume, retry: flags.retry,
             cacheFrom: flags.resume ? [] : recentRuns(authoringPath(flags['run-dir'])),
             fresh: flags.fresh ? true : flags.rerun?.length ? flags.rerun.flatMap(step => step.split(',')).map(step => step.trim()).filter(Boolean) : undefined,
             secrets: { ...resolveSecrets(Object.keys(method.secrets ?? {})), ...Object.fromEntries(Object.entries(runSecrets).filter(([key]) => Object.hasOwn(method.secrets ?? {}, key))) }, ...(hostedModels ? { hostedModels } : {}),