@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.1

package/src/commands/cloudflare.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { listWranglerNativeCommands, runWranglerNative, summarizeCloudflareCpuProfileFile, WRANGLER_OPERATION_FAMILIES } from '../cloudflare/index.js';
+import { renderDiagnosticError } from '../errors/index.js';
+
+function parse(argv = []) {
+  const subcommand = argv[0] || 'status';
+  const takesAction = subcommand === 'run' || subcommand === 'cpu';
+  const out = { subcommand, action: takesAction ? (argv[1] || '') : '', cwd: process.cwd(), json: false, name: '', account: '', config: '', env: '', profile: '', path: '', page: null, file: '' };
+  for (let i = takesAction ? 2 : 1; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--json') out.json = true;
+    else if (arg === '--cwd') out.cwd = argv[++i] || out.cwd;
+    else if (arg === '--name') out.name = argv[++i] || '';
+    else if (arg === '--account') out.account = argv[++i] || '';
+    else if (arg === '--config') out.config = argv[++i] || '';
+    else if (arg === '--env') out.env = argv[++i] || '';
+    else if (arg === '--profile') out.profile = argv[++i] || '';
+    else if (arg === '--path') out.path = argv[++i] || '';
+    else if (arg === '--page') out.page = Number(argv[++i] || 1);
+    else if (arg === '--file') out.file = argv[++i] || '';
+    else if (arg === '--help' || arg === '-h') out.help = true;
+    else if (out.subcommand === 'cpu' && out.action === 'analyze' && !out.file) out.file = arg;
+    else throw new Error(`unknown cloudflare option: ${arg}`);
+  }
+  return out;
+}
+
+const help = `Agent Sam · Cloudflare\n\n  agentsam cloudflare status [--cwd PATH] [--json]\n  agentsam cloudflare commands [--json]\n  agentsam cloudflare run <whoami|deployments.list|versions.list|types.check|queues.list> [options] [--json]\n  agentsam cloudflare cpu analyze <profile.cpuprofile> [--cwd PATH] [--json]\n\nSafe native runner is read-only. Deploy, rollback, secret reads, D1 mutation, R2 writes, and long-running tail/dev sessions remain explicit operator actions.\n`;
+
+export async function runCloudflare(argv = [], options = {}) {
+  const args = parse(argv);
+  if (options.cwd && !argv.includes('--cwd')) args.cwd = path.resolve(options.cwd);
+  const write = options.write || ((value) => process.stdout.write(value));
+  if (args.help) { write(help); return null; }
+  try {
+    let result;
+    if (args.subcommand === 'status') {
+      result = await runWranglerNative('whoami', args, options);
+    } else if (args.subcommand === 'commands') {
+      result = { schema_version: 1, native: listWranglerNativeCommands(), families: WRANGLER_OPERATION_FAMILIES };
+    } else if (args.subcommand === 'run') {
+      if (!args.action) throw new Error('cloudflare native command id required');
+      result = await runWranglerNative(args.action, args, options);
+    } else if (args.subcommand === 'cpu' && args.action === 'analyze') {
+      result = summarizeCloudflareCpuProfileFile({ cwd: path.resolve(args.cwd), file: args.file });
+    } else {
+      write(help);
+      return null;
+    }
+    write(args.json ? `${JSON.stringify(result)}\n` : `${JSON.stringify(result, null, 2)}\n`);
+    return result;
+  } catch (error) {
+    if (args.json) write(`${JSON.stringify({ ok: false, error: error?.diagnostic || { code: error?.code || 'cloudflare_operation_failed', message: error?.message || String(error) } })}\n`);
+    else write(`${renderDiagnosticError(error)}\n`);
+    error.reported = true;
+    throw error;
+  }
+}

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,129 @@
+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 = preferences.modelSnapshot?.model_key === preferences.modelPreference
+    ? preferences.modelSnapshot
+    : 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 windowTokens = Number(model.context_window);
+  if (!(Number.isFinite(windowTokens) && windowTokens > 0)) {
+    return Object.freeze({
+      model: model.provider_model_id,
+      model_key: model.model_key,
+      resolved: false,
+      reason: 'This provider verified the model but did not expose a trustworthy context-window limit. Agent Sam will show ctx unknown rather than guess.',
+      reasoning_effort: preferences.reasoningEffort || 'auto',
+      service_tier: preferences.serviceTier || 'default',
+      active_input_tokens: Number.isFinite(options.activeInputTokens) ? Math.floor(options.activeInputTokens) : null,
+    });
+  }
+
+  const policy = model.context_policy || {};
+  const budget = createContextBudget({
+    windowTokens,
+    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/context.js

@@ -1,4 +1,4 @@
-import { tryResolveGitContext } from '../lib/git-context.js';
+import { tryResolveGitContext } from '../../packages/agentsam-repository/src/git-context.js';
 import { resolveAgentSamBaseUrl, resolveBridgeKey } from '../lib/bridge-client.js';
 import { loadProjectRules } from '../lib/project-rules.js';
 

package/src/commands/db.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { initializeLocalSqlite, inspectLocalSqlite } from '../local/sqlite.js';
+import { createLocalSqliteDatabase, initializeLocalSqlite, inspectLocalSqlite } from '../local/sqlite.js';
+import { applyRuntimeMigrations } from '../local/migrations.js';
 import { getLocalDatabasePath, getLocalSchemaPath, readProjectConfig } from '../lib/project-config.js';
 
 function findProjectRoot(startDir) {
@@ -23,7 +24,7 @@ function resolveDb(root, config) {
 
 export async function runDb(argv = [], opts = {}) {
   const sub = argv[0] || 'status';
-  if (!['init', 'status'].includes(sub)) {
+  if (!['init', 'migrate', 'status'].includes(sub)) {
     throw new Error(`unknown db command: ${sub}`);
   }
 
@@ -36,10 +37,26 @@ export async function runDb(argv = [], opts = {}) {
     console.log(`\n  Agent Sam local DB\n`);
     console.log(`  ✓ SQLite      ${result.dbPath}`);
     console.log(`  ✓ Tables      ${result.tables.length}`);
-    console.log(`  ✓ Schema      ${paths.schemaPath}\n`);
+    console.log(`  ✓ Schema      ${paths.schemaPath}`);
+    console.log('  ✓ Migrations  current\n');
     return result;
   }
 
+  if (sub === 'migrate') {
+    if (!fs.existsSync(paths.dbPath)) throw new Error('Local DB is not initialized — run `agentsam db init` first.');
+    const db = await createLocalSqliteDatabase(paths.dbPath);
+    try {
+      const result = await applyRuntimeMigrations(db);
+      console.log(`\n  Agent Sam local DB migrations\n`);
+      console.log(`  applied       ${result.applied}`);
+      console.log(`  known         ${result.total}`);
+      console.log(`  path          ${paths.dbPath}\n`);
+      return result;
+    } finally {
+      db.close();
+    }
+  }
+
   const result = await inspectLocalSqlite(paths.dbPath);
   console.log(`\n  Agent Sam local DB\n`);
   if (!result.exists) {

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/env.js

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { describeProviderCredential, ensureProviderEnvProfile, providerCredentialSpec } from '../lib/provider-credentials.js';
+
+const PROVIDERS = Object.freeze(['openai', 'anthropic', 'gemini', 'grok', 'cloudflare']);
+
+function writeLine(write, value = '') { write(`${value}\n`); }
+
+function detectCloudflareAccounts(options = {}) {
+  const env = options.env || process.env;
+  const explicit = String(options.accountId || env.ACCOUNT_ID || env.CLOUDFLARE_ACCOUNT_ID || '').trim();
+  if (explicit) return { accounts: [{ id: explicit, name: null }], source: 'environment' };
+  const spawn = options.spawnSyncImpl || spawnSync;
+  const result = spawn('npx', ['--no-install', 'wrangler', 'whoami', '--json'], { cwd: options.cwd || process.cwd(), env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (result?.status !== 0) return { accounts: [], source: 'wrangler', error: String(result?.stderr || '').trim() || `wrangler exited ${result?.status ?? 'unknown'}` };
+  try {
+    const parsed = JSON.parse(String(result.stdout || '{}'));
+    const accounts = (Array.isArray(parsed?.accounts) ? parsed.accounts : []).map((row) => ({
+      id: String(row?.id || row?.account_id || '').trim(),
+      name: String(row?.name || row?.account_name || '').trim() || null,
+    })).filter((row) => row.id);
+    return { accounts, source: 'wrangler', error: null };
+  } catch (error) {
+    return { accounts: [], source: 'wrangler', error: `invalid wrangler JSON: ${error?.message || error}` };
+  }
+}
+
+function cloudflareGuidance(write) {
+  writeLine(write, '');
+  writeLine(write, '  Cloudflare token guidance');
+  writeLine(write, '  models only       Workers AI Read');
+  writeLine(write, '  run Workers AI    Workers AI Read + Edit');
+  writeLine(write, '  deploy Workers    Workers Editor for existing Workers; Admin only when create/delete is required');
+  writeLine(write, '  routes/domains    add Workers Routes Write only when AgentSam must change them');
+  writeLine(write, '  D1 / R2 / KV      add direct product permissions only when AgentSam must read/write those resources directly');
+}
+
+export async function runEnv(argv = [], options = {}) {
+  const write = options.write || ((text) => process.stdout.write(text));
+  const [command = 'status', providerArg] = argv;
+  let accountId = '';
+  for (let i = 2; i < argv.length; i += 1) {
+    if (argv[i] === '--account-id') accountId = String(argv[++i] || '').trim();
+    else throw new Error(`unexpected env argument: ${argv[i]}`);
+  }
+  if (command === '--help' || command === '-h' || command === 'help') {
+    writeLine(write, 'agentsam env init <openai|anthropic|gemini|grok|cloudflare> [--account-id <id>]');
+    writeLine(write, 'agentsam env status [provider]');
+    return;
+  }
+  if (command === 'init') {
+    const provider = String(providerArg || '').trim().toLowerCase();
+    if (!PROVIDERS.includes(provider)) throw new Error(`env init requires one of: ${PROVIDERS.join(', ')}`);
+    let cloudflareAccounts = null;
+    if (provider === 'cloudflare') {
+      if (accountId && !/^[a-f0-9]{32}$/i.test(accountId)) throw new Error('Cloudflare --account-id must be a 32-character hexadecimal account ID');
+      cloudflareAccounts = detectCloudflareAccounts({ ...options, accountId });
+      if (!accountId && cloudflareAccounts.accounts.length === 1) accountId = cloudflareAccounts.accounts[0].id;
+    }
+    const result = ensureProviderEnvProfile(provider, { ...options, accountId });
+    writeLine(write, '');
+    writeLine(write, `  AgentSam · ${provider} environment`);
+    writeLine(write, `  profile  ${result.file}${result.created ? ' · created' : ' · existing'}`);
+    writeLine(write, `  loader   ${result.loader}`);
+    writeLine(write, '');
+    writeLine(write, '  Add the credential to the profile, then load it into this shell:');
+    writeLine(write, `    ${result.source_command}`);
+    if (provider === 'cloudflare') {
+      if (accountId) writeLine(write, `  account  detected/configured (${cloudflareAccounts?.source || 'explicit'})`);
+      else if ((cloudflareAccounts?.accounts || []).length > 1) writeLine(write, `  account  ${cloudflareAccounts.accounts.length} Wrangler accounts found · rerun with --account-id <id>`);
+      else writeLine(write, '  account  not detected · set ACCOUNT_ID in the profile or rerun with --account-id <id>');
+      cloudflareGuidance(write);
+    }
+    writeLine(write, '');
+    return result;
+  }
+  if (command === 'status') {
+    const providers = providerArg ? [String(providerArg).trim().toLowerCase()] : PROVIDERS;
+    for (const provider of providers) if (!providerCredentialSpec(provider)) throw new Error(`unsupported_provider:${provider}`);
+    writeLine(write, '');
+    writeLine(write, '  AgentSam · provider environments');
+    for (const provider of providers) {
+      const row = describeProviderCredential(provider, options);
+      const extra = row.account_id ? ` · account ${row.account_id}` : '';
+      writeLine(write, `  ${provider.padEnd(12)} ${row.configured ? 'configured' : row.error ? `blocked (${row.error})` : 'not configured'}${extra}`);
+    }
+    writeLine(write, '');
+    return;
+  }
+  throw new Error(`unknown env command: ${command}`);
+}

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/knowledge.js

@@ -7,13 +7,13 @@ import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import pkg from '../../package.json' with { type: 'json' };
-import { CONFIG_PATH, repositoryRoot, initRepository, readConfig, scopeKey, cacheNamespace } from '../knowledge/config.js';
+import { CONFIG_PATH, repositoryRoot, initRepository, readConfig, defaultConfig, scopeKey, cacheNamespace } from '../knowledge/config.js';
 import { openSqliteStore } from '../knowledge/stores/sqlite.js';
 import { openPostgresStore } from '../knowledge/stores/postgres.js';
 import { planIndex, runIndex, retrieve } from '../knowledge/engine.js';
 import { createGeminiEmbedder } from '../knowledge/providers/gemini.js';
 import { compareObservations } from '../knowledge/evolution.js';
-import { ensureProjectManifest, getProjectName, getRepositoryId } from '../lib/project-config.js';
+import { ensureProjectManifest, getProjectName, getRepositoryId, portableRepositoryIdFromGit, tryReadProjectConfig } from '../lib/project-config.js';
 import { ensureProjectRules } from '../lib/project-rules.js';
 
 const execute = promisify(execFile);
@@ -25,6 +25,14 @@ async function openStore(root, config, readOnly = false) {
   return config.storage.driver === 'sqlite' ? openSqliteStore(localPath(root), { readOnly }) : openPostgresStore(process.env[config.storage.connection_env]);
 }
 function provider() { return createGeminiEmbedder({ apiKey: process.env.GEMINI_API_KEY }); }
+function resolveKnowledgeConfig(root) {
+  const filename = path.join(root, CONFIG_PATH);
+  if (fs.existsSync(filename)) return readConfig(root);
+  const project = tryReadProjectConfig(root);
+  const repositoryId = getRepositoryId(project) || portableRepositoryIdFromGit(root);
+  if (!repositoryId) throw new Error(`${CONFIG_PATH} is absent and repository identity could not be derived; run agentsam init . --yes to configure this repository.`);
+  return defaultConfig({ repositoryId });
+}
 
 export async function runRepositoryInit(argv) {
   const { values: opts, positionals } = flags(argv, { existing: { type: 'boolean' }, yes: { type: 'boolean', short: 'y' }, include: { type: 'string' }, exclude: { type: 'string' }, scope: { type: 'string' }, target: { type: 'string' }, dimensions: { type: 'string' } });
@@ -73,7 +81,7 @@ export async function runKnowledge(argv) {
   const command = positionals[0] || 'plan';
   if (opts.help) { console.log('agentsam index plan|run|status|history|show|setup-store [--cwd PATH] [--embed] [--max-inputs 100] [--max-characters 200000] [--generation ID] [--json]\nplan is read-only; run defaults to AST/text only; --embed sends selected chunks to the configured provider.'); return; }
   if (positionals.length > 1 || !['plan', 'run', 'status', 'history', 'show', 'setup-store'].includes(command)) throw new Error('Unknown index command; use agentsam index --help.');
-  const root = repositoryRoot(opts.cwd), config = readConfig(root);
+  const root = repositoryRoot(opts.cwd), config = resolveKnowledgeConfig(root);
   const store = await openStore(root, config, !['run', 'setup-store'].includes(command));
   try {
     if (command === 'setup-store') {
@@ -97,7 +105,7 @@ export async function runKnowledge(argv) {
 export async function runSearch(argv) {
   const { values: opts, positionals } = flags(argv, { semantic: { type: 'boolean' }, 'top-k': { type: 'string' }, 'token-budget': { type: 'string' }, generation: { type: 'string' } });
   if (opts.help) { console.log('agentsam search "query" [--cwd PATH] [--semantic] [--top-k 8] [--token-budget 6000] [--generation ID]'); return; }
-  const root = repositoryRoot(opts.cwd), config = readConfig(root), store = await openStore(root, config, true);
+  const root = repositoryRoot(opts.cwd), config = resolveKnowledgeConfig(root), store = await openStore(root, config, true);
   try { show(await retrieve({ store, config, text: positionals.join(' '), semantic: opts.semantic, embedder: opts.semantic ? provider() : null, topK: Number(opts['top-k'] || 8), tokenBudget: Number(opts['token-budget'] || 6000), generationId: opts.generation })); }
   finally { await store?.close(); }
 }