@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.0

package/src/commands/connections.js

@@ -0,0 +1,93 @@
+/**
+ * Operator diagnostics for AgentSam connections (Cloudflare account grant).
+ * Identity (who is this user?) is separate from the Cloudflare connector.
+ */
+import {
+  CLOUDFLARE_CALLBACK_PATH,
+  CLOUDFLARE_FIXTURE_CLIENT_ID,
+  cloudflareConnectionSafeStatus,
+  resolveCloudflareOAuthClient,
+} from '../../packages/connectors/cloudflare/src/index.js';
+import { resolveIamIssuer } from '../../packages/identity/src/contracts/auth-config.js';
+
+const PRODUCTION_CALLBACK = `https://agentsam.inneranimalmedia.com${CLOUDFLARE_CALLBACK_PATH}`;
+
+function doctor(env = process.env) {
+  const iam = {
+    issuer: resolveIamIssuer(env),
+    clientId: Boolean(String(env.IAM_CLIENT_ID || '').trim()),
+    serverSecret: Boolean(String(env.IAM_CLIENT_SECRET || '').trim()),
+    originAlias: Boolean(String(env.IAM_ORIGIN || '').trim()),
+  };
+  const cf = cloudflareConnectionSafeStatus(env);
+  const client = resolveCloudflareOAuthClient(env);
+  return { identity: iam, cloudflare: cf, client };
+}
+
+function printSetup(env = process.env) {
+  const client = resolveCloudflareOAuthClient(env);
+  console.log('Cloudflare connector setup');
+  console.log('');
+  console.log(`  callback: ${PRODUCTION_CALLBACK}`);
+  console.log('  authorize: https://dash.cloudflare.com/oauth2/auth');
+  console.log('  token:     https://dash.cloudflare.com/oauth2/token');
+  console.log('  revoke:    https://dash.cloudflare.com/oauth2/revoke');
+  console.log('');
+  console.log('This CLI does not mint a real Cloudflare OAuth client.');
+  console.log('Fixture client id ' + CLOUDFLARE_FIXTURE_CLIENT_ID + ' is local-only and must never be installed on production.');
+  if (client.fixture) {
+    console.log('STOP: fixture credentials are loaded. OAuth start will return 503.');
+  } else if (client.status === 'not_configured') {
+    console.log('status: not_configured — production may deploy; connector stays optional.');
+  } else {
+    console.log(`status: ${client.status}`);
+  }
+  return 0;
+}
+
+export async function runConnections(args = []) {
+  const argv = args.filter((a) => a !== '--json');
+  const jsonMode = args.includes('--json');
+  const env = process.env;
+  if (argv[0] === 'cloudflare' && argv[1] === 'setup') {
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        callback: PRODUCTION_CALLBACK,
+        authorize: 'https://dash.cloudflare.com/oauth2/auth',
+        token: 'https://dash.cloudflare.com/oauth2/token',
+        revoke: 'https://dash.cloudflare.com/oauth2/revoke',
+        mintsRealClient: false,
+        client: resolveCloudflareOAuthClient(env),
+      }, null, 2));
+      return 0;
+    }
+    return printSetup(env);
+  }
+  const report = doctor(env);
+  if (jsonMode) {
+    console.log(JSON.stringify({ identity: report.identity, cloudflare: report.cloudflare }, null, 2));
+    return 0;
+  }
+  const iam = report.identity;
+  const cf = report.cloudflare;
+  const client = report.client;
+  console.log('AgentSam Identity');
+  console.log('');
+  console.log('IAM client');
+  console.log(`  ${iam.clientId ? '✓' : '•'} client id`);
+  console.log(`  ✓ issuer ${iam.issuer}`);
+  console.log(`  ${iam.serverSecret ? '✓' : '•'} server secret configured`);
+  if (iam.originAlias) console.log('Compatibility\n  IAM_ORIGIN -> deprecated alias');
+  console.log('');
+  console.log('Cloudflare connection');
+  console.log('');
+  console.log('OAuth client');
+  console.log(`  client id: ${cf.clientId}`);
+  console.log(`  secret: ${cf.secret}`);
+  console.log(`  status: ${client.status}`);
+  if (client.fixture) {
+    console.log('  OAuth client fixture configured');
+    console.log('  real Cloudflare OAuth client still required');
+  }
+  return 0;
+}

package/src/commands/context-economics.js

@@ -0,0 +1,114 @@
+import { createContextBudget, assessContextUsage } from '../context/index.js';
+import { getModelRecord } from '../models/index.js';
+import { readCliPreferences } from '../lib/cli-preferences.js';
+
+function formatInteger(value) {
+  return Number(value).toLocaleString('en-US');
+}
+
+function percent(value) {
+  return `${(Number(value) * 100).toFixed(1)}%`;
+}
+
+export function buildContextEconomicsReport(cwd, options = {}) {
+  const preferences = options.preferences || readCliPreferences(cwd) || {};
+  const model = getModelRecord(preferences.modelPreference);
+  if (!model) {
+    return Object.freeze({
+      model: preferences.modelPreference || 'auto',
+      resolved: false,
+      reason: 'Select an exact catalog model with /model before Agent Sam can calculate model-specific context economics.',
+      reasoning_effort: preferences.reasoningEffort || 'auto',
+      service_tier: preferences.serviceTier || 'default',
+      active_input_tokens: null,
+    });
+  }
+
+  const policy = model.context_policy || {};
+  const budget = createContextBudget({
+    windowTokens: model.context_window,
+    targetInputTokens: policy.target_input_tokens,
+    compactAtTokens: policy.compact_at_tokens,
+    interveneAtTokens: policy.intervene_at_tokens,
+    maxNormalInputTokens: policy.max_normal_input_tokens,
+    pricingThresholdTokens: policy.pricing_threshold_tokens,
+    safetyMarginTokens: policy.safety_margin_tokens,
+  });
+  const active = Number.isFinite(options.activeInputTokens) && options.activeInputTokens >= 0
+    ? Math.floor(options.activeInputTokens)
+    : null;
+  const pressure = active == null ? null : assessContextUsage(active, budget);
+
+  return Object.freeze({
+    model: model.provider_model_id,
+    model_key: model.model_key,
+    resolved: true,
+    reasoning_effort: preferences.reasoningEffort || 'auto',
+    service_tier: preferences.serviceTier || 'default',
+    active_input_tokens: active,
+    estimate_kind: options.estimateKind === 'provider' ? 'provider' : active == null ? null : 'local',
+    window_tokens: budget.windowTokens,
+    utilization_ratio: pressure?.utilizationRatio ?? null,
+    target_input_tokens: budget.targetInputTokens,
+    compact_at_tokens: budget.compactAtTokens,
+    intervene_at_tokens: budget.interveneAtTokens,
+    max_normal_input_tokens: budget.maxNormalInputTokens,
+    pricing_threshold_tokens: budget.pricingThresholdTokens,
+    tokens_until_pricing_threshold: pressure?.tokensUntilPricingThreshold ?? null,
+    pressure: pressure?.stage ?? 'unknown',
+    should_compact: pressure?.shouldCompact ?? false,
+    should_intervene: pressure?.shouldIntervene ?? false,
+    pricing_threshold_crossed: pressure?.pricingThresholdCrossed ?? false,
+    batch: model.batch,
+    pricing_source: model.pricing?.source || null,
+    pricing_as_of: model.pricing?.as_of || null,
+  });
+}
+
+export function renderContextEconomics(report) {
+  if (!report.resolved) {
+    return [
+      '',
+      '  Agent Sam · context',
+      `  model            ${report.model}`,
+      `  reasoning        ${report.reasoning_effort}`,
+      `  processing       ${report.service_tier}`,
+      '',
+      `  ${report.reason}`,
+      '',
+    ].join('\n');
+  }
+
+  const active = report.active_input_tokens == null
+    ? 'unavailable · no provider/local usage snapshot yet'
+    : `${report.estimate_kind === 'provider' ? '' : '~'}${formatInteger(report.active_input_tokens)}${report.utilization_ratio == null ? '' : ` · ${percent(report.utilization_ratio)} of window`}`;
+  const remaining = report.tokens_until_pricing_threshold == null
+    ? 'unavailable until active usage is known'
+    : `${report.tokens_until_pricing_threshold < 0 ? '-' : ''}${formatInteger(Math.abs(report.tokens_until_pricing_threshold))}`;
+  return [
+    '',
+    '  Agent Sam · context',
+    `  model            ${report.model}`,
+    `  reasoning        ${report.reasoning_effort}`,
+    `  processing       ${report.service_tier}`,
+    '',
+    '  Context',
+    `    active          ${active}`,
+    `    window          ${formatInteger(report.window_tokens)}`,
+    '',
+    '  Working-set policy',
+    `    target          ${formatInteger(report.target_input_tokens)}`,
+    `    compact at      ${formatInteger(report.compact_at_tokens)}`,
+    `    intervene at    ${formatInteger(report.intervene_at_tokens)}`,
+    `    max normal      ${formatInteger(report.max_normal_input_tokens)}`,
+    '',
+    '  Economics',
+    `    price threshold ${formatInteger(report.pricing_threshold_tokens)}`,
+    `    remaining       ${remaining}`,
+    `    pricing as-of   ${report.pricing_as_of || 'unknown'}`,
+    '',
+    '  Batch is a separate asynchronous execution lane; it is not an interactive service tier.',
+    '  Use `/context repo` for repository/Git bridge context.',
+    '',
+  ].join('\n');
+}

package/src/commands/deploy.js

@@ -6,8 +6,9 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { authenticateViaBrowser } from '../lib/auth.js';
 import { getJson, streamScaffold } from '../lib/core-client.js';
-import { resolveSdkKey } from '../../packages/identity/src/contracts/auth-config.js';
+import { resolveAccountSdkKey } from '../lib/account-session.js';
 import { getDefaultProfile, getDeployTarget, getLocalSchemaPath, getProjectName, getProjectPreset, readProjectConfig, setDeployTarget, writeProjectConfig } from '../lib/project-config.js';
+import { isLocalStudioCheckout, runLocalStudioDeploy } from '../lib/deploy/local-studio.js';
 
 function writeCloudflareAdapter(cwd, config, cf) {
   const projectName = getProjectName(config, path.basename(cwd));
@@ -67,7 +68,7 @@ function ask(question) {
 async function runCloudflareDeploy(cwd, config, accountId) {
   console.log('\n  Cloudflare deploy — browser sign-in + resource provisioning…\n');
 
-  let token = resolveSdkKey(process.env);
+  let token = resolveAccountSdkKey({ env: process.env }).value;
   if (!token) {
     const session = await authenticateViaBrowser();
     token = session.access_token;
@@ -122,10 +123,45 @@ async function runCloudflareDeploy(cwd, config, accountId) {
 }
 
 /**
- * @param {{ cwd?: string, target?: string, accountId?: string }} [opts]
+ * @param {{ cwd?: string, target?: string, accountId?: string, dryRun?: boolean, plan?: boolean }} [opts]
  */
 export async function runDeploy(opts = {}) {
   const cwd = path.resolve(opts.cwd || process.cwd());
+
+  if (isLocalStudioCheckout(cwd)) {
+    const result = await runLocalStudioDeploy({
+      cwd,
+      dryRun: Boolean(opts.dryRun),
+      planOnly: Boolean(opts.plan),
+      execute: !opts.plan,
+    });
+    const payload = {
+      provider: result.plan.provider,
+      app: result.plan.app,
+      wranglerConfig: result.plan.wranglerConfig,
+      wranglerArgs: result.plan.wranglerArgs,
+      cwd: result.plan.cwd,
+      envLoaded: result.plan.envLoaded,
+      fingerprint: result.plan.fingerprint,
+      skip: result.plan.skip,
+      dryRun: Boolean(opts.dryRun),
+      plan: Boolean(opts.plan),
+      genericRootDeploy: false,
+      receipt: result.receipt,
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    if (result.plan.skip) {
+      console.log('skip: unchanged deploy fingerprint');
+    } else if (opts.plan) {
+      console.log('plan only — no wrangler deploy');
+    } else if (opts.dryRun) {
+      console.log('wrangler dry-run complete');
+    } else {
+      console.log('local-studio deploy complete');
+    }
+    return result;
+  }
+
   const config = readProjectConfig(cwd);
 
   let target = opts.target || getDeployTarget(config) || 'cloudflare';

package/src/commands/eval.js

@@ -0,0 +1,63 @@
+import { evaluateContextFixture, listContextEvalFixtures } from '../eval/index.js';
+
+function parse(argv) {
+  const out = { subcommand: argv[0] || '', fixture: '', strategy: 'all', model: 'gpt-6-astra', json: false, list: false };
+  for (let i = 1; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--fixture') out.fixture = argv[++i] || '';
+    else if (arg === '--strategy') out.strategy = argv[++i] || 'all';
+    else if (arg === '--model') out.model = argv[++i] || 'gpt-6-astra';
+    else if (arg === '--json') out.json = true;
+    else if (arg === '--list') out.list = true;
+    else if (arg === '--help' || arg === '-h') out.help = true;
+    else throw new Error(`unknown eval option: ${arg}`);
+  }
+  return out;
+}
+
+function render(report) {
+  const rows = [
+    '',
+    '  AgentSam · Context Eval',
+    '',
+    `  fixture          ${report.fixture}`,
+    `  model            ${report.model}`,
+    `  provider call    no · deterministic/offline`,
+    '',
+  ];
+  for (const row of report.strategies) {
+    rows.push(`  ${row.strategy.toUpperCase()}`);
+    rows.push(`    result           ${row.result}`);
+    rows.push(`    evidence         ${row.required_found} / ${row.required_evidence} required · ${row.sources_selected} / ${row.sources_considered} selected`);
+    rows.push(`    active context   ~${row.active_context_tokens.toLocaleString('en-US')}`);
+    rows.push(`    window           ${row.window_tokens.toLocaleString('en-US')}`);
+    rows.push(`    price threshold  ${row.pricing_threshold_tokens.toLocaleString('en-US')}`);
+    rows.push(`    remaining        ${row.tokens_until_pricing_threshold.toLocaleString('en-US')}`);
+    rows.push(`    tool schemas     ${row.hydrated_tools} · ${row.tool_schema_chars.toLocaleString('en-US')} chars`);
+    rows.push(`    compacted        ${row.compacted_chars.toLocaleString('en-US')} chars`);
+    rows.push(`    rehydrated       ${row.rehydrated_refs.length ? row.rehydrated_refs.join(', ') : 'none'}`);
+    rows.push(`    est input cost   $${row.estimated_input_cost_usd.toFixed(4)}`);
+    rows.push('');
+  }
+  rows.push(`  winner           ${report.winner}`);
+  rows.push(`  scoring          ${report.scoring.join(' → ')}`);
+  rows.push('');
+  return rows.join('\n');
+}
+
+export async function runEval(argv = [], options = {}) {
+  const args = parse(argv);
+  const write = options.write || (text => process.stdout.write(text));
+  if (args.help || args.subcommand !== 'context') {
+    write('agentsam eval context --fixture <name> [--strategy bounded|discovery|compact|all] [--model gpt-6-astra] [--json]\n');
+    return null;
+  }
+  if (args.list) {
+    const value = { fixtures: listContextEvalFixtures() };
+    write(args.json ? `${JSON.stringify(value)}\n` : `${value.fixtures.join('\n')}\n`);
+    return value;
+  }
+  const report = await evaluateContextFixture({ fixture: args.fixture || 'exact-symbol-callers', strategy: args.strategy, model: args.model });
+  write(args.json ? `${JSON.stringify(report)}\n` : render(report));
+  return report;
+}

package/src/commands/interactive.js

@@ -7,15 +7,12 @@ export async function runInteractive(options = {}) {
   let identity = detectCliProject(options.cwd || process.cwd());
   let preferences = readCliPreferences(identity.root);
 
-  if (!preferences) {
+  if (!preferences || preferences.trustedDirectory !== true) {
     const configured = await configureCliPreferences({ cwd: identity.root, firstRun: true });
     identity = configured.identity;
     preferences = configured.preferences;
   }
 
   await runBootScene({ identity, preferences, animate: options.animate !== false });
-  await runShell([], {
-    cwd: identity.root,
-    intro: 'quiet',
-  });
+  await runShell([], { cwd: identity.root, intro: 'quiet' });
 }

package/src/commands/models.js

@@ -1,33 +1,81 @@
 import pc from 'picocolors';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
+import { listModelCatalog } from '../models/index.js';
+import { resolveProviderCredential } from '../lib/provider-credentials.js';
 
 const API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', credential: 'OPENAI_API_KEY' },
   { id: 'gemini', label: 'Gemini', credential: 'GEMINI_API_KEY' },
   { id: 'grok', label: 'Grok', credential: 'XAI_API_KEY' },
+  { id: 'anthropic', label: 'Anthropic', credential: 'ANTHROPIC_API_KEY' },
 ]);
 
-function clean(value) {
-  return value == null ? '' : String(value).trim();
-}
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function configured(value) { return Boolean(clean(value)); }
 
-function configured(value) {
-  return Boolean(clean(value));
+async function discoverOpenAIModels(apiKey, fetchImpl) {
+  if (!apiKey) return { attempted: false, ok: false, models: [], error: null };
+  try {
+    const response = await fetchImpl('https://api.openai.com/v1/models', {
+      headers: { authorization: `Bearer ${apiKey}` },
+      signal: typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(8_000) : undefined,
+    });
+    if (!response.ok) return { attempted: true, ok: false, models: [], error: `HTTP ${response.status}` };
+    const body = await response.json();
+    const models = Array.isArray(body?.data) ? body.data.map((row) => clean(row?.id)).filter(Boolean) : [];
+    return { attempted: true, ok: true, models, error: null };
+  } catch (error) {
+    return { attempted: true, ok: false, models: [], error: error?.message || String(error) };
+  }
 }
 
 export async function collectModelsStatus(options = {}) {
   const env = options.env || process.env;
-  const fetchImpl = options.fetchImpl || fetch;
+  const ollamaFetchImpl = options.fetchImpl || fetch;
+  const providerFetchImpl = options.providerFetchImpl || fetch;
   const ollamaConfig = resolveOllamaConfig({}, env);
-  const ollama = await probeOllama(ollamaConfig, fetchImpl);
+  const ollama = await probeOllama(ollamaConfig, ollamaFetchImpl);
+  const credentials = new Map(API_PROVIDERS.map((provider) => [provider.id, resolveProviderCredential(provider.id, { env, home: options.home })]));
+  const providers = API_PROVIDERS.map((provider) => {
+    const credential = credentials.get(provider.id);
+    return {
+      ...provider,
+      configured: credential?.configured === true,
+      source: credential?.source || null,
+      credentialError: credential?.error || null,
+    };
+  });
+
+  const openaiCredential = credentials.get('openai');
+  const shouldDiscover = options.discoverRemote !== false && Boolean(openaiCredential?.configured);
+  const openai = shouldDiscover
+    ? await discoverOpenAIModels(clean(openaiCredential?.value), providerFetchImpl)
+    : { attempted: false, ok: false, models: [], error: null };
+  const availableIds = new Set(openai.models);
+  const catalogModels = listModelCatalog().map((record) => ({
+    model_key: record.model_key,
+    provider: record.provider,
+    provider_model_id: record.provider_model_id,
+    label: record.label,
+    availability: record.provider === 'openai' && openai.ok
+      ? (availableIds.has(record.provider_model_id) ? 'available' : 'unavailable')
+      : 'unverified',
+    source: record.source,
+  }));
 
   return {
-    schemaVersion: 'agentsam-model-inventory-v1',
-    providers: API_PROVIDERS.map((provider) => ({
-      ...provider,
-      configured: configured(env[provider.credential]),
-      source: 'environment',
-    })),
+    schemaVersion: 'agentsam-model-inventory-v2',
+    providers,
+    discovery: {
+      openai: {
+        attempted: openai.attempted,
+        ok: openai.ok,
+        error: openai.error,
+        returnedModelCount: openai.models.length,
+      },
+    },
+    catalogModels,
+    availableModels: catalogModels.filter((row) => row.availability === 'available'),
     local: {
       provider: 'ollama',
       configured: ollama.online,
@@ -41,67 +89,64 @@ export async function collectModelsStatus(options = {}) {
   };
 }
 
-function statusMark(ok) {
-  return ok ? pc.green('●') : pc.dim('○');
-}
-
-function writeLine(write, value = '') {
-  write(`${value}\n`);
-}
+function statusMark(ok) { return ok ? pc.green('●') : pc.dim('○'); }
+function writeLine(write, value = '') { write(`${value}\n`); }
 
 export function renderModelsStatus(status) {
   const lines = [];
   lines.push('');
   lines.push(`  ${pc.bold('Agent Sam · models')}`);
-  lines.push(`  ${pc.dim('Detected from this terminal session. Secrets are never printed.')}`);
+  lines.push(`  ${pc.dim('Credential presence is local evidence; exact hosted-model availability is provider-verified when discovery succeeds.')}`);
   lines.push('');
 
   for (const provider of status.providers) {
-    const state = provider.configured ? pc.green('configured') : pc.dim('not configured');
-    const detail = provider.configured ? 'credential available' : provider.credential;
+    const state = provider.configured ? pc.green('configured') : pc.dim(provider.credentialError ? 'blocked' : 'not configured');
+    const detail = provider.configured ? `credential available · ${provider.source || 'runtime'}` : provider.credentialError ? `${provider.credential} · ${provider.credentialError}` : provider.credential;
     lines.push(`  ${statusMark(provider.configured)}  ${pc.cyan(provider.label.padEnd(10))} ${state.padEnd(20)} ${pc.dim(detail)}`);
   }
 
+  const exact = status.availableModels || [];
+  if (exact.length) {
+    lines.push('');
+    lines.push(`  ${pc.dim('provider-verified selectable models')}`);
+    for (const model of exact) lines.push(`    ${pc.green('•')} ${model.provider_model_id}`);
+  } else if (status.discovery?.openai?.attempted) {
+    lines.push('');
+    lines.push(`  ${pc.dim(`OpenAI discovery ${status.discovery.openai.ok ? 'completed; no catalog models matched' : `failed: ${status.discovery.openai.error || 'unknown error'}`}`)}`);
+  }
+
   const local = status.local;
   const localState = local.online ? pc.green('online') : pc.dim('offline');
   lines.push(`  ${statusMark(local.online)}  ${pc.cyan('Ollama'.padEnd(10))} ${localState.padEnd(20)} ${pc.dim('local only')}`);
-
   if (local.online) {
     const names = local.models.map((row) => row.name).filter(Boolean);
     lines.push('');
     lines.push(`  ${pc.dim('local models')}`);
-    if (names.length) {
-      for (const name of names) lines.push(`    ${pc.green('•')} ${name}`);
-    } else {
-      lines.push(`    ${pc.dim('no models reported')}`);
-    }
+    if (names.length) for (const name of names) lines.push(`    ${pc.green('•')} ${name}`);
+    else lines.push(`    ${pc.dim('no models reported')}`);
     lines.push('');
     lines.push(`  ${pc.dim('chat default')}   ${local.chatModel}`);
     lines.push(`  ${pc.dim('embed default')}  ${local.embedModel}`);
   }
-
   lines.push('');
-  lines.push(`  ${pc.dim('Provider model catalogs and model selection belong to the connected host/runtime;')}`);
-  lines.push(`  ${pc.dim('this command only reports what this local CLI can prove is configured or available.')}`);
+  lines.push(`  ${pc.dim('Use /model inside Agent Sam to choose an exact verified model, reasoning effort, and processing tier.')}`);
   lines.push('');
   return lines.join('\n');
 }
 
 export async function runModels(argv = [], options = {}) {
   if (argv.some((arg) => arg === '--help' || arg === '-h')) {
-    const text = 'agentsam models [--json]\n\nShow model providers configured in this terminal session plus models reported by local Ollama.\n';
+    const text = 'agentsam models [--json] [--no-discover]\n\nShow configured providers, provider-verified known models when available, and local Ollama inventory.\n';
     (options.write || process.stdout.write.bind(process.stdout))(text);
     return;
   }
-  const unknown = argv.filter((arg) => arg !== '--json');
+  const allowed = new Set(['--json', '--no-discover']);
+  const unknown = argv.filter((arg) => !allowed.has(arg));
   if (unknown.length) throw new Error(`unknown models option: ${unknown[0]}`);
 
-  const status = await collectModelsStatus(options);
+  const status = await collectModelsStatus({ ...options, discoverRemote: !argv.includes('--no-discover') });
   const write = options.write || ((text) => process.stdout.write(text));
-  if (argv.includes('--json')) {
-    writeLine(write, JSON.stringify(status, null, 2));
-  } else {
-    write(renderModelsStatus(status));
-  }
+  if (argv.includes('--json')) writeLine(write, JSON.stringify(status, null, 2));
+  else write(renderModelsStatus(status));
   return status;
 }