@smithers-orchestrator/cli 0.20.4 → 0.21.0

package/dist/agent-detection.d.ts

@@ -1,9 +1,11 @@
 type AgentAvailabilityStatus$1 = "likely-subscription" | "api-key" | "binary-only" | "unavailable";
 
 type AgentAvailability$1 = {
-    id: "claude" | "codex" | "gemini" | "pi" | "kimi" | "amp";
+    id: "claude" | "codex" | "antigravity" | "gemini" | "pi" | "kimi" | "amp";
     displayName: string;
     binary: string;
+    deprecated?: boolean;
+    deprecationReason?: string;
     hasBinary: boolean;
     hasAuthSignal: boolean;
     hasApiKeySignal: boolean;
@@ -15,6 +17,15 @@ type AgentAvailability$1 = {
     unusableReasons: string[];
 };
 
+/**
+ * Extracts detection-derived provider ids from a generated `.smithers/agents.ts`.
+ * Account labels are deliberately ignored; the accounts registry remains the
+ * source of truth for account-backed providers.
+ *
+ * @param {string} source
+ * @returns {Set<string>}
+ */
+declare function extractGeneratedDetectionProviderIds(source: string): Set<string>;
 /**
  * @param {AgentAvailability} agent
  */
@@ -33,12 +44,14 @@ declare function detectAvailableAgents(env?: NodeJS.ProcessEnv, options?: {
 }): AgentAvailability[];
 /**
  * @param {NodeJS.ProcessEnv} [env]
- * @param {{ cwd?: string }} [options]
+ * @param {{ cwd?: string; preserveProviderIds?: Iterable<string>; scaffoldProviderIds?: Iterable<string> }} [options]
  */
 declare function generateAgentsTs(env?: NodeJS.ProcessEnv, options?: {
     cwd?: string;
+    preserveProviderIds?: Iterable<string>;
+    scaffoldProviderIds?: Iterable<string>;
 }): string;
 type AgentAvailability = AgentAvailability$1;
 type AgentAvailabilityStatus = AgentAvailabilityStatus$1;
 
-export { type AgentAvailability, type AgentAvailabilityStatus, describeUnavailableAgent, detectAvailableAgents, formatNoUsableAgentsMessage, generateAgentsTs };
+export { type AgentAvailability, type AgentAvailabilityStatus, describeUnavailableAgent, detectAvailableAgents, extractGeneratedDetectionProviderIds, formatNoUsableAgentsMessage, generateAgentsTs };

package/dist/argv-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} argv
+ */
+declare function parseMcpSurfaceArgv(argv: string[]): {
+    surface: string;
+    argv: string[];
+};
+/**
+ * @param {string[]} argv
+ * @returns {number}
+ */
+declare function findFirstPositionalIndex(argv: string[], startIndex?: number): number;
+/**
+ * Incur treats union-typed options as value-bearing flags, so a bare
+ * `--resume --run-id value` would consume `--run-id` as the resume value.
+ *
+ * @param {string[]} argv
+ */
+declare function rewriteBareResumeFlagArgv(argv: string[]): string[];
+
+export { findFirstPositionalIndex, parseMcpSurfaceArgv, rewriteBareResumeFlagArgv };

package/dist/eval-suite.d.ts

@@ -0,0 +1,201 @@
+/**
+ * @param {string} value
+ * @param {string} fallback
+ * @param {number} maxLength
+ */
+declare function slugifyEvalToken(value: string, fallback?: string, maxLength?: number): string;
+/**
+ * @param {unknown} raw
+ * @param {number} index
+ */
+declare function normalizeEvalCase(raw: unknown, index: number): {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    annotations: Record<string, string | number | boolean>;
+    expected: {
+        status: string;
+    };
+    metadata: Record<string, unknown>;
+};
+/**
+ * @param {string} root
+ * @param {string} path
+ * @param {{ maxCases?: number }} [options]
+ */
+declare function loadEvalCases(root: string, path: string, options?: {
+    maxCases?: number;
+}): {
+    path: string;
+    cases: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+        annotations: Record<string, string | number | boolean>;
+        expected: {
+            status: string;
+        };
+        metadata: Record<string, unknown>;
+    }[];
+    totalCases: number;
+};
+/**
+ * @param {string} suiteId
+ * @param {string} caseId
+ */
+declare function evalRunId(suiteId: string, caseId: string): string;
+/**
+ * @param {{
+ *   suiteId?: string;
+ *   runLabel?: string;
+ *   workflowPath: string;
+ *   casesPath: string;
+ *   loadedCases: ReturnType<typeof loadEvalCases>;
+ * }} input
+ */
+declare function buildEvalPlan(input: {
+    suiteId?: string;
+    runLabel?: string;
+    workflowPath: string;
+    casesPath: string;
+    loadedCases: ReturnType<typeof loadEvalCases>;
+}): {
+    suiteId: string;
+    runLabel: string | null;
+    workflowPath: string;
+    casesPath: string;
+    totalCases: number;
+    plannedCases: number;
+    cases: {
+        runId: string;
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+        annotations: Record<string, string | number | boolean>;
+        expected: {
+            status: string;
+        };
+        metadata: Record<string, unknown>;
+    }[];
+};
+/**
+ * @param {{ getRun(runId: string): Promise<unknown> }} adapter
+ * @param {Array<{ runId: string }>} cases
+ */
+declare function assertEvalRunIdsAvailable(adapter: {
+    getRun(runId: string): Promise<unknown>;
+}, cases: Array<{
+    runId: string;
+}>): Promise<void>;
+/**
+ * @param {Array<{ passed: boolean; status?: string; durationMs?: number }>} results
+ */
+declare function summarizeEvalResults(results: Array<{
+    passed: boolean;
+    status?: string;
+    durationMs?: number;
+}>): {
+    total: number;
+    passed: number;
+    failed: number;
+    byStatus: {};
+    durationMs: number;
+};
+/**
+ * @param {ReturnType<typeof normalizeEvalCase>} testCase
+ * @param {{ status?: string; output?: unknown; error?: unknown }} result
+ */
+declare function evaluateEvalCaseResult(testCase: ReturnType<typeof normalizeEvalCase>, result: {
+    status?: string;
+    output?: unknown;
+    error?: unknown;
+}): {
+    passed: boolean;
+    assertions: {
+        name: string;
+        passed: boolean;
+        expected: any;
+        actual: unknown;
+    }[];
+};
+/**
+ * @param {{
+ *   plan: ReturnType<typeof buildEvalPlan>;
+ *   results: Array<Record<string, unknown> & { passed: boolean; status?: string; durationMs?: number }>;
+ *   startedAtMs: number;
+ *   finishedAtMs: number;
+ *   reportPath?: string | null;
+ * }} input
+ */
+declare function buildEvalReport(input: {
+    plan: ReturnType<typeof buildEvalPlan>;
+    results: Array<Record<string, unknown> & {
+        passed: boolean;
+        status?: string;
+        durationMs?: number;
+    }>;
+    startedAtMs: number;
+    finishedAtMs: number;
+    reportPath?: string | null;
+}): {
+    suiteId: string;
+    runLabel: string | null;
+    workflowPath: string;
+    casesPath: string;
+    startedAtMs: number;
+    finishedAtMs: number;
+    durationMs: number;
+    reportPath: string | null;
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        byStatus: {};
+        durationMs: number;
+    };
+    results: (Record<string, unknown> & {
+        passed: boolean;
+        status?: string;
+        durationMs?: number;
+    })[];
+};
+/**
+ * @param {string} root
+ * @param {string} suiteId
+ */
+declare function defaultEvalReportPath(root: string, suiteId: string): string;
+/**
+ * @param {string} root
+ * @param {string} suiteId
+ * @param {string | undefined} path
+ */
+declare function resolveEvalReportPath(root: string, suiteId: string, path: string | undefined): string;
+/**
+ * @param {string} root
+ * @param {string} suiteId
+ * @param {{ path?: string; force?: boolean }} [options]
+ */
+declare function assertEvalReportWritable(root: string, suiteId: string, options?: {
+    path?: string;
+    force?: boolean;
+}): string;
+/**
+ * @param {string} root
+ * @param {Record<string, unknown>} report
+ * @param {{ path?: string; force?: boolean }} [options]
+ */
+declare function writeEvalReport(root: string, report: Record<string, unknown>, options?: {
+    path?: string;
+    force?: boolean;
+}): string;
+/**
+ * @param {ReturnType<typeof buildEvalPlan>} plan
+ */
+declare function renderEvalPlan(plan: ReturnType<typeof buildEvalPlan>): string;
+/**
+ * @param {ReturnType<typeof buildEvalReport>} report
+ */
+declare function renderEvalReport(report: ReturnType<typeof buildEvalReport>): string;
+declare const EVAL_CASE_STATUSES: string[];
+
+export { EVAL_CASE_STATUSES, assertEvalReportWritable, assertEvalRunIdsAvailable, buildEvalPlan, buildEvalReport, defaultEvalReportPath, evalRunId, evaluateEvalCaseResult, loadEvalCases, normalizeEvalCase, renderEvalPlan, renderEvalReport, resolveEvalReportPath, slugifyEvalToken, summarizeEvalResults, writeEvalReport };

package/dist/hijack.d.ts

@@ -1,7 +1,7 @@
 import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
 import { H as HijackCandidate$1 } from './HijackCandidate-FxLeKpcZ.js';
 
-type NativeHijackEngine$1 = "claude-code" | "codex" | "gemini" | "pi" | "kimi" | "forge" | "amp";
+type NativeHijackEngine$1 = "claude-code" | "antigravity" | "codex" | "gemini" | "pi" | "kimi" | "forge" | "amp";
 
 type HijackLaunchSpec$1 = {
     command: string;

package/dist/json-args.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {string | undefined} raw
+ * @param {string} label
+ * @returns {string | undefined}
+ */
+declare function readJsonArgumentPayload(raw: string | undefined, label: string): string | undefined;
+/**
+ * @param {string | undefined} raw
+ * @param {string} label
+ */
+declare function parseJsonArgument(raw: string | undefined, label: string): any;
+/**
+ * @param {string | undefined} raw
+ * @param {string} label
+ * @param {(opts: { code: string; message: string; exitCode: number }) => unknown} fail
+ */
+declare function parseJsonInput(raw: string | undefined, label: string, fail: (opts: {
+    code: string;
+    message: string;
+    exitCode: number;
+}) => unknown): any;
+declare const CLI_JSON_ARGUMENT_MAX_BYTES: number;
+
+export { CLI_JSON_ARGUMENT_MAX_BYTES, parseJsonArgument, parseJsonInput, readJsonArgumentPayload };

package/dist/token-store.d.ts

@@ -0,0 +1,8 @@
+declare function smithersTokenStorePath(): string;
+declare function readSmithersTokenStore(): {
+    tokens: any;
+};
+declare function writeSmithersTokenStore(store: any): void;
+declare function parseTokenScopes(raw: any): any;
+
+export { parseTokenScopes, readSmithersTokenStore, smithersTokenStorePath, writeSmithersTokenStore };

package/dist/workflows.d.ts

@@ -2,8 +2,12 @@ type WorkflowSourceType$1 = "user" | "seeded" | "generated" | (string & {});
 
 type DiscoveredWorkflow$1 = {
     id: string;
+    metadataVersion: 1;
     displayName: string;
     sourceType: WorkflowSourceType$1;
+    description: string;
+    tags: string[];
+    aliases: string[];
     entryFile: string;
     path: string;
 };
@@ -29,7 +33,32 @@ declare function resolveWorkflow(id: string, root: string): DiscoveredWorkflow;
  * @returns {DiscoveredWorkflow}
  */
 declare function createWorkflowFile(name: string, root: string): DiscoveredWorkflow;
+/**
+ * @param {DiscoveredWorkflow} workflow
+ * @param {{ root?: string }} [options]
+ * @returns {string}
+ */
+declare function renderWorkflowSkill(workflow: DiscoveredWorkflow, options?: {
+    root?: string;
+}): string;
+/**
+ * @param {string} root
+ * @param {{ workflowId?: string; output?: string; force?: boolean }} [options]
+ */
+declare function writeWorkflowSkillFiles(root: string, options?: {
+    workflowId?: string;
+    output?: string;
+    force?: boolean;
+}): {
+    rootDir: string;
+    workflowId: string;
+    outputPath: string;
+    force: boolean;
+    workflows: DiscoveredWorkflow$1[];
+    writtenFiles: string[];
+    skippedFiles: string[];
+};
 type WorkflowSourceType = WorkflowSourceType$1;
 type DiscoveredWorkflow = DiscoveredWorkflow$1;
 
-export { type DiscoveredWorkflow, type WorkflowSourceType, createWorkflowFile, discoverWorkflows, resolveWorkflow, validateWorkflowName };
+export { type DiscoveredWorkflow, type WorkflowSourceType, createWorkflowFile, discoverWorkflows, renderWorkflowSkill, resolveWorkflow, validateWorkflowName, writeWorkflowSkillFiles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/cli",
-  "version": "0.20.4",
+  "version": "0.21.0",
   "description": "Smithers command-line interface, MCP server, and local workflow tools",
   "type": "module",
   "sideEffects": false,
@@ -32,21 +32,21 @@
     "picocolors": "^1.1.1",
     "react": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/accounts": "0.20.4",
-    "@smithers-orchestrator/agents": "0.20.4",
-    "@smithers-orchestrator/components": "0.20.4",
-    "@smithers-orchestrator/db": "0.20.4",
-    "@smithers-orchestrator/devtools": "0.20.4",
-    "@smithers-orchestrator/driver": "0.20.4",
-    "@smithers-orchestrator/errors": "0.20.4",
-    "@smithers-orchestrator/observability": "0.20.4",
-    "@smithers-orchestrator/protocol": "0.20.4",
-    "@smithers-orchestrator/scheduler": "0.20.4",
-    "@smithers-orchestrator/engine": "0.20.4",
-    "@smithers-orchestrator/server": "0.20.4",
-    "@smithers-orchestrator/time-travel": "0.20.4",
-    "@smithers-orchestrator/memory": "0.20.4",
-    "@smithers-orchestrator/openapi": "0.20.4"
+    "@smithers-orchestrator/accounts": "0.21.0",
+    "@smithers-orchestrator/agents": "0.21.0",
+    "@smithers-orchestrator/db": "0.21.0",
+    "@smithers-orchestrator/driver": "0.21.0",
+    "@smithers-orchestrator/devtools": "0.21.0",
+    "@smithers-orchestrator/engine": "0.21.0",
+    "@smithers-orchestrator/errors": "0.21.0",
+    "@smithers-orchestrator/memory": "0.21.0",
+    "@smithers-orchestrator/observability": "0.21.0",
+    "@smithers-orchestrator/protocol": "0.21.0",
+    "@smithers-orchestrator/openapi": "0.21.0",
+    "@smithers-orchestrator/server": "0.21.0",
+    "@smithers-orchestrator/time-travel": "0.21.0",
+    "@smithers-orchestrator/scheduler": "0.21.0",
+    "@smithers-orchestrator/components": "0.21.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/AgentAvailability.ts

@@ -1,9 +1,11 @@
 import type { AgentAvailabilityStatus } from "./AgentAvailabilityStatus.ts";
 
 export type AgentAvailability = {
-    id: "claude" | "codex" | "gemini" | "pi" | "kimi" | "amp";
+    id: "claude" | "codex" | "antigravity" | "gemini" | "pi" | "kimi" | "amp";
     displayName: string;
     binary: string;
+    deprecated?: boolean;
+    deprecationReason?: string;
     hasBinary: boolean;
     hasAuthSignal: boolean;
     hasApiKeySignal: boolean;

package/src/AskOptions.ts

@@ -1,6 +1,6 @@
 import type { SmithersToolSurface } from "@smithers-orchestrator/agents/agent-contract";
 
-export type AskAgentId = "claude" | "codex" | "kimi" | "gemini" | "pi";
+export type AskAgentId = "claude" | "codex" | "kimi" | "antigravity" | "gemini" | "pi";
 
 export type AskOptions = {
     agent?: AskAgentId;

package/src/DiscoveredWorkflow.ts

@@ -2,8 +2,12 @@ import type { WorkflowSourceType } from "./WorkflowSourceType.ts";
 
 export type DiscoveredWorkflow = {
     id: string;
+    metadataVersion: 1;
     displayName: string;
     sourceType: WorkflowSourceType;
+    description: string;
+    tags: string[];
+    aliases: string[];
     entryFile: string;
     path: string;
 };

package/src/NativeHijackEngine.ts

@@ -1,5 +1,6 @@
 export type NativeHijackEngine =
     | "claude-code"
+    | "antigravity"
     | "codex"
     | "gemini"
     | "pi"

package/src/agent-commands/agentAddWizard.js

@@ -6,8 +6,9 @@ import { runAgentAdd, pingAccount } from "./runAgentAdd.js";
 
 const PROVIDER_CHOICES = [
     { value: "claude-code", label: "Claude Code (subscription)", hint: "Pro / Max plan via `claude` CLI" },
+    { value: "antigravity", label: "Antigravity (subscription)", hint: "Google account via `agy` CLI" },
     { value: "codex", label: "Codex (subscription)", hint: "ChatGPT Plus/Pro via `codex` CLI" },
-    { value: "gemini", label: "Gemini (subscription)", hint: "Google account via `gemini` CLI" },
+    { value: "gemini", label: "Gemini (deprecated subscription)", hint: "Legacy/enterprise Google account via `gemini` CLI" },
     { value: "kimi", label: "Kimi (subscription)", hint: "OAuth via `kimi` CLI" },
     { value: "anthropic-api", label: "Anthropic API key", hint: "Pay-per-token via api.anthropic.com" },
     { value: "openai-api", label: "OpenAI API key", hint: "Pay-per-token via api.openai.com (used by Codex)" },
@@ -16,6 +17,7 @@ const PROVIDER_CHOICES = [
 
 const SUBSCRIPTION_LOGIN_BIN = {
     "claude-code": "claude",
+    "antigravity": "agy",
     "codex": "codex",
     "gemini": "gemini",
     "kimi": "kimi",
@@ -23,6 +25,7 @@ const SUBSCRIPTION_LOGIN_BIN = {
 
 const SUBSCRIPTION_DIR_ENV_VAR = {
     "claude-code": "CLAUDE_CONFIG_DIR",
+    "antigravity": "GEMINI_DIR",
     "codex": "CODEX_HOME",
     "gemini": "GEMINI_DIR",
     "kimi": "KIMI_SHARE_DIR",
@@ -33,15 +36,24 @@ const SUBSCRIPTION_DIR_ENV_VAR = {
  * dedicated subcommand (`codex login`, `kimi login`); others authenticate via
  * a slash command inside the REPL (`claude` then /login).
  *
- * @type {Record<string, { args: string[]; postInstructions?: string }>}
+ * @type {Record<string, { args: string[] | ((configDir: string) => string[]); postInstructions?: string }>}
  */
 const SUBSCRIPTION_LOGIN_RECIPE = {
     "claude-code": { args: [], postInstructions: "Inside Claude Code, type /login and follow the browser flow." },
+    "antigravity": { args: (configDir) => ["--gemini_dir", configDir], postInstructions: "Antigravity will open Google Sign-In or print a browser authorization URL." },
     "codex": { args: ["login"] },
     "gemini": { args: [], postInstructions: "Inside Gemini, type /auth (or follow the prompt) to sign in." },
     "kimi": { args: ["login"] },
 };
 
+/**
+ * @param {string[] | ((configDir: string) => string[])} args
+ * @param {string} configDir
+ */
+function resolveLoginArgs(args, configDir) {
+    return typeof args === "function" ? args(configDir) : args;
+}
+
 function bail() {
     outro("Cancelled.");
     process.exit(130);
@@ -102,7 +114,8 @@ export async function agentAddWizard(opts = {}) {
             const bin = SUBSCRIPTION_LOGIN_BIN[provider];
             const envVar = SUBSCRIPTION_DIR_ENV_VAR[provider];
             const recipe = SUBSCRIPTION_LOGIN_RECIPE[provider] ?? { args: [] };
-            const loginCmd = `${envVar}=${configDir} ${bin}${recipe.args.length ? " " + recipe.args.join(" ") : ""}`;
+            const loginArgs = resolveLoginArgs(recipe.args, configDir);
+            const loginCmd = `${envVar}=${configDir} ${bin}${loginArgs.length ? " " + loginArgs.join(" ") : ""}`;
             const lines = [
                 "Open another terminal and run:",
                 "",

package/src/agent-commands/regenerateAgentsTsIfPresent.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { generateAgentsTs } from "../agent-detection.js";
+import { extractGeneratedDetectionProviderIds, generateAgentsTs } from "../agent-detection.js";
 
 /**
  * If the current working directory contains a `.smithers/agents.ts` that was
@@ -19,7 +19,20 @@ export function regenerateAgentsTsIfPresent(cwd = process.cwd()) {
     if (!existing.startsWith("// smithers-source: generated")) {
         return { rewritten: false, path, reason: "agents.ts has been edited by hand; not overwriting" };
     }
-    const next = generateAgentsTs(process.env);
+    const scaffoldFiles = {
+        claude: "claude-code.ts",
+        codex: "codex.ts",
+        antigravity: "antigravity.ts",
+        gemini: "gemini.ts",
+    };
+    const scaffoldProviderIds = Object.entries(scaffoldFiles)
+        .filter(([, file]) => existsSync(join(cwd, ".smithers", "agents", file)))
+        .map(([providerId]) => providerId);
+    const next = generateAgentsTs(process.env, {
+        cwd,
+        preserveProviderIds: extractGeneratedDetectionProviderIds(existing),
+        scaffoldProviderIds,
+    });
     if (next === existing) {
         return { rewritten: false, path, reason: "no changes" };
     }

package/src/agent-commands/runAgentAdd.js

@@ -12,6 +12,7 @@ import { regenerateAgentsTsIfPresent } from "./regenerateAgentsTsIfPresent.js";
  */
 const SUBSCRIPTION_LOGIN_BIN = {
     "claude-code": "claude",
+    "antigravity": "agy",
     "codex": "codex",
     "gemini": "gemini",
     "kimi": "kimi",
@@ -24,10 +25,11 @@ const SUBSCRIPTION_LOGIN_BIN = {
  * Subcommand args appended to the login command. Some CLIs use a dedicated
  * subcommand (`codex login`, `kimi login`); others authenticate via a slash
  * command inside the REPL (the user types /login after launching).
- * @type {Record<string, string[]>}
+ * @type {Record<string, string[] | ((configDir: string) => string[])>}
  */
 const SUBSCRIPTION_LOGIN_ARGS = {
     "claude-code": [],
+    "antigravity": (configDir) => ["--gemini_dir", configDir],
     "codex": ["login"],
     "gemini": [],
     "kimi": ["login"],
@@ -39,6 +41,7 @@ const SUBSCRIPTION_LOGIN_ARGS = {
  */
 const SUBSCRIPTION_DIR_ENV_VAR = {
     "claude-code": "CLAUDE_CONFIG_DIR",
+    "antigravity": "GEMINI_DIR",
     "codex": "CODEX_HOME",
     "gemini": "GEMINI_DIR",
     "kimi": "KIMI_SHARE_DIR",
@@ -47,6 +50,15 @@ const SUBSCRIPTION_DIR_ENV_VAR = {
     "gemini-api": null,
 };
 
+/**
+ * @param {string} provider
+ * @param {string} configDir
+ */
+function subscriptionLoginArgs(provider, configDir) {
+    const args = SUBSCRIPTION_LOGIN_ARGS[provider] ?? [];
+    return typeof args === "function" ? args(configDir) : args;
+}
+
 /**
  * @param {string} dir
  * @returns {boolean}
@@ -94,7 +106,7 @@ export function runAgentAdd(input) {
         if (!populated && !input.skipLogin && !input.force) {
             const bin = SUBSCRIPTION_LOGIN_BIN[input.provider];
             const envVar = SUBSCRIPTION_DIR_ENV_VAR[input.provider];
-            const subArgs = SUBSCRIPTION_LOGIN_ARGS[input.provider] ?? [];
+            const subArgs = subscriptionLoginArgs(input.provider, configDir);
             const cmd = `${envVar}=${configDir} ${bin}${subArgs.length ? " " + subArgs.join(" ") : ""}`;
             const detail = `Config dir ${configDir} is empty. Run the following in another terminal to log in, then re-run \`smithers agents add\`:\n\n  ${cmd}\n\n(or pass --skip-login to register the empty dir, --force to register without verification)`;
             return { ok: false, reason: "login-required", detail, configDir };