@method-ai-hq/sdk 0.14.5 → 0.14.6

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.14.5/method-ai-hq-sdk-0.14.5.tgz
+npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.14.6/method-ai-hq-sdk-0.14.6.tgz
 npx method --version
 ```
 

package/dist/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@method-ai-hq/sdk",
-    "version": "0.14.5",
+    "version": "0.14.6",
     "description": "Build and run reusable .method files with checked steps and saved results.",
     "license": "MIT",
     "type": "module",

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

@@ -5,7 +5,7 @@ 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 and rubrics in the user's existing work, each with the step that holds 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. **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. When the user asks that run data stay on this computer or not be uploaded, set `run_data: device`: the run's inputs, outputs, and files stay here, and the account keeps only each step's status and timing. Model steps still send each step's input to the model to answer it; nothing is kept. Tell the user that in one line, then run again.\n7. **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.\n8. **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.\n9. **Iterate.** After a good run, show the result and the dashboard 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.\n10. **Publish** with `method publish FILE --reason TEXT` when the user wants to share or schedule a version. It runs the Method's cases first.\n11. **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 and show the result and the dashboard link in a few sentences. Say that it works only after a run completed.\n12. **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.\n13. **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.\n\nWhen a run fails, read its `fix` and `diagnostics`, change the step, 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 and rubrics in the user's existing work, each with the step that holds 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. **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. When the user asks that run data stay on this computer or not be uploaded, set `run_data: device`: the run's inputs, outputs, and files stay here, and the account keeps only each step's status and timing. Model steps still send each step's input to the model to answer it; nothing is kept. Tell the user that in one line, then run again.\n7. **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.\n8. **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.\n9. **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.\n10. **Publish** with `method publish FILE --reason TEXT` when the user wants to share or schedule a version. It runs the Method's cases first.\n11. **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 and show the result and the dashboard link in a few sentences. Say that it works only after a run completed.\n12. **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.\n13. **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.\n\nWhen a run fails, read its `fix` and `diagnostics`, change the step, 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.\n- **Say what to do.** Leave out background that does not change the output.\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. */

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

@@ -37,7 +37,7 @@ export const firstMethodRules = `# Build a Method
 6. **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. When the user asks that run data stay on this computer or not be uploaded, set \`run_data: device\`: the run's inputs, outputs, and files stay here, and the account keeps only each step's status and timing. Model steps still send each step's input to the model to answer it; nothing is kept. Tell the user that in one line, then run again.
 7. **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.
 8. **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.
-9. **Iterate.** After a good run, show the result and the dashboard 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.
+9. **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.
 10. **Publish** with \`method publish FILE --reason TEXT\` when the user wants to share or schedule a version. It runs the Method's cases first.
 11. **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 and show the result and the dashboard link in a few sentences. Say that it works only after a run completed.
 12. **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.

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

@@ -145,7 +145,7 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
         });
         runFailed = !['completed', 'unconfirmed'].includes(result.status);
         const synced = await sync?.finish();
-        let display = synced ? { ...result, dashboard_sync: synced } : result;
+        let display = synced ? { ...result, dashboard: sync.dashboard, dashboard_sync: synced } : result;
         // A run that waits for a person shows the question itself, so the agent can ask the user and pass on the answer.
         const question = result.status === 'needs_input' ? (await import('./worker.js')).lastQuestion(authoringPath(flags['run-dir'])) : null;
         if (question)

package/dist/packages/sdk/src/local-cli.js

@@ -82,7 +82,9 @@ async function accountSync(path, flags) {
             return undefined;
         }
         const version = await prepareVersion(client, outbox, path);
-        return { client, outbox, version, sync: () => new Sync(client, runDir, version.method_id, version.version_id, undefined, method.run_data === "device", outbox) };
+        // A run started by the run worker keeps the ID that its start line linked to.
+        const identity = join(runDir, "run-id.json"), runId = existsSync(identity) ? JSON.parse(readFileSync(identity, "utf8")).id : undefined;
+        return { client, outbox, version, sync: () => new Sync(client, runDir, version.method_id, version.version_id, runId, method.run_data === "device", outbox) };
     }
     catch (error) {
         // A copy of a Method that is saved from another file must not run: the change belongs in that file.

package/dist/packages/sdk/src/method-help.js

@@ -13,7 +13,7 @@ export const commandHelp = {
     "new-id": { usage: "method new-id FILE", purpose: "Make a copied Method file a new Method.", arguments: "Writes a new id: line. A copy that keeps its id: saves to the same Method.", result: "JSON with file and method_id.", errors: "Missing file.", example: "method new-id copy.method" },
     bind: { usage: "method bind FILE_OR_ID NAME (--file FOLDER | --connection URL) [--upload]", purpose: "Save a named input location or connection.", arguments: "Default: this computer only, in ~/.config/method/computer.json under the Method's ID (a FILE gets its id: line). A folder named NAME beside the Method needs no binding. --upload saves only the selected input folder or connection URL in the account. It never scans your disk. Keep credentials in the service's normal sign-in store.", result: "Saved binding and scope.", errors: "Missing input, invalid name, or unsafe path.", example: "method bind METHOD_ID prepared_day --file day-records --upload", remote: true },
     state: { usage: "method state ID [--enable --file state.json | --release RUN_ID]", purpose: "Read or explicitly enable shared account state.", arguments: "Accepted state updates use revision checks. Inspect a stopped run's external actions before releasing its ownership.", result: "Current revision, value, and owner run.", errors: "Concurrent ownership or stale revision. Existing state is never silently overwritten.", example: "method state METHOD_ID --enable --file initial-state.json", remote: true },
-    wait: { usage: "method wait RUN_DIRECTORY", purpose: "Reconnect to the same local worker.", arguments: "Use the directory returned by run. Closing this output connection leaves the worker active.", result: "Live output and final worker status.", errors: "Stopped process or missing run.", example: "method wait .runs/example" },
+    wait: { usage: "method wait RUN_DIRECTORY", purpose: "Reconnect to the same local worker.", arguments: "Use the directory returned by run. Closing this output connection leaves the worker active.", result: "Live output, then the final worker status with the dashboard link of a synced run.", errors: "Stopped process or missing run.", example: "method wait .runs/example" },
     'run-status': { usage: "method run-status RUN_DIRECTORY", purpose: "Read worker status without waiting.", arguments: "Local run directory.", result: "Worker status and whether its process is active.", errors: "Unreadable run directory.", example: "method run-status .runs/example" },
     cancel: { usage: "method cancel RUN_DIRECTORY", purpose: "Stop a local run process.", arguments: "Inspect uncertain external actions before any explicit retry.", result: "Cancellation request. The checkpoint remains available.", errors: "Unreadable run directory.", example: "method cancel .runs/example" },
     progress: { usage: "method progress --message TEXT [--completed N --total N --unit NAME] [--child NAME]\nmethod progress --codex --child NAME", purpose: "Report public progress from a running script or relay a child Codex JSON stream.", arguments: "METHOD_PROGRESS_FD is supplied by the executor. --codex reads JSON lines from stdin; --message sends one message. Do not include secrets or source contents.", result: "Writes to the separate progress pipe. No stdout output. No-op outside a Method process.", errors: "Invalid arguments. Malformed Codex events are ignored.", example: "method progress --message 'Rendered 12 of 40 pages' --completed 12 --total 40 --unit pages" },
@@ -65,7 +65,7 @@ export const commandHelp = {
 --fresh: run every step; reuse nothing.
 --human FILE: answers for ask steps, as {steps: {"STEP": {outputs: {...}}}} (STEP:ITERATION, counted from 0, for a step with each or repeat).
 --verbose: print runtime events.
-Use method doctor to check the installed Node and configured tools.`, result: "Progress and final status text; local result.json and run evidence; dashboard run link when synced. The runtime executes the method's declared scripts, calls, agents, and checks. Executes trusted local processes; changes declarations do not enforce permissions. Runs exit 0 on completion, 1 on failure, 2 when human input is needed, and 3 when an observer could not confirm an external change (unconfirmed).", errors: "Missing inputs/access, failed check, timeout, unsafe resume/version mismatch, upload failure. See recovery. Never retry a business write without inspecting its saved changes.", example: "method run wf_example --version v_example --inputs inputs.json", remote: true },
+Use method doctor to check the installed Node and configured tools.`, result: "When signed in, the start line and the final result have dashboard: the link to the run's page; give it to the user when the run starts. Progress and final status text; local result.json and run evidence. The runtime executes the method's declared scripts, calls, agents, and checks. Executes trusted local processes; changes declarations do not enforce permissions. Runs exit 0 on completion, 1 on failure, 2 when human input is needed, and 3 when an observer could not confirm an external change (unconfirmed).", errors: "Missing inputs/access, failed check, timeout, unsafe resume/version mismatch, upload failure. See recovery. Never retry a business write without inspecting its saved changes.", example: "method run wf_example --version v_example --inputs inputs.json", remote: true },
     observe: { usage: "method observe [RUN_DIRECTORY...] [--pending ROOT]...", purpose: "Make the effect observations that are due for finished runs.", arguments: "Without directories, checks runs with open effects under .method-runs and the Method cache. Runs only observers and judges; never repeats an action. Schedule it, for example hourly, so late evidence such as a bounce reaches the run.", result: "JSON with each run's new verdicts, status, and next observation time. A synced run whose status changed is uploaded again.", errors: "Locked run, changed bundle, or a missing observer credential.", example: "method observe --pending .method-runs" },
     test: { usage: "method test FILE [--case ID]... [--baseline OLD_FILE] [--new ID]... [--cases DIR] [--agent codex|claude]", purpose: "Replay recorded cases against this version of a Method. Every case must pass.", arguments: "Cases are in cases/ beside the Method. Unchanged steps return their recorded outputs; changed steps run; files connections are scratch folders, so a changed step that writes files runs safely. A changed step that asks a person or acts on a service makes the case unverifiable. --baseline also runs each case on the old version, to show what the change fixed or broke.", result: "JSON report with a verdict per case and passed:true when no case blocks the change. Exit 0 or 1.", errors: "Unknown case, invalid Method, or setup errors.", example: "method test task.method --baseline task-before.method --new bounce-reported" },
     case: { usage: "method case new|retire|list FILE ...", purpose: "Keep a correction as a recorded case that every later version must pass.", arguments: "Use method help case new, method help case retire, or method help case list.", result: "See the subcommand.", errors: "Unknown action. Choose new, retire, or list.", example: "method help case new" },
@@ -154,7 +154,7 @@ What this example shows:
 
 \`\`\`sh
 method validate tickets.method
-method run tickets.method --inputs inputs.json   # prints the version and dashboard links
+method run tickets.method --inputs inputs.json   # prints the run's dashboard link at the start and with the result
 # change the summary prompt, then:
 method run tickets.method --inputs inputs.json   # reuses read, urgency and join; runs summary
 \`\`\`

package/dist/packages/sdk/src/method-sync.d.ts

@@ -17,6 +17,8 @@ export declare class MethodSync {
     readonly outbox: Outbox;
     constructor(client: MethodClient, directory: string, workflowId: string, versionId: string, runId?: string, device?: boolean, outbox?: Outbox);
     get device(): boolean;
+    /** The run's dashboard page. Before the first record arrives, the page waits for it. */
+    get dashboard(): string;
     private get item();
     private save;
     private upload;
@@ -39,6 +41,8 @@ export declare class MethodSync {
     /** Send the final local record of a run. Never runs business actions. */
     static retry(directory: string, client?: MethodClient): Promise<void>;
 }
+/** The dashboard page of the run in a run folder, when the run is linked to an account. */
+export declare function runDashboard(directory: string): string | undefined;
 /**
  * The organization setting "Keep run content on devices". When it cannot be read, the run's content stays on this
  * computer: the server would refuse the content anyway when the setting is on.

package/dist/packages/sdk/src/method-sync.js

@@ -62,6 +62,10 @@ export class MethodSync {
     get device() {
         return this.state.device === true;
     }
+    /** The run's dashboard page. Before the first record arrives, the page waits for it. */
+    get dashboard() {
+        return dashboardUrl(this.state);
+    }
     get item() {
         return { kind: "run", server: this.client.server, run_dir: this.directory, version_id: this.state.version_id, pid: process.pid };
     }
@@ -99,8 +103,6 @@ export class MethodSync {
     }
     async send(payload) {
         const result = await retryTransfer(() => this.client.request(`/api/cli/runs/${this.state.id}`, "PUT", payload, true, { stallMs: 60_000 }));
-        if (!this.state.dashboard_id)
-            process.stderr.write(`Dashboard: ${this.client.server}/runs/${result.id}\n`);
         this.state.dashboard_id = result.id;
         this.save();
         this.warned = false;
@@ -267,6 +269,15 @@ export class MethodSync {
         sync.outbox.remove(sync.item);
     }
 }
+/** The dashboard page of a run: its saved ID, or before the first record, the ID that this computer gave it. */
+function dashboardUrl(state) {
+    return `${state.server}/runs/${state.dashboard_id ?? state.id}`;
+}
+/** The dashboard page of the run in a run folder, when the run is linked to an account. */
+export function runDashboard(directory) {
+    const path = join(directory, "method-sync.json");
+    return existsSync(path) ? dashboardUrl(SyncSchema.parse(JSON.parse(readFileSync(path, "utf8")))) : undefined;
+}
 async function retryTransfer(send) {
     for (let attempt = 0;; attempt++)
         try {

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

@@ -41,7 +41,15 @@ async function dispatchRunWorker(args, flags, extra = []) {
     const workerArgs = [...args.filter(arg => arg !== '--background'), ...extra];
     if (!flags['run-dir'])
         workerArgs.push('--run-dir', directory);
-    await startRunWorker(workerArgs, directory, flags.background);
+    // A new run of a signed-in computer is synced; a resumed run keeps the link that it has.
+    let server;
+    try {
+        const client = new MethodClient(flags.server);
+        if (!flags.resume && client.token())
+            server = client.server;
+    }
+    catch { /* Not signed in to this server. */ }
+    await startRunWorker(workerArgs, directory, flags.background, server);
     return true;
 }
 export async function methodMain(args = process.argv.slice(2), clientFactory = server => new MethodClient(server)) {

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

@@ -52,7 +52,7 @@ export async function runSaved(saved, flags, client) {
     setupEvents.push({ at: new Date().toISOString(), type: 'setup_started' });
     writePrivateJson(setupFile, setupEvents);
     await sync.start(saved.workflow, inputs, {});
-    process.stderr.write(`Local run: ${directory}\n`);
+    process.stderr.write(`Local run: ${directory}\nDashboard: ${sync.dashboard}\n`);
     let acquired = false, started = false, revision = 0;
     const statePath = `/api/cli/methods/${encodeURIComponent(saved.workflow_id)}/state`;
     try {

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

@@ -1,4 +1,5 @@
-export declare function startRunWorker(args: string[], directory: string, background?: boolean): Promise<void>;
+/** server: the signed-in Method server, so that the start line links to the run's dashboard page. */
+export declare function startRunWorker(args: string[], directory: string, background?: boolean, server?: string): Promise<void>;
 export declare function workerAlive(directory: string): boolean;
 export declare function waitForRun(directory: string): Promise<any>;
 export declare function cancelRun(directory: string): {

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

@@ -4,7 +4,9 @@ import { existsSync, mkdirSync, openSync, closeSync, readFileSync, rmSync, write
 import { resolve, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writePrivateJson } from './files.js';
-export async function startRunWorker(args, directory, background = false) {
+import { runDashboard } from './method-sync.js';
+/** server: the signed-in Method server, so that the start line links to the run's dashboard page. */
+export async function startRunWorker(args, directory, background = false, server) {
     directory = resolve(directory);
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const file = join(directory, 'worker-request.json'), status = join(directory, 'worker.json');
@@ -47,7 +49,8 @@ export async function startRunWorker(args, directory, background = false) {
         await new Promise((yes, no) => { child.once('spawn', yes); child.once('error', no); });
         child.unref();
         // The child owns its status record after startup. Do not overwrite a fast completion.
-        process.stdout.write(JSON.stringify({ status: 'started', run_id: runId, run_dir: directory, wait: `method wait ${JSON.stringify(directory)}`, cancel: `method cancel ${JSON.stringify(directory)}` }) + '\n');
+        const dashboard = runDashboard(directory) ?? (server ? `${server}/runs/${runId}` : undefined);
+        process.stdout.write(JSON.stringify({ status: 'started', run_id: runId, ...(dashboard ? { dashboard } : {}), run_dir: directory, wait: `method wait ${JSON.stringify(directory)}`, cancel: `method cancel ${JSON.stringify(directory)}` }) + '\n');
         const startupDeadline = Date.now() + 30_000;
         while (!existsSync(status)) {
             if (Date.now() > startupDeadline)
@@ -107,13 +110,14 @@ export async function waitForRun(directory) {
         const file = join(directory, 'worker.json');
         if (existsSync(file)) {
             const status = JSON.parse(readFileSync(file, 'utf8'));
+            const dashboard = runDashboard(directory), link = dashboard ? { dashboard } : {};
             if (status.status !== 'running') {
                 process.exitCode = status.exit_code ?? 1;
-                return status;
+                return { ...status, ...link };
             }
             if (!workerAlive(directory)) {
                 process.exitCode = 1;
-                return { status: 'interrupted', run_dir: directory, message: 'The worker stopped. Inspect its run record before resuming.' };
+                return { status: 'interrupted', run_dir: directory, ...link, message: 'The worker stopped. Inspect its run record before resuming.' };
             }
         }
         if (!existsSync(file) && Date.now() > deadline)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@method-ai-hq/sdk",
-  "version": "0.14.5",
+  "version": "0.14.6",
   "description": "Build and run reusable .method files with checked steps and saved results.",
   "license": "MIT",
   "type": "module",