@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.1

package/src/commands/merkle-persist.js

@@ -1,10 +1,12 @@
 import path from 'node:path';
-import { readSnapshot } from '../lib/merkle/snapshot.js';
+import { readSnapshot } from '../../packages/agentsam-repository/src/merkle/snapshot.js';
+import { readAccountSession } from '../lib/account-session.js';
+import { getRepositoryId, portableRepositoryIdFromGit, tryReadProjectConfig } from '../lib/project-config.js';
 import {
   buildMerklePersistencePlan,
   persistMerkleSnapshotCloudflare,
   resolveWranglerMerklePersistence,
-} from '../lib/merkle/cloudflare-persistence.js';
+} from '../../packages/agentsam-repository/src/merkle/cloudflare-persistence.js';
 
 function value(args, index, flag) {
   const next = args[index + 1];
@@ -17,8 +19,6 @@ export function printMerklePersistHelp() {
   agentsam merkle persist <snapshot.json> — publish a saved Merkle snapshot through host bindings
 
   --wrangler-config <file>    Worker config containing WEBSITE_ASSETS and optionally DB
-  --owner-user-id <id>        Snapshot owner authority (or AGENTSAM_OWNER_USER_ID)
-  --repo-id <id>              Canonical repo id; inferred for GitHub/GitLab/Bitbucket when possible
   --capture-kind <kind>       deploy|manual|agent|index (default manual)
   --connection-id <id>        Execution provenance for non-deploy captures
   --runtime-lease-id <id>     Alternative execution provenance for non-deploy captures
@@ -35,9 +35,11 @@ export function printMerklePersistHelp() {
   --dry-run                   Resolve bindings and emit the exact storage/index plan without writes
   --json                      Machine-readable output
 
-  The SDK never infers owner identity. Hosts should pass authenticated owner_user_id.
-  Physical bucket/database names come from Wrangler bindings, so customer installs keep
-  WEBSITE_ASSETS/DB while selecting their own storage resources.
+  CLI ownership comes from the authenticated AgentSam session, while repository identity is
+  derived from Git/provider identity (with the committed project manifest as local fallback).
+  Programmatic hosts pass account_id + repository_id directly to the persistence plan. Physical
+  bucket/database names come from Wrangler bindings, so customer installs keep WEBSITE_ASSETS/DB
+  while selecting their own storage resources.
 `);
 }
 
@@ -55,7 +57,7 @@ function parse(args) {
     if (arg === '--dry-run') { opts.dryRun = true; continue; }
     if (arg === '--r2-only') { opts.r2Only = true; continue; }
     const map = {
-      '--wrangler-config': 'wranglerConfig', '--owner-user-id': 'ownerUserId', '--repo-id': 'repoId',
+      '--wrangler-config': 'wranglerConfig',
       '--capture-kind': 'captureKind', '--connection-id': 'connectionId', '--runtime-lease-id': 'runtimeLeaseId',
       '--deployment-id': 'deploymentId', '--worker-version': 'workerVersionId', '--reference-label': 'referenceLabel',
       '--source': 'source', '--prefix': 'storagePrefix', '--r2-binding': 'r2Binding', '--d1-binding': 'd1Binding',
@@ -65,19 +67,36 @@ function parse(args) {
     throw new Error(`Unknown merkle persist option: ${arg}`);
   }
   if (!opts.snapshotPath) throw new Error('snapshot_file_required');
-  opts.ownerUserId ||= process.env.AGENTSAM_OWNER_USER_ID || '';
   opts.wranglerConfig ||= process.env.AGENTSAM_WRANGLER_CONFIG || '';
   opts.connectionId ||= process.env.AGENTSAM_CONNECTION_ID || '';
   opts.runtimeLeaseId ||= process.env.AGENTSAM_RUNTIME_LEASE_ID || '';
   return opts;
 }
 
+export function resolveMerklePersistenceIdentity(root, options = {}) {
+  const session = options.session ?? readAccountSession(options.sessionOptions || {});
+  const accountId = String(session?.account_id || '').trim();
+  if (!accountId) throw new Error('agentsam_login_required_for_merkle_persistence');
+
+  const projectConfig = options.projectConfig ?? tryReadProjectConfig(root);
+  const gitRepositoryId = portableRepositoryIdFromGit(root);
+  const repositoryId = gitRepositoryId || getRepositoryId(projectConfig);
+  if (!repositoryId) throw new Error('repository_identity_unresolved');
+
+  return {
+    accountId,
+    repositoryId,
+    repositoryIdentitySource: gitRepositoryId ? 'git' : 'project_manifest',
+  };
+}
+
 export async function runMerklePersist(args = []) {
   const opts = parse(args);
   if (opts.help) { printMerklePersistHelp(); return null; }
   const snapshotPath = path.resolve(opts.snapshotPath);
   const snapshot = await readSnapshot(snapshotPath);
   const root = path.resolve(opts.root || snapshot.rootPath || process.cwd());
+  const identity = resolveMerklePersistenceIdentity(root);
   const wrangler = resolveWranglerMerklePersistence({
     configPath: opts.wranglerConfig,
     environment: opts.environment || null,
@@ -88,8 +107,8 @@ export async function runMerklePersist(args = []) {
   const plan = buildMerklePersistencePlan({
     snapshot,
     root,
-    ownerUserId: opts.ownerUserId,
-    repoId: opts.repoId,
+    accountId: identity.accountId,
+    repositoryId: identity.repositoryId,
     source: opts.source,
     captureKind: opts.captureKind,
     connectionId: opts.connectionId,

package/src/commands/merkle.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { buildMerkleTree, saveSnapshot, readSnapshot, diffTrees, normalizePolicy } from '../lib/merkle/index.js';
+import { buildMerkleTree, saveSnapshot, readSnapshot, diffTrees, normalizePolicy } from '../../packages/agentsam-repository/src/merkle/index.js';
 import { renderSummary, safeText } from '../ui/merkle/render.js';
 import { runMerkleExplorer } from '../ui/merkle/explorer.js';
 import { runMerklePersist } from './merkle-persist.js';

package/src/commands/models.js

@@ -1,33 +1,109 @@
 import pc from 'picocolors';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
+import { listModelCatalog } from '../models/index.js';
+import { discoverProviderModels } from '../models/discovery.js';
+import { resolveProviderCredential } from '../lib/provider-credentials.js';
 
-const API_PROVIDERS = Object.freeze([
+export const API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', credential: 'OPENAI_API_KEY' },
+  { id: 'anthropic', label: 'Anthropic', credential: 'ANTHROPIC_API_KEY' },
   { id: 'gemini', label: 'Gemini', credential: 'GEMINI_API_KEY' },
-  { id: 'grok', label: 'Grok', credential: 'XAI_API_KEY' },
+  { id: 'grok', label: 'Grok / xAI', credential: 'XAI_API_KEY' },
+  { id: 'cloudflare', label: 'Cloudflare', credential: 'CLOUDFLARE_API_TOKEN' },
 ]);
 
-function clean(value) {
-  return value == null ? '' : String(value).trim();
+function clean(value) { return value == null ? '' : String(value).trim(); }
+
+function emptyDiscovery() {
+  return { attempted: false, ok: false, models: [], error: null };
 }
 
-function configured(value) {
-  return Boolean(clean(value));
+function providerSummary(result = {}) {
+  return {
+    attempted: result.attempted === true,
+    ok: result.ok === true,
+    error: result.error || null,
+    returnedModelCount: Array.isArray(result.models) ? result.models.length : 0,
+  };
+}
+
+function mergeStaticFallbacks(discovered = []) {
+  const byKey = new Map(discovered.map((row) => [row.model_key, row]));
+  const out = [...discovered];
+  for (const record of listModelCatalog()) {
+    if (byKey.has(record.model_key)) continue;
+    out.push({
+      model_key: record.model_key,
+      provider: record.provider,
+      provider_model_id: record.provider_model_id,
+      label: record.label,
+      availability: 'unverified',
+      availability_source: 'sdk_reference',
+      context_window: record.context_window,
+      context_window_source: 'sdk_reference',
+      max_output_tokens: record.max_output_tokens,
+      max_output_tokens_source: 'sdk_reference',
+      reasoning_efforts: [...record.reasoning_efforts],
+      service_tiers: [...record.service_tiers],
+      capabilities: { ...record.capabilities },
+      pricing: record.pricing || null,
+      context_policy: record.context_policy || null,
+      batch: record.batch || null,
+      source: record.source || null,
+    });
+  }
+  return out;
 }
 
 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 }),
+    ]),
+  );
 
-  return {
-    schemaVersion: 'agentsam-model-inventory-v1',
-    providers: API_PROVIDERS.map((provider) => ({
+  const providers = API_PROVIDERS.map((provider) => {
+    const credential = credentials.get(provider.id);
+    return {
       ...provider,
-      configured: configured(env[provider.credential]),
-      source: 'environment',
-    })),
+      configured: credential?.configured === true,
+      source: credential?.source || null,
+      credentialError: credential?.error || null,
+    };
+  });
+
+  const shouldDiscover = options.discoverRemote !== false;
+  const discovery = {};
+  const providerModels = {};
+
+  await Promise.all(API_PROVIDERS.map(async (provider) => {
+    const credential = credentials.get(provider.id);
+    const result = shouldDiscover && credential?.configured
+      ? await discoverProviderModels(provider.id, credential, { fetchImpl: providerFetchImpl })
+      : emptyDiscovery();
+    discovery[provider.id] = providerSummary(result);
+    providerModels[provider.id] = result.models || [];
+  }));
+
+  const discovered = Object.values(providerModels).flat();
+  const exactAvailable = discovered.filter((row) => row.availability === 'available');
+  const catalogModels = mergeStaticFallbacks(discovered);
+
+  return {
+    schemaVersion: 'agentsam-model-inventory-v3',
+    generatedAt: new Date().toISOString(),
+    authority: 'per_credential_provider_discovery',
+    providers,
+    discovery,
+    providerModels,
+    catalogModels,
+    availableModels: exactAvailable,
     local: {
       provider: 'ollama',
       configured: ollama.online,
@@ -41,67 +117,94 @@ 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`); }
+function contextLabel(model) {
+  const value = Number(model?.context_window);
+  if (!Number.isFinite(value) || value <= 0) return 'ctx unknown';
+  return `ctx ${Math.round(value / 1000).toLocaleString('en-US')}k`;
 }
 
 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('Availability is verified with this machine\'s own provider credentials. Limits are provider-derived when exposed; otherwise marked unknown/reference.')}`);
   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;
-    lines.push(`  ${statusMark(provider.configured)}  ${pc.cyan(provider.label.padEnd(10))} ${state.padEnd(20)} ${pc.dim(detail)}`);
+    const state = provider.configured
+      ? pc.green('configured')
+      : pc.dim(provider.credentialError ? 'blocked' : 'not configured');
+    const discovery = status.discovery?.[provider.id];
+    const detail = provider.configured
+      ? discovery?.attempted
+        ? discovery.ok
+          ? `${discovery.returnedModelCount} account-visible models`
+          : `discovery failed · ${discovery.error || 'unknown error'}`
+        : `credential available · ${provider.source || 'runtime'}`
+      : provider.credentialError
+        ? `${provider.credential} · ${provider.credentialError}`
+        : provider.credential;
+    lines.push(`  ${statusMark(provider.configured)}  ${pc.cyan(provider.label.padEnd(12))} ${state.padEnd(20)} ${pc.dim(detail)}`);
+  }
+
+  for (const provider of API_PROVIDERS) {
+    const models = status.providerModels?.[provider.id] || [];
+    if (!models.length) continue;
+    lines.push('');
+    lines.push(`  ${pc.dim(`${provider.label} · provider-verified for this credential`)}`);
+    const visible = models.slice(0, 30);
+    for (const model of visible) {
+      const source = model.context_window_source === 'provider_api'
+        ? contextLabel(model)
+        : model.context_window_source === 'sdk_reference'
+          ? `${contextLabel(model)} · reference`
+          : 'ctx unknown';
+      lines.push(`    ${pc.green('•')} ${model.provider_model_id} ${pc.dim('· ' + source)}`);
+    }
+    if (models.length > visible.length) lines.push(`    ${pc.dim(`… ${models.length - visible.length} more`)}`);
   }
 
   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')}`);
-
+  lines.push('');
+  lines.push(`  ${statusMark(local.online)}  ${pc.cyan('Ollama'.padEnd(12))} ${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')}`);
-    }
-    lines.push('');
-    lines.push(`  ${pc.dim('chat default')}   ${local.chatModel}`);
-    lines.push(`  ${pc.dim('embed default')}  ${local.embedModel}`);
+    for (const name of names.slice(0, 30)) lines.push(`    ${pc.green('•')} ${name}`);
+    if (names.length > 30) lines.push(`    ${pc.dim(`… ${names.length - 30} more`)}`);
   }
 
   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. The picker is built from the models visible to your own connected provider credentials.')}`);
   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]',
+      '',
+      'Probe the provider accounts configured on this machine and list the models visible to those exact credentials.',
+      'Context/output limits are taken from provider metadata when available; otherwise Agent Sam reports unknown or a clearly-labeled SDK reference.',
+      '',
+    ].join('\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;
 }

package/src/commands/ollama.js

@@ -148,6 +148,32 @@ function hasModel(models, desired) {
   return models.some((row) => normalizeModelName(row.name || row.model) === want);
 }
 
+export async function probeOllamaModel(model, config, fetchImpl = fetch) {
+  const endpoint = `${config.baseUrl}/api/show`;
+  try {
+    const response = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!response.ok) return { ok: false, model, context_window: null, error: `HTTP ${response.status}` };
+    const body = await response.json();
+    const info = body?.model_info && typeof body.model_info === 'object' ? body.model_info : {};
+    const contextEntry = Object.entries(info).find(([key, value]) => key.endsWith('.context_length') && Number(value) > 0);
+    return {
+      ok: true,
+      model,
+      context_window: contextEntry ? Math.floor(Number(contextEntry[1])) : null,
+      context_window_source: contextEntry ? 'local_runtime' : 'unknown',
+      capabilities: Array.isArray(body?.capabilities) ? body.capabilities : [],
+      details: body?.details || null,
+    };
+  } catch (error) {
+    return { ok: false, model, context_window: null, error: error?.message || String(error) };
+  }
+}
+
 export async function probeOllama(config, fetchImpl = fetch) {
   const endpoint = `${config.baseUrl}/api/tags`;
   try {

package/src/commands/preferences.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { cancel, intro, isCancel, outro, select, text } from '@clack/prompts';
+import { cancel, confirm, intro, isCancel, outro, select, text } from '@clack/prompts';
 import { collectModelsStatus } from './models.js';
+import { getModelRecord } from '../models/index.js';
 import { detectCliProject, readCliPreferences, writeCliPreferences } from '../lib/cli-preferences.js';
+import { readAccountSession } from '../lib/account-session.js';
 
 function stopIfCancelled(value) {
   if (!isCancel(value)) return value;
@@ -18,85 +20,152 @@ function commandExists(command) {
   return spawnSync(probe[0], probe[1], { stdio: 'ignore' }).status === 0;
 }
 
+export function runtimeOptions({ accountConnected = false } = {}) {
+  const rows = [{ value: 'local', label: 'Local machine', hint: 'standalone · real shell + filesystem' }];
+  if (accountConnected) {
+    rows.push(
+      { value: 'remote', label: 'Remote', hint: 'IAM-connected enrolled runtime' },
+      { value: 'sandbox', label: 'Sandbox', hint: 'IAM-connected isolated runtime' },
+    );
+  }
+  return rows;
+}
+
 export function availableShells(env = process.env) {
   const values = [];
   const detected = path.basename(env.SHELL || env.ComSpec || '').trim();
   if (detected) values.push(detected);
-  for (const shell of ['zsh', 'bash', 'fish', 'pwsh']) {
-    if (!values.includes(shell) && commandExists(shell)) values.push(shell);
-  }
+  for (const shell of ['zsh', 'bash', 'fish', 'pwsh']) if (!values.includes(shell) && commandExists(shell)) values.push(shell);
   return values.length ? values : ['shell'];
 }
 
-function modelOptions(status) {
-  const options = [{ value: 'auto', label: 'Automatic', hint: 'connected host/runtime decides' }];
-  if (status.local?.online) {
-    for (const row of status.local.models || []) {
-      if (row?.name) options.push({ value: `ollama:${row.name}`, label: `Ollama · ${row.name}`, hint: 'local' });
-    }
+export function modelOptions(status) {
+  const options = [{ value: 'auto', label: 'Automatic', hint: 'runtime chooses from this credential\'s verified inventory', model: null }];
+  for (const model of status.availableModels || []) {
+    const context = Number(model.context_window) > 0 ? ` · ctx ${Math.round(Number(model.context_window) / 1000)}k` : ' · ctx unknown';
+    options.push({
+      value: model.model_key,
+      label: `${model.provider} · ${model.label}`,
+      hint: `${model.provider_model_id}${context} · provider verified`,
+      model,
+    });
   }
-  for (const provider of status.providers || []) {
-    if (provider.configured) options.push({ value: `${provider.id}:auto`, label: provider.label, hint: 'provider configured' });
+  if (status.local?.online) {
+    for (const row of status.local.models || []) if (row?.name) options.push({
+      value: `ollama:${row.name}`,
+      label: `Ollama · ${row.name}`,
+      hint: 'local',
+      model: {
+        model_key: `ollama:${row.name}`, provider: 'ollama', provider_model_id: row.name, label: row.name,
+        availability: 'available', availability_source: 'local_runtime', context_window: null, context_window_source: 'unknown',
+        max_output_tokens: null, max_output_tokens_source: 'unknown', reasoning_efforts: ['auto'], service_tiers: ['default'], capabilities: { chat: true },
+      },
+    });
   }
   return options;
 }
 
-export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false } = {}) {
-  let identity = detectCliProject(cwd);
-  const existing = readCliPreferences(identity.root) || {};
-  intro(firstRun ? 'Welcome to Agent Sam' : 'Agent Sam settings');
-
-  const projectChoice = stopIfCancelled(await select({
-    message: 'Where should Agent Sam work?',
-    initialValue: 'current',
-    options: [
-      { value: 'current', label: `This project · ${identity.project}`, hint: identity.root },
-      { value: 'other', label: 'Choose another folder' },
-    ],
-  }));
-
-  if (projectChoice === 'other') {
-    const folder = stopIfCancelled(await text({
-      message: 'Project folder',
-      placeholder: identity.root,
-      defaultValue: identity.root,
-      validate(value) {
-        const resolved = path.resolve(String(value || ''));
-        if (!fs.existsSync(resolved)) return 'Folder does not exist';
-        if (!fs.statSync(resolved).isDirectory()) return 'Path is not a directory';
-      },
-    }));
-    identity = detectCliProject(path.resolve(String(folder)));
-  }
+function resolvedModel(modelPreference, modelSnapshot) {
+  if (modelSnapshot?.model_key === modelPreference) return modelSnapshot;
+  return getModelRecord(modelPreference);
+}
 
-  const runtime = stopIfCancelled(await select({
-    message: 'Runtime',
-    initialValue: existing.runtime || 'local',
-    options: [
-      { value: 'local', label: 'Local machine', hint: 'real shell + filesystem' },
-      { value: 'remote', label: 'Remote', hint: 'connected remote runtime' },
-      { value: 'sandbox', label: 'Sandbox', hint: 'isolated disposable runtime' },
-    ],
+function reasoningOptions(modelPreference, modelSnapshot) {
+  const record = resolvedModel(modelPreference, modelSnapshot);
+  if (!record) return [{ value: 'auto', label: 'Automatic', hint: 'runtime/provider default' }];
+  return record.reasoning_efforts.map((value) => ({
+    value,
+    label: value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1),
+    hint: value === 'low' ? 'lighter reasoning' : value === 'max' ? 'highest supported reasoning depth' : undefined,
   }));
+}
 
-  const shells = availableShells();
-  const terminal = stopIfCancelled(await select({
-    message: 'Terminal',
-    initialValue: existing.terminal && shells.includes(existing.terminal) ? existing.terminal : shells[0],
-    options: shells.map((shell) => ({ value: shell, label: shell, hint: shell === shells[0] ? 'detected/default' : undefined })),
-  }));
+function serviceTierOptions(modelPreference, modelSnapshot) {
+  const record = resolvedModel(modelPreference, modelSnapshot);
+  if (!record) return [{ value: 'default', label: 'Standard', hint: 'default provider processing' }];
+  return record.service_tiers.map((value) => {
+    if (value === 'fast') return { value, label: 'Fast', hint: 'lower latency · 2× applicable token rates for Astra' };
+    if (value === 'flex') return { value, label: 'Flex', hint: 'slower / capacity-sensitive · 50% of Standard for Astra' };
+    return { value, label: 'Standard', hint: 'standard pricing and latency' };
+  });
+}
 
-  let status = { providers: [], local: { online: false, models: [] } };
-  try { status = await collectModelsStatus(); } catch { /* inventory is best-effort */ }
+async function promptModelPreferences(identity, existing, options = {}) {
+  let status = { providers: [], availableModels: [], local: { online: false, models: [] } };
+  try { status = await collectModelsStatus(options.modelStatusOptions || {}); } catch { /* inventory remains best-effort */ }
   const models = modelOptions(status);
   const initialModel = models.some((row) => row.value === existing.modelPreference) ? existing.modelPreference : 'auto';
-  const modelPreference = stopIfCancelled(await select({
-    message: 'Model preference',
-    initialValue: initialModel,
-    options: models,
-  }));
+  const modelPreference = stopIfCancelled(await select({ message: 'Model', initialValue: initialModel, options: models.map(({ model, ...row }) => row) }));
+  const selected = models.find((row) => row.value === modelPreference)?.model || null;
+  const modelSnapshot = selected || (existing.modelSnapshot?.model_key === modelPreference ? existing.modelSnapshot : null);
+
+  const reasoning = reasoningOptions(modelPreference, modelSnapshot);
+  const initialReasoning = reasoning.some((row) => row.value === existing.reasoningEffort) ? existing.reasoningEffort : reasoning[0].value;
+  const reasoningEffort = stopIfCancelled(await select({ message: 'Reasoning level', initialValue: initialReasoning, options: reasoning }));
+
+  const tiers = serviceTierOptions(modelPreference, modelSnapshot);
+  const initialTier = tiers.some((row) => row.value === existing.serviceTier) ? existing.serviceTier : tiers[0].value;
+  const serviceTier = stopIfCancelled(await select({ message: 'Processing', initialValue: initialTier, options: tiers }));
+
+  return { modelPreference, modelSnapshot, reasoningEffort, serviceTier };
+}
+
+export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false, section = 'all', modelStatusOptions, home, env = process.env } = {}) {
+  let identity = detectCliProject(cwd);
+  const existing = readCliPreferences(identity.root) || {};
+  intro(firstRun ? `You are in ${identity.root}` : section === 'model' ? 'Agent Sam model' : 'Agent Sam settings');
+
+  let trustedDirectory = existing.trustedDirectory === true;
+  if (firstRun && !trustedDirectory) {
+    trustedDirectory = stopIfCancelled(await confirm({
+      message: 'Do you trust the contents of this directory? Project-local instructions, hooks, and execution policy may load.',
+      initialValue: false,
+    }));
+    if (!trustedDirectory) {
+      cancel('Directory not trusted. Agent Sam did not load project-local configuration.');
+      const error = new Error('directory_not_trusted');
+      error.code = 'AGENTSAM_SETUP_CANCELLED';
+      throw error;
+    }
+  }
+
+  const accountConnected = Boolean(readAccountSession({ home, env })?.account_id);
+  const runtimes = runtimeOptions({ accountConnected });
+  let runtime = runtimes.some((row) => row.value === existing.runtime) ? existing.runtime : 'local';
+  let terminal = existing.terminal || availableShells(env)[0];
+  if (!firstRun && section === 'all') {
+    const projectChoice = stopIfCancelled(await select({
+      message: 'Where should Agent Sam work?',
+      initialValue: 'current',
+      options: [
+        { value: 'current', label: `This project · ${identity.project}`, hint: identity.root },
+        { value: 'other', label: 'Choose another folder' },
+      ],
+    }));
+    if (projectChoice === 'other') {
+      const folder = stopIfCancelled(await text({
+        message: 'Project folder', placeholder: identity.root, defaultValue: identity.root,
+        validate(value) {
+          const resolved = path.resolve(String(value || ''));
+          if (!fs.existsSync(resolved)) return 'Folder does not exist';
+          if (!fs.statSync(resolved).isDirectory()) return 'Path is not a directory';
+        },
+      }));
+      identity = detectCliProject(path.resolve(String(folder)));
+    }
+    runtime = stopIfCancelled(await select({
+      message: 'Runtime', initialValue: runtime,
+      options: runtimes,
+    }));
+    const shells = availableShells(env);
+    terminal = stopIfCancelled(await select({
+      message: 'Terminal', initialValue: terminal && shells.includes(terminal) ? terminal : shells[0],
+      options: shells.map((shell) => ({ value: shell, label: shell, hint: shell === shells[0] ? 'detected/default' : undefined })),
+    }));
+  }
 
-  const preferences = writeCliPreferences(identity.root, { runtime, terminal, modelPreference });
+  const model = await promptModelPreferences(identity, existing, { modelStatusOptions: { home, env, ...(modelStatusOptions || {}) } });
+  const preferences = writeCliPreferences(identity.root, { trustedDirectory, runtime, terminal, ...model });
   outro(`Ready · ${identity.project}`);
   return { identity, preferences };
 }