@sdods/cli 0.18.0 → 0.20.0

package/dist/commands/agent.js

@@ -36,7 +36,7 @@ export function register(program) {
             .option('--run-id <id>', 'run id (heal), default last', 'last')
             .option('--diff <range>', 'git range (upgrade), e.g. main..HEAD')
             .option('--files <list>', 'feature files (review)', collect, [])
-            .option('--adapter <name>', 'claude (API key) | claude-code (logged-in Claude Code CLI) | codex (logged-in Codex CLI) | openai | ollama (a model on this machine) | fake; default: auto-detect')
+            .option('--adapter <name>', 'claude (API key) | claude-code (logged-in Claude Code CLI) | codex (logged-in Codex CLI) | copilot (logged-in GitHub Copilot CLI) | openai | ollama (a model on this machine) | fake; default: auto-detect')
             .option('--model <id>', 'model override')
             .option('--profile <name>', 'auto | full | small — how many tools and how much prompt the model is given')
             .option('--browser', 'attach the browser MCP server even under the small profile (which omits it)')
@@ -162,13 +162,13 @@ export function register(program) {
     const installAction = async (opts, cmd, forced) => {
         const ctx = createContext(cmd);
         const target = (forced ?? opts.for ?? 'all');
-        if (!['claude', 'codex', 'all'].includes(target)) {
+        if (!['claude', 'codex', 'copilot', 'all'].includes(target)) {
             throw new SdodsError('NOT_SUPPORTED', `Unknown target "${target}".`, {
-                hint: 'Use --for claude, --for codex or --for all.',
+                hint: 'Use --for claude, --for codex, --for copilot or --for all.',
                 exitCode: 2,
             });
         }
-        const { installCodingAgents } = await import('@sdods/agents');
+        const { installCodingAgents, findOnPath } = await import('@sdods/agents');
         const written = installCodingAgents(ctx.rootDir, {
             for: target,
             project: opts.project,
@@ -177,7 +177,11 @@ export function register(program) {
         });
         if (opts.mcp !== false) {
             const { execa } = await import('execa');
-            const clients = target === 'all' ? ['claude', 'codex'] : [target];
+            // `all` registers with Copilot only when it is installed: its config lives in the home
+            // directory, and writing one for someone who does not use Copilot would be clutter.
+            const clients = target === 'all'
+                ? ['claude', 'codex', ...(findOnPath('copilot') ? ['copilot'] : [])]
+                : [target];
             for (const client of clients) {
                 const args = ['mcp', 'install', client];
                 if (opts.project)
@@ -200,8 +204,8 @@ export function register(program) {
     };
     agent
         .command('install')
-        .description('Set up coding-agent CLIs: --for claude writes .claude/agents/sdods-*.md + CLAUDE.md, --for codex writes AGENTS.md; both get AGENT.md/SKILL.md and the MCP registration')
-        .option('--for <client>', 'claude | codex | all', 'all')
+        .description('Set up coding-agent CLIs: --for claude writes .claude/agents/sdods-*.md + CLAUDE.md, --for codex writes AGENTS.md, --for copilot writes .github/agents/sdods-*.agent.md + AGENTS.md; all get AGENT.md/SKILL.md and the MCP registration')
+        .option('--for <client>', 'claude | codex | copilot | all', 'all')
         .option('-p, --project <slug>')
         .option('-e, --env <name>')
         .option('--force', 'overwrite existing files')

package/dist/commands/doctor.js

@@ -173,6 +173,7 @@ function tokenMatrix(cliStatus, localLlm) {
     const has = (k) => Boolean(process.env[k]);
     const claudeOk = cliStatus.find((c) => c.name === 'cli:claude')?.ok ?? false;
     const codexOk = cliStatus.find((c) => c.name === 'cli:codex')?.ok ?? false;
+    const copilotOk = cliStatus.find((c) => c.name === 'cli:copilot')?.ok ?? false;
     const agentsGroup = [
         {
             name: 'ANTHROPIC_API_KEY',
@@ -192,6 +193,12 @@ function tokenMatrix(cliStatus, localLlm) {
             detail: 'adapter codex: uses your Codex login (ChatGPT account)',
             hint: '`npm i -g @openai/codex && codex login`',
         },
+        {
+            name: 'copilot CLI login',
+            present: copilotOk,
+            detail: 'adapter copilot: uses your GitHub Copilot subscription',
+            hint: '`npm i -g @github/copilot && copilot login` (or COPILOT_GITHUB_TOKEN)',
+        },
         {
             name: 'OPENAI_API_KEY (+OPENAI_BASE_URL)',
             present: has('OPENAI_API_KEY'),
@@ -296,11 +303,11 @@ async function localModelStatus() {
         return { name, ok: false, optional: true, detail: 'agents package unavailable' };
     }
 }
-/** `cli:claude` / `cli:codex` rows: installed + logged in. Missing CLIs are not failures. */
+/** `cli:claude` / `cli:codex` / `cli:copilot` rows: installed + logged in. Missing CLIs are not failures. */
 async function codingCliStatus() {
     const rows = [];
     try {
-        const { ClaudeCodeCliAdapter, CodexCliAdapter } = await import('@sdods/agents');
+        const { ClaudeCodeCliAdapter, CodexCliAdapter, CopilotCliAdapter } = await import('@sdods/agents');
         const c = ClaudeCodeCliAdapter.loginStatus();
         rows.push({
             name: 'cli:claude',
@@ -317,6 +324,15 @@ async function codingCliStatus() {
             detail: x.detail,
             fix: x.installed ? 'codex login' : 'npm i -g @openai/codex (optional)',
         });
+        const g = CopilotCliAdapter.loginStatus();
+        rows.push({
+            name: 'cli:copilot',
+            // Copilot cannot report its login without a prompt; installed counts until a run says otherwise
+            ok: g.installed && g.loggedIn !== false,
+            optional: true,
+            detail: g.detail,
+            fix: g.installed ? 'copilot login' : 'npm i -g @github/copilot (optional)',
+        });
     }
     catch {
         rows.push({
@@ -331,6 +347,12 @@ async function codingCliStatus() {
             optional: true,
             detail: 'agents package unavailable',
         });
+        rows.push({
+            name: 'cli:copilot',
+            ok: false,
+            optional: true,
+            detail: 'agents package unavailable',
+        });
     }
     return rows;
 }

package/dist/commands/import.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+import { planCucumberImport } from '@sdods/core';
+import { type CliContext } from '../context.js';
+/** Every file of the proposed project, keyed by its path from the repository root. */
+export declare function cucumberProjectFiles(ctx: Pick<CliContext, 'rootDir' | 'registry'>, plan: ReturnType<typeof planCucumberImport>, envName: string): Record<string, string>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/import.js

@@ -0,0 +1,147 @@
+import { existsSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import pc from 'picocolors';
+import { stringify as toYaml } from 'yaml';
+import { ProjectConfigSchema, SlugSchema } from '@sdods/contracts';
+import { PROJECT_FILE, SdodsError, analyzePlaywrightSuite, planCucumberImport } from '@sdods/core';
+import { createContext } from '../context.js';
+import { projectTemplateFiles } from '../templates/project.js';
+import { json, ok, out } from '../ui.js';
+/**
+ * `sdods import cucumber|playwright <dir>`: map an existing suite into an SDODS project, as a
+ * proposal a person accepts (docs/adr/0001-import-existing-suites.md). Never writes the tree.
+ */
+function sourceDir(dir) {
+    const abs = resolve(dir);
+    if (!existsSync(abs) || !statSync(abs).isDirectory()) {
+        throw new SdodsError('CONFIG_INVALID', `${dir} is not a directory.`, { exitCode: 2 });
+    }
+    return abs;
+}
+function checkSlug(ctx, slug) {
+    SlugSchema.parse(slug);
+    if (existsSync(join(ctx.registry.projectsDir, slug, PROJECT_FILE))) {
+        throw new SdodsError('CONFIG_INVALID', `Project "${slug}" already exists.`, {
+            hint: 'Pick another --project slug; an import proposes a new project.',
+            exitCode: 2,
+        });
+    }
+    return slug;
+}
+/** Every file of the proposed project, keyed by its path from the repository root. */
+export function cucumberProjectFiles(ctx, plan, envName) {
+    const config = ProjectConfigSchema.parse({
+        slug: plan.slug,
+        name: plan.slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+        description: `Imported from a Cucumber-JS suite by sdods import cucumber.`,
+        layers: plan.layers,
+        browsers: ['chromium'],
+        envs: { default: envName, available: [envName] },
+        tags: { extra: plan.extraTags },
+    });
+    const scaffold = projectTemplateFiles({
+        config,
+        envName,
+        uiUrl: 'http://localhost:3000',
+        apiUrl: 'http://localhost:3000/api',
+    });
+    for (const key of Object.keys(scaffold))
+        if (key.startsWith('features/'))
+            delete scaffold[key];
+    const project = {
+        ...scaffold,
+        [PROJECT_FILE]: `# SDODS project, imported by sdods import cucumber. Reference: https://docs.sdods.com/docs/reference/project-yaml\n${toYaml({
+            slug: config.slug,
+            name: config.name,
+            description: config.description,
+            layers: config.layers,
+            browsers: config.browsers,
+            testIdAttribute: config.testIdAttribute,
+            tags: { suites: config.tags.suites, extra: config.tags.extra, roles: config.tags.roles },
+            envs: config.envs,
+            heal: { enabled: true },
+            retries: { ci: 2, local: 0 },
+        }, { lineWidth: 100 })}`,
+        'IMPORT-REPORT.md': plan.report,
+    };
+    for (const f of plan.features)
+        project[f.path] = f.content;
+    if (plan.stepsFile)
+        project['steps/imported.steps.ts'] = plan.stepsFile;
+    const base = relative(ctx.rootDir, join(ctx.registry.projectsDir, plan.slug));
+    return Object.fromEntries(Object.entries(project).map(([k, v]) => [join(base, k), v]));
+}
+export function register(program) {
+    const cmd = program
+        .command('import')
+        .description('Map an existing Cucumber-JS or Playwright suite into an SDODS project (as a proposal)');
+    cmd
+        .command('cucumber <dir>')
+        .description('Read a Cucumber-JS suite (features, step definitions, cucumber.js) and propose an SDODS project')
+        .requiredOption('-p, --project <slug>', 'slug of the new project')
+        .option('--env <name>', 'first environment name', 'local')
+        .option('--module <name>', 'folder under features/ for the imported features', 'imported')
+        .option('--dry-run', 'print the report and write nothing, not even a proposal')
+        .action(async (dir, opts, command) => {
+        const ctx = createContext(command);
+        const slug = checkSlug(ctx, opts.project);
+        const plan = planCucumberImport(sourceDir(dir), { slug, module: opts.module });
+        if (plan.features.length === 0) {
+            throw new SdodsError('CONFIG_INVALID', `No .feature files under ${dir}.`, { exitCode: 2 });
+        }
+        const files = cucumberProjectFiles(ctx, plan, opts.env);
+        if (opts.dryRun) {
+            if (ctx.opts.json)
+                return json({ plan, files: Object.keys(files) });
+            out(plan.report);
+            return;
+        }
+        const { ProposalStore } = await import('@sdods/mcp');
+        const manifest = new ProposalStore(ctx.rootDir).create({
+            role: 'importer',
+            project: slug,
+            env: opts.env,
+            summary: `Import ${plan.mappings.length} scenario(s) from ${plan.features.length} Cucumber-JS feature file(s) into ${slug}: ${plan.steps.core.length} step(s) reuse the SDODS library, ${plan.steps.stubbed.length} stubbed to port.`,
+            files: Object.entries(files).map(([path, content]) => ({
+                path,
+                content,
+                op: 'add',
+            })),
+        });
+        if (ctx.opts.json)
+            return json({ proposal: manifest, plan });
+        ok(`proposal ${manifest.id}: ${manifest.files.length} file(s) for projects/${slug}`);
+        out(pc.dim(`  ${plan.mappings.length} scenario(s), ${plan.steps.stubbed.length} step stub(s), ${plan.manual.length} item(s) to port by hand`));
+        out(`  review: ${pc.cyan(`sdods proposals show ${manifest.id}`)}`);
+        out(`  accept: ${pc.cyan(`sdods proposals accept ${manifest.id}`)}`);
+    });
+    cmd
+        .command('playwright <dir>')
+        .description('Analyse a Playwright Test suite and propose the report (converts nothing yet)')
+        .requiredOption('-p, --project <slug>', 'slug the suite would be imported as')
+        .option('--dry-run', 'print the report and write nothing')
+        .action(async (dir, opts, command) => {
+        const ctx = createContext(command);
+        const slug = checkSlug(ctx, opts.project);
+        const analysis = analyzePlaywrightSuite(sourceDir(dir), slug);
+        if (opts.dryRun) {
+            if (ctx.opts.json)
+                return json(analysis);
+            out(analysis.report);
+            return;
+        }
+        const { ProposalStore } = await import('@sdods/mcp');
+        const base = relative(ctx.rootDir, join(ctx.registry.projectsDir, slug));
+        const manifest = new ProposalStore(ctx.rootDir).create({
+            role: 'importer',
+            project: slug,
+            summary: `Analysis of a Playwright suite (${analysis.specFiles.length} spec file(s), ${analysis.tests} test(s)); converts nothing yet.`,
+            files: [{ path: join(base, 'IMPORT-REPORT.md'), content: analysis.report, op: 'add' }],
+        });
+        if (ctx.opts.json)
+            return json({ proposal: manifest, analysis });
+        ok(`proposal ${manifest.id}: the analysis report for ${slug}`);
+        out(`  review: ${pc.cyan(`sdods proposals show ${manifest.id}`)}`);
+    });
+}
+//# sourceMappingURL=import.js.map

package/dist/commands/mcp.js

@@ -81,14 +81,14 @@ export function register(program) {
     });
     mcp
         .command('install <client>')
-        .description('Register the SDODS MCP server with a client: claude | codex | cursor | vscode | windsurf | gemini (merges, never clobbers)')
+        .description('Register the SDODS MCP server with a client: claude | codex | copilot | cursor | vscode | windsurf | gemini (merges, never clobbers)')
         .option('-p, --project <slug>')
         .option('-e, --env <name>')
         .option('--caps <list>')
         .option('--http-url <url>', 'configure the HTTP transport instead of stdio')
         .option('--token-placeholder <text>', 'placeholder written for the bearer token')
         .option('--with-playwright', 'also register the raw upstream Playwright MCP server (ungoverned; the sdods server already wraps it as browser_*)')
-        .option('--file', 'always write the config file instead of calling `claude mcp add` / `codex mcp add`')
+        .option('--file', 'always write the config file instead of calling `claude` / `codex` / `copilot mcp add`')
         .option('--print', 'print the snippet instead of writing files')
         .action(async (client, opts, cmd) => {
         const ctx = createContext(cmd);
@@ -120,11 +120,11 @@ export function register(program) {
             return;
         }
         // Prefer the client's own CLI so its config format stays authoritative.
-        if (!opts.file && (client === 'claude' || client === 'codex')) {
+        if (!opts.file && (client === 'claude' || client === 'codex' || client === 'copilot')) {
             const done = await registerViaClientCli(client, o, ctx.rootDir);
             if (done) {
                 ok(`Registered the sdods MCP server with ${client} (${cliCommands(o)[client]})`);
-                if (o.withPlaywright === true && client === 'codex')
+                if (o.withPlaywright === true && client !== 'claude')
                     out(pc.dim('Also registered the bundled Playwright MCP server as "playwright".'));
                 return;
             }
@@ -135,7 +135,7 @@ export function register(program) {
             out(pc.dim(`Alternative: ${s.cli}`));
     });
 }
-/** `claude mcp add` (project scope) or `codex mcp add`; false when the CLI is unavailable. */
+/** `claude mcp add` (project scope), `codex mcp add` or `copilot mcp add` (user config); false when the CLI is unavailable. */
 async function registerViaClientCli(client, o, cwd) {
     const { execa } = await import('execa');
     // `npx sdods` resolves only when the cwd happens to sit inside a checkout that has the binary in
@@ -148,7 +148,7 @@ async function registerViaClientCli(client, o, cwd) {
         stdio.push('--env', o.env);
     if (o.caps)
         stdio.push('--caps', o.caps);
-    const run = async (args) => {
+    const run = async (args, name = 'sdods') => {
         try {
             await execa(client, args, { cwd, timeout: 30_000 });
             return true;
@@ -159,7 +159,7 @@ async function registerViaClientCli(client, o, cwd) {
                 return false;
             // already registered → remove and re-add so the args are current
             if (/already exists/i.test(msg)) {
-                await execa(client, ['mcp', 'remove', args[2] ?? 'sdods'], { cwd, reject: false });
+                await execa(client, ['mcp', 'remove', name], { cwd, reject: false });
                 await execa(client, args, { cwd, timeout: 30_000 });
                 return true;
             }
@@ -170,26 +170,39 @@ async function registerViaClientCli(client, o, cwd) {
     };
     // A remote server without credentials answers 401 to every call, so the token is part of the
     // registration. Neither form writes the secret: Claude Code expands ${SDODS_TOKEN} from the
-    // environment when it reads .mcp.json, and Codex reads the variable named by
-    // --bearer-token-env-var at connect time.
-    const addArgs = client === 'claude'
+    // environment when it reads .mcp.json, Copilot keeps the ${SDODS_TOKEN} reference as written,
+    // and Codex reads the variable named by --bearer-token-env-var at connect time.
+    const addArgs = client === 'copilot'
         ? o.httpUrl
             ? [
                 'mcp',
                 'add',
-                '-s',
-                'project',
                 '--transport',
                 'http',
-                'sdods',
-                o.httpUrl,
                 '--header',
                 'Authorization: Bearer ${SDODS_TOKEN}',
+                'sdods',
+                o.httpUrl,
             ]
-            : ['mcp', 'add', '-s', 'project', 'sdods', '--', ...stdio]
-        : o.httpUrl
-            ? ['mcp', 'add', 'sdods', '--url', o.httpUrl, '--bearer-token-env-var', 'SDODS_TOKEN']
-            : ['mcp', 'add', 'sdods', '--', ...stdio];
+            : ['mcp', 'add', 'sdods', '--', ...stdio]
+        : client === 'claude'
+            ? o.httpUrl
+                ? [
+                    'mcp',
+                    'add',
+                    '-s',
+                    'project',
+                    '--transport',
+                    'http',
+                    'sdods',
+                    o.httpUrl,
+                    '--header',
+                    'Authorization: Bearer ${SDODS_TOKEN}',
+                ]
+                : ['mcp', 'add', '-s', 'project', 'sdods', '--', ...stdio]
+            : o.httpUrl
+                ? ['mcp', 'add', 'sdods', '--url', o.httpUrl, '--bearer-token-env-var', 'SDODS_TOKEN']
+                : ['mcp', 'add', 'sdods', '--', ...stdio];
     const ok1 = await run(addArgs);
     if (!ok1)
         return false;
@@ -208,7 +221,7 @@ async function registerViaClientCli(client, o, cwd) {
                 '--headless',
             ]
             : ['mcp', 'add', 'playwright', '--', 'npx', 'playwright', 'mcp', '--headless'];
-        await run(pw).catch(() => false);
+        await run(pw, 'playwright').catch(() => false);
     }
     return true;
 }

package/dist/commands/record.js

@@ -132,7 +132,7 @@ export function register(program) {
         .description('Ask the generator agent to turn a recorded spec into a feature + steps proposal (reviewed, never auto-applied)')
         .option('-p, --project <slug>', 'project slug (default: inferred from the spec path)')
         .option('--dry-run', 'print the prompt and plan without calling a model')
-        .option('--adapter <name>', 'claude | claude-code | codex | openai | ollama | fake; default: auto-detect')
+        .option('--adapter <name>', 'claude | claude-code | codex | copilot | openai | ollama | fake; default: auto-detect')
         .option('--model <id>', 'model override')
         .option('--profile <name>', 'auto | full | small — how much of the platform the model is shown')
         .action(async (spec, opts, cmd) => {

package/dist/commands/run.js

@@ -1,9 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { isAbsolute, join, relative, resolve as resolvePath } from 'node:path';
 import { execa } from 'execa';
 import pc from 'picocolors';
 import { RecordingModeSchema, isRunId, 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 { SdodsError, CLI_OVERRIDES_ENV, VERSION, checkPoolCapacity, ciHealSummary, collectGateEvidence, collectHealEvents, 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';
@@ -68,7 +68,7 @@ function addRunOptions(cmd) {
         .option('--fail-on-flaky', 'exit 1 when any test is flaky')
         .option('--max-failures <n>', 'stop after n failures', parseIntFlag('max-failures'))
         .option('--timeout <ms>', 'per-test timeout override', parseIntFlag('timeout'))
-        .option('--reporter <name>', 'reporter override (repeatable, name=outputFile)', collect, [])
+        .option('--reporter <name>', 'add a reporter: junit (XML), allure (allure-results), json, blob, or any Playwright reporter; name=path sets the output (repeatable)', collect, [])
         .option('--reporter-mode <mode>', 'default | server | quiet')
         .option('--trigger <kind>', 'cli | ui | ci | agent | mcp | schedule', 'cli')
         .option('--allow-empty', 'exit 0 when the selection matches no scenario (by default that is exit 2)')
@@ -476,6 +476,26 @@ export async function runCommand(flags, cmd) {
             warn(`trace redaction failed for ${relative(ctx.rootDir, e.file)}: ${e.error}`);
     }
     const summary = readSummary(runDir, runId, exitCode, Date.now() - started);
+    // A heal in CI means the page changed under the suite. It must never pass silently
+    // (heal.ciMode, default warn), so every one is listed as an annotation and in the step summary.
+    if (cfg.runtime.ci) {
+        const heals = ciHealSummary(collectHealEvents(runDir));
+        if (heals) {
+            if (process.env.GITHUB_ACTIONS === 'true' && !ctx.opts.json)
+                for (const a of heals.annotations)
+                    console.log(a);
+            else
+                warn(heals.line);
+            if (process.env.GITHUB_STEP_SUMMARY) {
+                try {
+                    appendFileSync(process.env.GITHUB_STEP_SUMMARY, `${heals.markdown}\n`);
+                }
+                catch {
+                    // a read-only or missing summary file must not fail the run
+                }
+            }
+        }
+    }
     // Process gates are judged here, from the run that just finished, before anything publishes it.
     // One shard of several holds only part of the run, so its pass rate and its a11y/perf evidence
     // are not the run's; a sharded process is gated where the shards are merged

package/dist/program.js

@@ -40,6 +40,7 @@ import { register as registerUpgrade } from './commands/upgrade.js';
 import { register as registerFeedback } from './commands/feedback.js';
 import { register as registerLoad } from './commands/load.js';
 import { register as registerMatrix } from './commands/matrix.js';
+import { register as registerImport } from './commands/import.js';
 /**
  * All commands are registered eagerly (cheap) but each module keeps heavy imports
  * (server, agents, DB, browser runner) inside its action via dynamic import.
@@ -101,6 +102,7 @@ export function buildProgram() {
     registerFeedback(program);
     registerLoad(program);
     registerMatrix(program);
+    registerImport(program);
     return program;
 }
 //# sourceMappingURL=program.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/cli",
-  "version": "0.18.0",
+  "version": "0.20.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/",
@@ -26,8 +26,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.18.0",
-    "@sdods/core": "0.18.0",
+    "@sdods/contracts": "0.20.0",
+    "@sdods/core": "0.20.0",
     "commander": "^15.0.0",
     "execa": "^10.2.1",
     "picocolors": "^1.1.1",
@@ -36,12 +36,12 @@
     "zod": "^4.6.7",
     "@playwright/test": "^1.64.0",
     "playwright-core": "^1.64.0",
-    "@sdods/integrations": "0.18.0",
-    "@sdods/mcp": "0.18.0",
-    "@sdods/agents": "0.18.0",
-    "@sdods/db": "0.18.0",
+    "@sdods/integrations": "0.20.0",
+    "@sdods/mcp": "0.20.0",
+    "@sdods/agents": "0.20.0",
+    "@sdods/db": "0.20.0",
     "csv-parse": "^7.0.3",
-    "@sdods/server": "0.18.0"
+    "@sdods/server": "0.20.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {
@@ -49,7 +49,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/YarlisAISolutions/SDODS.git",
+    "url": "git+https://github.com/YarlisAISolutions/sdods.git",
     "directory": "packages/cli"
   },
   "keywords": [