@sdods/cli 0.12.0 → 0.13.0

package/dist/commands/auth.js

@@ -2,6 +2,7 @@ import { execa } from 'execa';
 import { SdodsError } from '@sdods/core';
 import { createContext } from '../context.js';
 import { json, ok, table } from '../ui.js';
+import { ensureBrowsers } from './browsers.js';
 /**
  * Login-state commands. Capture/list are thin wrappers over `@sdods/core/auth/capture`
  * (the same library `sdods record --user` uses) so there is a single implementation.
@@ -26,6 +27,10 @@ export function register(program) {
         const ctx = createContext(cmd);
         const cfg = ctx.registry.resolve(opts.project, opts.env);
         const { captureAuth, poolUsers } = await import('@sdods/core/auth/capture');
+        await ensureBrowsers([opts.browser ?? 'chromium'], {
+            cwd: ctx.rootDir,
+            install: process.env.SDODS_AUTO_INSTALL_BROWSERS === '1',
+        });
         const roles = opts.user
             ? [opts.user]
             : [...new Set((await poolUsers(cfg)).map((u) => u.role))];

package/dist/commands/browsers.js

@@ -7,6 +7,7 @@ import { BrowserSchema } from '@sdods/contracts';
 import { SdodsError } from '@sdods/core';
 import { createContext } from '../context.js';
 import { collect, info, json, ok, table, warn } from '../ui.js';
+import { toolCommand } from '../workspace-bin.js';
 // Typed against BrowserName (not `string`) so a new browser is a compile error here rather than a
 // silent fall-through to chromium.
 const ENGINE_OF = {
@@ -186,7 +187,7 @@ export async function ensureBrowsers(names, opts) {
     }
     if (process.platform === 'linux') {
         warn('If the browser then fails to launch with missing libraries, run ' +
-            `\`sudo npx playwright install-deps ${engines.join(' ')}\` once on this machine.`);
+            `\`sudo sdods browsers install --with-deps ${engines.map((e) => `-b ${e}`).join(' ')}\` once on this machine.`);
     }
     ok(`Installed ${engines.join(', ')}`);
     return engines;
@@ -198,12 +199,18 @@ export async function installBrowsers(opts = {}) {
     const channels = [...new Set(names.map((b) => CHANNEL_OF[b]).filter((c) => !!c))];
     if (engines.length) {
         const args = ['playwright', 'install', ...(opts.withDeps ? ['--with-deps'] : []), ...engines];
-        await execa('npx', args, { stdio: 'inherit', cwd: opts.cwd });
+        const [file, ...argv] = toolCommand(opts.cwd ?? process.cwd(), args);
+        await execa(file, argv, { stdio: 'inherit', cwd: opts.cwd });
     }
     // Channels are a system install run by the vendor's own installer, so `--with-deps` does not
     // apply and they cannot share the engine invocation.
     for (const channel of channels) {
-        await execa('npx', ['playwright', 'install', channel], { stdio: 'inherit', cwd: opts.cwd });
+        const [file, ...argv] = toolCommand(opts.cwd ?? process.cwd(), [
+            'playwright',
+            'install',
+            channel,
+        ]);
+        await execa(file, argv, { stdio: 'inherit', cwd: opts.cwd });
     }
 }
 /**

package/dist/commands/doctor.js

@@ -4,7 +4,7 @@ import { execa } from 'execa';
 import pc from 'picocolors';
 import { collectVarRefs, describeWorkers, effectiveWorkers, loadDotEnvLayer, loadEnvFile, poolAccountsByEnv, } from '@sdods/core';
 import { createContext } from '../context.js';
-import { browserStatuses } from './browsers.js';
+import { browserStatuses, installBrowsers } from './browsers.js';
 import { MIN_PLAYWRIGHT_FOR_STEP_RESULTS, installedPlaywrightVersion, stepResultsWarning, } from '../runner-compat.js';
 import { json, out, parseIntFlag } from '../ui.js';
 export function registerDoctorCommand(program) {
@@ -41,8 +41,10 @@ export function registerDoctorCommand(program) {
         checks.push(...browsers);
         if (opts.fix && browsers.some((b) => !b.ok)) {
             out(pc.cyan('Installing browsers…'));
-            await execa('npx', ['playwright', 'install', '--with-deps'], {
-                stdio: 'inherit',
+            // The same path as `sdods browsers install`, so the engines land where runs look for them.
+            await installBrowsers({
+                browsers: browsers.filter((b) => !b.ok).map((b) => b.name),
+                withDeps: process.platform === 'linux',
                 cwd: ctx.rootDir,
             }).catch(() => undefined);
         }

package/dist/commands/init.js

@@ -6,6 +6,7 @@ import pc from 'picocolors';
 import { OrganizationSchema, SlugSchema, WorkspaceSchema } from '@sdods/contracts';
 import { SdodsError, VERSION, WORKSPACE_FILE } from '@sdods/core';
 import { globalOptions } from '../context.js';
+import { installBrowsers } from './browsers.js';
 import { installSkills } from '../skills-catalog.js';
 import { json, ok, out, warn } from '../ui.js';
 /** Root of the SDODS monorepo this CLI runs from (used by --link, which needs a real checkout). */
@@ -338,12 +339,7 @@ Docs: https://docs.sdods.com
     }
     let browsersInstalled = false;
     if (flags.install && flags.browsers && installed) {
-        const res = await execa('npx', ['playwright', 'install', 'chromium'], {
-            cwd: target,
-            stdio: 'inherit',
-            reject: false,
-        });
-        browsersInstalled = res.exitCode === 0;
+        browsersInstalled = await installBrowsers({ browsers: ['chromium'], cwd: target }).then(() => true, () => false);
     }
     if (flags.claude) {
         const res = await execa('npx', ['-y', '@sdods/cli', 'agent', 'install-claude'], {

package/dist/commands/record.js

@@ -5,6 +5,8 @@ import pc from 'picocolors';
 import { SdodsError, VERSION } from '@sdods/core';
 import { createContext } from '../context.js';
 import { json, ok, out, warn } from '../ui.js';
+import { toolCommand } from '../workspace-bin.js';
+import { ensureBrowsers } from './browsers.js';
 function addRecordOptions(cmd) {
     return cmd
         .option('-p, --project <slug>', 'project slug')
@@ -30,6 +32,12 @@ async function recordAction(flags, cmd) {
     const { AuthStateCache } = await import('@sdods/core');
     const name = flags.name ?? `rec-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`;
     const browser = (flags.browser ?? 'chromium');
+    // Before the recorder opens: otherwise a missing engine surfaces as the runner's own install
+    // instructions, which install to the wrong place.
+    await ensureBrowsers([browser], {
+        cwd: config.runtime.repoRoot,
+        install: process.env.SDODS_AUTO_INSTALL_BROWSERS === '1',
+    });
     // logged-in start: make sure the first user of the role has a fresh storage state
     let storageStatePath;
     let userName;
@@ -164,7 +172,8 @@ export function register(program) {
 }
 async function playwrightVersion(cwd) {
     try {
-        const { stdout } = await execa('npx', ['playwright', '--version'], { cwd });
+        const [file, ...argv] = toolCommand(cwd, ['playwright', '--version']);
+        const { stdout } = await execa(file, argv, { cwd });
         return stdout.trim().replace(/^Version\s+/i, '');
     }
     catch {

package/dist/commands/report.js

@@ -8,6 +8,8 @@ import { SdodsError, collectGateEvidence, evaluateGates, gateReportsFromRunnerJs
 import { createContext } from '../context.js';
 import { gateFailedError, printGates } from '../gates.js';
 import { json, ok, out, table, warn } from '../ui.js';
+import { toolCommand } from '../workspace-bin.js';
+import { openInBrowser } from '../open.js';
 function artifactsRoot(rootDir) {
     return resolve(rootDir, process.env.SDODS_ARTIFACTS_DIR ?? '.sdods/runs');
 }
@@ -33,10 +35,7 @@ function readJsonFile(file) {
         return null;
     }
 }
-async function openPath(p) {
-    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-    await execa(cmd, [p], { shell: process.platform === 'win32' }).catch(() => undefined);
-}
+const openPath = openInBrowser;
 /**
  * The process `report merge` judges: `--process` (with `-p`, or the project in a run.json), or the
  * process a run.json names when it declares gates. `undefined` when there is nothing to judge.
@@ -337,7 +336,8 @@ export function register(program) {
             reporters.join(','),
             workspace.reports,
         ];
-        const res = await execa('npx', args, {
+        const [file, ...argv] = toolCommand(ctx.rootDir, args);
+        const res = await execa(file, argv, {
             cwd: ctx.rootDir,
             reject: false,
             env: {
@@ -459,6 +459,7 @@ export function register(program) {
         .command('show-report')
         .description('Open the HTML report of a run')
         .option('--run <id>', 'run id (default: latest)')
+        .option('--last', 'the latest run (the default; accepted so `report --last` habits work here)')
         .action(async (opts, cmd) => {
         const ctx = createContext(cmd);
         const root = artifactsRoot(ctx.rootDir);
@@ -468,10 +469,13 @@ export function register(program) {
         const html = join(root, runId, runFiles.htmlReport, 'index.html');
         if (!existsSync(html))
             throw new SdodsError('RUN_FAILED', `No HTML report at ${html}.`, { exitCode: 2 });
-        await execa('npx', ['playwright', 'show-report', join(root, runId, runFiles.htmlReport)], {
-            stdio: 'inherit',
-            cwd: ctx.rootDir,
-        });
+        const [file, ...argv] = toolCommand(ctx.rootDir, [
+            'playwright',
+            'show-report',
+            join(root, runId, runFiles.htmlReport),
+        ]);
+        out(pc.cyan(`Serving the report of run ${runId}. Press Ctrl+C to stop.`));
+        await execa(file, argv, { stdio: 'inherit', cwd: ctx.rootDir });
     });
 }
 //# sourceMappingURL=report.js.map

package/dist/commands/run.d.ts

@@ -42,6 +42,7 @@ export interface RunFlags {
     notify?: boolean;
     allowPoolContention?: boolean;
     installBrowsers?: boolean;
+    open?: string;
 }
 export declare function register(program: Command): void;
 export declare function runCommand(flags: RunFlags, cmd: Command): Promise<number>;

package/dist/commands/run.js

@@ -6,6 +6,8 @@ import { RecordingModeSchema, newRunId, runFiles, } from '@sdods/contracts';
 import { SdodsError, CLI_OVERRIDES_ENV, VERSION, checkPoolCapacity, collectGateEvidence, effectiveWorkers, evaluateGates, formatFindings, hasGates, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, parseTagExpr, poolAccountsFor, poolDemandByRole, poolTooSmallError, redactRunTraces, serializeCliOverrides, setupTierOf, } from '@sdods/core';
 import { analyzeChangeImpact } from '@sdods/mcp';
 import { createContext } from '../context.js';
+import { toolCommand, workspaceBin } from '../workspace-bin.js';
+import { openInBrowser, resolveOpenWhen } from '../open.js';
 import { browserStatuses, ensureBrowsers } from './browsers.js';
 import { gateFailedError, printGates } from '../gates.js';
 import { maybeNotify, notifyRun } from '../notify.js';
@@ -61,6 +63,7 @@ function addRunOptions(cmd) {
         .option('--ui', 'interactive UI mode')
         .option('--debug', 'step debugger')
         .option('--list', 'list the run targets and tests that would run')
+        .option('--open <when>', 'open the SDODS dashboard after the run: always | on-failure | never (default: on-failure at an interactive terminal, never in CI or under an agent; or set SDODS_OPEN)')
         .option('--repeat-each <n>', 'repeat each test n times', parseIntFlag('repeat-each'))
         .option('--fail-on-flaky', 'exit 1 when any test is flaky')
         .option('--max-failures <n>', 'stop after n failures', parseIntFlag('max-failures'))
@@ -328,7 +331,8 @@ export async function runCommand(flags, cmd) {
     // Recorded specs are plain runner tests: no Gherkin to generate.
     const recordedOnly = runnerProjects.every((p) => p.layer === 'recorded');
     if (!recordedOnly) {
-        const gen = await execa('npx', ['bddgen', '-c', configPath], {
+        const [bddgen, ...bddgenArgs] = workspaceBin(ctx.rootDir, 'playwright-bdd', 'bddgen');
+        const gen = await execa(bddgen, [...bddgenArgs, '-c', configPath], {
             cwd: ctx.rootDir,
             env: childEnv,
             stdio: ctx.opts.quiet ? 'pipe' : 'inherit',
@@ -337,7 +341,7 @@ export async function runCommand(flags, cmd) {
         if (gen.exitCode !== 0) {
             if (ctx.opts.quiet && gen.stderr)
                 process.stderr.write(gen.stderr + '\n');
-            throw new SdodsError('RUN_FAILED', 'bddgen failed to generate specs.', {
+            throw new SdodsError('RUN_FAILED', 'Could not generate specs from the features.', {
                 hint: 'Run `sdods lint -p <slug> --undefined-steps` to find undefined steps.',
                 exitCode: 2,
             });
@@ -417,9 +421,11 @@ export async function runCommand(flags, cmd) {
                 out(`  ${p.name}--setup`);
             out(`  ${p.name}`);
         }
-        const listed = await execa('npx', args, {
+        const [listFile, ...listArgv] = toolCommand(ctx.rootDir, args);
+        const listed = await execa(listFile, listArgv, {
             cwd: ctx.rootDir,
-            env: childEnv,
+            // The SDODS terminal reporter lists scenarios by feature and title instead of reporting.
+            env: { ...childEnv, SDODS_LIST_ONLY: '1' },
             stdio: 'inherit',
             reject: false,
         });
@@ -430,10 +436,15 @@ export async function runCommand(flags, cmd) {
     out(pc.dim(`run ${runId} · project ${entry.slug} · env ${cfg.env.name}${tags ? ` · tags ${tags}` : ''}${proc ? ` · process ${proc.name}` : ''}${modules.length ? ` · modules ${modules.join(',')}` : ''}`));
     out(pc.dim(`projects: ${runnerProjects.map((p) => p.name).join(', ')}`));
     const started = Date.now();
-    const child = execa('npx', args, {
+    const [runFile, ...runArgv] = toolCommand(ctx.rootDir, args);
+    const interactive = Boolean(flags.ui || flags.debug);
+    const child = execa(runFile, runArgv, {
         cwd: ctx.rootDir,
         env: childEnv,
-        stdio: 'inherit',
+        // stdin is only for the runner's interactive modes. Given a terminal on stdin, the HTML
+        // reporter ends every run with "To open last HTML report run: npx playwright show-report",
+        // a command for a tool the user never installed by name; SDODS prints its own below.
+        stdio: [interactive ? 'inherit' : 'ignore', 'inherit', 'inherit'],
         reject: false,
     });
     const onSignal = () => child.kill('SIGTERM');
@@ -572,6 +583,17 @@ export async function runCommand(flags, cmd) {
         out(pc.dim(`artifacts:   ${runDir}`));
         out(pc.dim(`html report: ${join(runDir, runFiles.htmlReport, 'index.html')}`));
         out(pc.dim(`dashboard:   ${join(runDir, runFiles.dashboard, 'index.html')}`));
+        out('');
+        out(`  open the results:  ${pc.cyan(`sdods report --run ${runId} --open`)}`);
+        const openWhen = resolveOpenWhen(flags.open, false);
+        const failed = finalExit !== 0 && finalExit !== 130;
+        const dashboard = join(runDir, runFiles.dashboard, 'index.html');
+        if ((openWhen === 'always' || (openWhen === 'on-failure' && failed)) && existsSync(dashboard)) {
+            out(pc.dim(`  opening the dashboard in your browser (--open never to stop this)`));
+            await openInBrowser(dashboard);
+        }
+        if (finalExit !== 0 && finalExit !== 130)
+            out(`  step through it:   ${pc.cyan(`sdods trace --run ${runId}`)}`);
     }
     if (gates && !gates.passed)
         renderError(gateFailedError(gates, join(runDir, runFiles.gates)), Boolean(ctx.opts.json));

package/dist/commands/steps.js

@@ -3,6 +3,7 @@ import { execa } from 'execa';
 import { SdodsError, coreStepsDir } from '@sdods/core';
 import { createContext } from '../context.js';
 import { json, table } from '../ui.js';
+import { toolCommand } from '../workspace-bin.js';
 /** Parse `bddgen export` output (`* Given ...` lines) into StepDef[]. */
 export async function listSteps(rootDir, slug, opts = {}) {
     const env = {
@@ -14,9 +15,10 @@ export async function listSteps(rootDir, slug, opts = {}) {
     const args = ['bddgen', 'export', '-c', join(rootDir, 'sdods.runner.config.ts')];
     if (opts.unused)
         args.push('--unused-steps');
-    const result = await execa('npx', args, { cwd: rootDir, env, reject: false, all: true });
+    const [file, ...argv] = toolCommand(rootDir, args);
+    const result = await execa(file, argv, { cwd: rootDir, env, reject: false, all: true });
     if (result.exitCode !== 0) {
-        throw new SdodsError('RUN_FAILED', `bddgen export failed for ${slug}.`, {
+        throw new SdodsError('RUN_FAILED', `Could not list the step definitions of ${slug}.`, {
             details: { output: result.all?.slice(-2000) },
         });
     }
@@ -46,7 +48,7 @@ export function register(program) {
         .description('Inspect step definitions available to a project');
     steps
         .command('list')
-        .description('List all step definitions (core library + project) as seen by bddgen')
+        .description('List all step definitions (core library + project) as the run sees them')
         .requiredOption('-p, --project <slug>', 'project slug')
         .option('--unused', 'only steps not used by any feature')
         .option('--grep <text>', 'filter by substring')

package/dist/commands/trace.js

@@ -5,6 +5,7 @@ import pc from 'picocolors';
 import { SdodsError, DEFAULT_ARTIFACTS_DIR } from '@sdods/core';
 import { createContext } from '../context.js';
 import { json, out, table } from '../ui.js';
+import { toolCommand } from '../workspace-bin.js';
 /** Recursively find `trace.zip` files (runner output) below a directory. */
 export function findTraceZips(dir, depth = 8) {
     const found = [];
@@ -93,7 +94,8 @@ export function register(program) {
             return;
         }
         out(pc.cyan(`Opening ${zips.length} trace(s) from ${source}`));
-        const res = await execa('npx', ['playwright', 'show-trace', ...zips], {
+        const [file, ...argv] = toolCommand(ctx.rootDir, ['playwright', 'show-trace', ...zips]);
+        const res = await execa(file, argv, {
             cwd: ctx.rootDir,
             stdio: 'inherit',
             reject: false,

package/dist/commands/watch.js

@@ -4,7 +4,9 @@ import pc from 'picocolors';
 import { newRunId } from '@sdods/contracts';
 import { SdodsError, listGeneratedProjects, normalizeTagExpr } from '@sdods/core';
 import { createContext } from '../context.js';
+import { toolCommand, workspaceBin } from '../workspace-bin.js';
 import { collect, out } from '../ui.js';
+import { ensureBrowsers } from './browsers.js';
 /**
  * Spec generation runs in watch mode while the interactive UI
  * re-runs them. Both children share the same SDODS_* environment that `sdods run` uses.
@@ -52,13 +54,15 @@ export function register(program) {
             SDODS_REPORTER_MODE: 'quiet',
         };
         const configPath = join(ctx.rootDir, 'sdods.runner.config.ts');
-        const names = listGeneratedProjects(ctx.registry, selection).map((p) => p.name);
+        const targets = listGeneratedProjects(ctx.registry, selection);
+        const names = targets.map((p) => p.name);
         if (!names.length) {
             throw new SdodsError('CONFIG_INVALID', 'Nothing to watch: no run targets match the selection.', {
                 hint: 'Check --layer/--browser against the project yaml.',
                 exitCode: 2,
             });
         }
+        await ensureBrowsers(targets.map((p) => p.browser ?? 'chromium'), { cwd: ctx.rootDir, install: process.env.SDODS_AUTO_INSTALL_BROWSERS === '1' });
         out(pc.cyan(`Watching ${entry.slug} (${cfg.env.name}) → ${names.join(', ')}`));
         const children = [];
         const stop = () => {
@@ -68,18 +72,20 @@ export function register(program) {
         process.on('SIGINT', stop);
         process.on('SIGTERM', stop);
         // initial generation so UI mode has specs to show
-        const gen = await execa('npx', ['bddgen', '-c', configPath], {
+        const [bddgen, ...bddgenArgs] = workspaceBin(ctx.rootDir, 'playwright-bdd', 'bddgen');
+        const gen = await execa(bddgen, [...bddgenArgs, '-c', configPath], {
             cwd: ctx.rootDir,
             env: childEnv,
             stdio: 'inherit',
             reject: false,
         });
         if (gen.exitCode !== 0) {
-            throw new SdodsError('RUN_FAILED', 'bddgen failed; fix the errors above and retry.', {
+            throw new SdodsError('RUN_FAILED', 'Could not generate specs from the features; fix the errors above and retry.', {
+                hint: `Run \`sdods lint -p ${entry.slug} --undefined-steps\` to list them.`,
                 exitCode: 1,
             });
         }
-        const watcher = execa('npx', ['bddgen', '-c', configPath, '--watch'], {
+        const watcher = execa(bddgen, [...bddgenArgs, '-c', configPath, '--watch'], {
             cwd: ctx.rootDir,
             env: childEnv,
             stdio: 'inherit',
@@ -101,7 +107,8 @@ export function register(program) {
         else {
             pwArgs.push('--ui');
         }
-        const pw = execa('npx', pwArgs, {
+        const [pwFile, ...pwArgv] = toolCommand(ctx.rootDir, pwArgs);
+        const pw = execa(pwFile, pwArgv, {
             cwd: ctx.rootDir,
             env: childEnv,
             stdio: 'inherit',

package/dist/open.d.ts

@@ -0,0 +1,10 @@
+/** Open a file or URL in the default browser or viewer. Never throws: opening is a courtesy. */
+export declare function openInBrowser(target: string): Promise<void>;
+export type OpenWhen = 'always' | 'on-failure' | 'never';
+/**
+ * When `sdods run` opens its results. `--open` wins, then SDODS_OPEN; otherwise on failure, and only
+ * for a person at a terminal: never in CI, under a coding agent (the same check the runner makes),
+ * for --json, or when output is piped to the server, the desktop app or a log.
+ */
+export declare function resolveOpenWhen(flag: string | undefined, json: boolean): OpenWhen;
+//# sourceMappingURL=open.d.ts.map

package/dist/open.js

@@ -0,0 +1,26 @@
+import { execa } from 'execa';
+/** Open a file or URL in the default browser or viewer. Never throws: opening is a courtesy. */
+export async function openInBrowser(target) {
+    const [cmd, args] = process.platform === 'darwin'
+        ? ['open', [target]]
+        : process.platform === 'win32'
+            ? // `start` takes its first quoted argument as a window title, so give it an empty one.
+                ['cmd', ['/c', 'start', '""', target]]
+            : ['xdg-open', [target]];
+    await execa(cmd, args, { stdio: 'ignore', windowsVerbatimArguments: true }).catch(() => undefined);
+}
+/**
+ * When `sdods run` opens its results. `--open` wins, then SDODS_OPEN; otherwise on failure, and only
+ * for a person at a terminal: never in CI, under a coding agent (the same check the runner makes),
+ * for --json, or when output is piped to the server, the desktop app or a log.
+ */
+export function resolveOpenWhen(flag, json) {
+    const explicit = flag ?? process.env.SDODS_OPEN;
+    if (explicit === 'always' || explicit === 'on-failure' || explicit === 'never')
+        return explicit;
+    const agent = Boolean(process.env.CLAUDECODE || process.env.COPILOT_CLI);
+    if (json || process.env.CI || agent || !process.stdout.isTTY)
+        return 'never';
+    return 'on-failure';
+}
+//# sourceMappingURL=open.js.map

package/dist/program.js

@@ -46,7 +46,7 @@ import { register as registerMatrix } from './commands/matrix.js';
 export function buildProgram() {
     const program = new Command('sdods');
     program
-        .description('SDODS — automation and orchestration for reliable business workflows: BDD for UI, API and hybrid flows.')
+        .description('SDODS — BDD test automation for UI, API and hybrid flows that leaves release evidence behind every run.')
         .version(VERSION, '-V, --version')
         .option('--json', 'machine-readable output')
         .option('-q, --quiet', 'only errors')
@@ -57,7 +57,10 @@ export function buildProgram() {
         .showSuggestionAfterError()
         .configureHelp({ sortSubcommands: true })
         // Root help only: 'after' is not inherited by subcommands.
-        .addHelpText('after', `\nDocs: https://docs.sdods.com${SPONSOR_ENABLED ? `  ·  Sponsor: ${SPONSOR_URL}` : ''}`);
+        .addHelpText('after', 
+    // The credit NOTICE requires in spirit: SDODS wraps the runner's commands, not its authorship.
+    `\nDocs: https://docs.sdods.com${SPONSOR_ENABLED ? `  ·  Sponsor: ${SPONSOR_URL}` : ''}\n` +
+        'Runs on Playwright (Apache-2.0) and playwright-bdd (MIT); see NOTICE.');
     registerProjectCommands(program);
     registerEnvCommands(program);
     registerConfigCommands(program);

package/dist/workspace-bin.d.ts

@@ -0,0 +1,2 @@
+export { toolCommand, workspaceBin } from '@sdods/core';
+//# sourceMappingURL=workspace-bin.d.ts.map

package/dist/workspace-bin.js

@@ -0,0 +1,3 @@
+// Moved to @sdods/core so the lint and recorder code paths resolve the runner tools the same way.
+export { toolCommand, workspaceBin } from '@sdods/core';
+//# sourceMappingURL=workspace-bin.js.map

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@sdods/cli",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "SDODS command line: run, record, analyze, agents, MCP server, scheduler and the web server.",
   "license": "Apache-2.0",
+  "funding": "https://sdods.com/sponsor/",
   "author": "SDODS <admin@sdods.com>",
   "type": "module",
   "bin": {
@@ -25,22 +26,22 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.12.0",
-    "@sdods/core": "0.12.0",
+    "@sdods/contracts": "0.13.0",
+    "@sdods/core": "0.13.0",
     "commander": "^15.0.0",
-    "execa": "^10.0.1",
+    "execa": "^10.1.0",
     "picocolors": "^1.1.1",
     "semver": "^7.8.5",
     "yaml": "^2.9.1",
     "zod": "^4.6.5",
     "@playwright/test": "^1.63.0",
     "playwright-core": "^1.63.0",
-    "@sdods/integrations": "0.12.0",
-    "@sdods/mcp": "0.12.0",
-    "@sdods/agents": "0.12.0",
-    "@sdods/db": "0.12.0",
-    "csv-parse": "^7.0.2",
-    "@sdods/server": "0.12.0"
+    "@sdods/integrations": "0.13.0",
+    "@sdods/mcp": "0.13.0",
+    "@sdods/agents": "0.13.0",
+    "@sdods/db": "0.13.0",
+    "csv-parse": "^7.0.3",
+    "@sdods/server": "0.13.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {