@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/integration/provider-env-cli.test.mjs

@@ -1,50 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import test from 'node:test';
-
-const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
-
-test('agentsam env init creates provider profile and reusable source loader', { skip: process.platform === 'win32' }, t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-cli-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = { ...process.env, HOME: home };
-  const result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh(?:\s|$)/);
-  assert.doesNotMatch(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh openai/);
-  assert.equal(fs.statSync(path.join(home, '.agentsam', 'env.d', 'openai.env')).mode & 0o777, 0o600);
-  assert.equal(fs.statSync(path.join(home, '.agentsam', 'load-agent-env.sh')).mode & 0o777, 0o700);
-});
-
-
-test('Cloudflare env init backfills exactly one Wrangler account without printing credentials', async t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-cf-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const { runEnv } = await import('../../src/commands/env.js');
-  let output = '';
-  await runEnv(['init', 'cloudflare'], {
-    home, env: { HOME: home }, write: text => { output += text; },
-    spawnSyncImpl: () => ({ status: 0, stdout: JSON.stringify({ accounts: [{ id: '11111111111111111111111111111111', name: 'Example' }] }), stderr: '' }),
-  });
-  const profile = fs.readFileSync(path.join(home, '.agentsam', 'env.d', 'cloudflare.env'), 'utf8');
-  assert.match(profile, /CLOUDFLARE_ACCOUNT_ID="11111111111111111111111111111111"/);
-  assert.match(profile, /CLOUDFLARE_API_TOKEN=""/);
-  assert.match(output, /account  detected\/configured/);
-  assert.doesNotMatch(output, /CLOUDFLARE_API_TOKEN=.*[^ ]/);
-});
-
-
-test('generated loader exports the selected provider profile into the caller shell', { skip: process.platform === 'win32' }, t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-source-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = { ...process.env, HOME: home };
-  let result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  fs.writeFileSync(path.join(home, '.agentsam', 'env.d', 'openai.env'), 'export OPENAI_API_KEY="sentinel-provider-key"\
-', { mode: 0o600 });
-  result = spawnSync('bash', ['-lc', 'source "$HOME/.agentsam/load-agent-env.sh" openai && test "$OPENAI_API_KEY" = "sentinel-provider-key"'], { env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-});

package/test/integration/provider-factory.test.mjs

@@ -1,197 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createProviderAdapter } from '../../src/providers/index.js';
-
-function response(body, status = 200, headers = {}) {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    headers: { get(name) { return headers[String(name).toLowerCase()] || null; } },
-    async json() { return body; },
-    async text() { return JSON.stringify(body); },
-  };
-}
-
-test('OpenAI-compatible adapter accepts provider-discovered records and preserves cache key', async () => {
-  let body;
-  const record = {
-    model_key: 'openai:account-model',
-    provider: 'openai',
-    provider_model_id: 'account-model',
-    context_window: 128000,
-    max_output_tokens: 8192,
-    reasoning_efforts: ['auto'],
-    service_tiers: ['default'],
-    capabilities: { responses: true },
-    pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async (url, init) => {
-      assert.match(url, /\/v1\/responses$/);
-      body = JSON.parse(init.body);
-      return response({
-        id: 'resp_1',
-        status: 'completed',
-        output_text: 'hello',
-        output: [],
-        usage: { input_tokens: 12, output_tokens: 3, input_tokens_details: { cached_tokens: 5 } },
-      });
-    },
-  });
-  const result = await provider.create({
-    model: record.provider_model_id,
-    modelRecord: record,
-    input: 'hi',
-    reasoningEffort: 'auto',
-    serviceTier: 'default',
-    promptCacheKey: 'session-1',
-  });
-  assert.equal(body.prompt_cache_key, 'session-1');
-  assert.equal(body.reasoning, undefined);
-  assert.equal(result.output_text, 'hello');
-  assert.equal(result.provider_state.previous_response_id, 'resp_1');
-  assert.equal(result.usage_snapshot.current_context.window_tokens, 128000);
-});
-
-
-
-test('xAI adapter supports native compaction without requiring a live API key in tests', async () => {
-  const requests = [];
-  const record = {
-    model_key: 'grok:grok-test',
-    provider: 'grok',
-    provider_model_id: 'grok-test',
-    context_window: 256000,
-    max_output_tokens: 8192,
-    reasoning_efforts: ['auto'],
-    service_tiers: ['default'],
-    capabilities: { responses: true, compaction: true, prompt_caching: true },
-    pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'xai-key' },
-    fetchImpl: async (url, init) => {
-      const body = JSON.parse(init.body);
-      requests.push({ url, body });
-      if (url.endsWith('/responses/compact')) {
-        return response({
-          id: 'cmp_1',
-          object: 'response.compaction',
-          output: [{ type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' }],
-          usage: { input_tokens: 1000, output_tokens: 120, input_tokens_details: { cached_tokens: 0 } },
-        });
-      }
-      return response({
-        id: 'resp_xai_1',
-        status: 'completed',
-        output_text: 'first answer',
-        output: [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'first answer' }] }],
-        usage: { input_tokens: 50, output_tokens: 10, input_tokens_details: { cached_tokens: 20 } },
-      });
-    },
-  });
-
-  const first = await provider.create({
-    modelRecord: record,
-    input: 'hello',
-    instructions: 'stable system prefix',
-    promptCacheKey: 'session-xai',
-  });
-  assert.equal(first.provider_state.previous_response_id, 'resp_xai_1');
-  assert.equal(Array.isArray(first.provider_state.compaction_input), true);
-  assert.equal(first.provider_state.compaction_input[0].role, 'system');
-
-  const compacted = await provider.compact({
-    modelRecord: record,
-    providerState: first.provider_state,
-    tokensBefore: 1000,
-  });
-  assert.match(requests.at(-1).url, /\/v1\/responses\/compact$/);
-  assert.equal(Array.isArray(requests.at(-1).body.input), true);
-  assert.equal(requests.at(-1).body.previous_response_id, undefined);
-  assert.deepEqual(compacted.provider_state.compaction_input, [
-    { type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' },
-  ]);
-  assert.equal(compacted.provider_state.previous_response_id, null);
-
-  await provider.create({
-    modelRecord: record,
-    providerState: compacted.provider_state,
-    input: 'continue after compaction',
-    promptCacheKey: 'session-xai',
-  });
-  assert.deepEqual(requests.at(-1).body.input, [
-    { type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' },
-    { role: 'user', content: 'continue after compaction' },
-  ]);
-});
-
-
-test('Anthropic adapter keeps append-only provider state and tool calls', async () => {
-  const record = {
-    model_key: 'anthropic:claude-test', provider: 'anthropic', provider_model_id: 'claude-test',
-    context_window: 200000, max_output_tokens: 4096, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async () => response({
-      id: 'msg_1', stop_reason: 'tool_use',
-      content: [{ type: 'tool_use', id: 'toolu_1', name: 'as_test', input: { a: 1 } }],
-      usage: { input_tokens: 20, output_tokens: 5, cache_read_input_tokens: 7 },
-    }),
-  });
-  const result = await provider.create({
-    modelRecord: record,
-    input: 'do it',
-    instructions: 'stable prefix',
-    tools: [{ type: 'function', name: 'as_test', description: 'test', parameters: { type: 'object', properties: {} } }],
-  });
-  assert.equal(result.tool_calls[0].call_id, 'toolu_1');
-  assert.equal(result.provider_state.messages.at(-1).role, 'assistant');
-  assert.equal(result.usage_snapshot.cumulative.cached_input_tokens, 7);
-});
-
-test('Gemini adapter maps provider token limits and function calls into AgentSam shape', async () => {
-  const record = {
-    model_key: 'gemini:gemini-test', provider: 'gemini', provider_model_id: 'gemini-test',
-    context_window: 1000000, max_output_tokens: 8192, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async () => response({
-      responseId: 'gem_1',
-      candidates: [{ finishReason: 'STOP', content: { role: 'model', parts: [{ functionCall: { name: 'as_test', args: { x: 2 } } }] } }],
-      usageMetadata: { promptTokenCount: 30, candidatesTokenCount: 8, cachedContentTokenCount: 10, thoughtsTokenCount: 2 },
-    }),
-  });
-  const result = await provider.create({ modelRecord: record, input: 'go', tools: [{ type: 'function', name: 'as_test', parameters: { type: 'object' } }] });
-  assert.equal(result.tool_calls[0].name, 'as_test');
-  assert.equal(result.usage_snapshot.current_context.window_tokens, 1000000);
-  assert.equal(result.usage_snapshot.cumulative.reasoning_tokens, 2);
-});
-
-test('Cloudflare adapter executes account-scoped Workers AI through the connected account', async () => {
-  let seen;
-  const record = {
-    model_key: 'cloudflare:@cf/test/model', provider: 'cloudflare', provider_model_id: '@cf/test/model',
-    context_window: null, max_output_tokens: null, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'cf-token', account_id: '1234567890abcdef1234567890abcdef' },
-    fetchImpl: async (url, init) => {
-      seen = { url, headers: init.headers, body: JSON.parse(init.body) };
-      return response({ id: 'cf_1', choices: [{ finish_reason: 'stop', message: { role: 'assistant', content: 'done' } }], usage: { prompt_tokens: 9, completion_tokens: 2 } });
-    },
-  });
-  const result = await provider.create({ modelRecord: record, input: 'go' });
-  assert.match(seen.url, /accounts\/1234567890abcdef1234567890abcdef\/ai\/v1\/chat\/completions$/);
-  assert.equal(seen.headers['cf-aig-gateway-id'], 'default');
-  assert.equal(seen.body.model, '@cf/test/model');
-  assert.equal(result.output_text, 'done');
-});

package/test/integration/repository-company-graph.test.mjs

@@ -1,90 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { test } from 'node:test';
-import {
-  COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION,
-  createRepositoryContract,
-  createRepositoryDependency,
-  createRepositoryIdentity,
-} from '../../packages/agentsam-repository/src/contracts.js';
-
-const root = path.resolve(import.meta.dirname, '../..');
-
-function schema(relative) {
-  return JSON.parse(fs.readFileSync(path.join(root, relative), 'utf8'));
-}
-
-test('portable repository identity is account-independent', () => {
-  const identity = createRepositoryIdentity({
-    repository_id: 'repo_agentsam_sdk',
-    full_name: 'SamPrimeaux/agentsam-sdk',
-    role: 'contract/runtime SDK',
-    default_branch: 'main',
-  });
-  assert.equal(identity.schema_version, COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION);
-  assert.equal(identity.repository_id, 'repo_agentsam_sdk');
-  assert.equal(Object.hasOwn(identity, 'account_id'), false);
-  assert.throws(() => createRepositoryIdentity({
-    repository_id: 'repo_x', full_name: 'owner/repo', role: 'test', account_id: 'au_test',
-  }), /must not embed account_id/);
-});
-
-test('repository contracts use account and repository SSOT only', () => {
-  const record = createRepositoryContract({
-    id: 'rct_runtime_receipts_v2',
-    account_id: 'au_test',
-    repository_id: 'repo_agentsam_sdk',
-    contract_key: 'runtime-receipts',
-    contract_version: '2',
-    contract_type: 'schema',
-    name: 'Runtime receipts',
-    manifest_path: 'protocol/telemetry',
-    contract_hash: `sha256:${'1'.repeat(64)}`,
-  });
-  assert.equal(record.account_id, 'au_test');
-  assert.equal(record.contract_type, 'schema');
-  assert.equal(record.status, 'active');
-  assert.throws(() => createRepositoryContract({
-    ...record, id: 'bad', workspace_id: 'ws_old',
-  }), /legacy ownership field/);
-});
-
-test('repository dependencies encode cross-repo criticality and failure policy', () => {
-  const edge = createRepositoryDependency({
-    id: 'rdep_iam_execos',
-    account_id: 'au_test',
-    source_repository_id: 'repo_inneranimalmedia',
-    target_repository_id: 'repo_execos',
-    dependency_type: 'runtime',
-    criticality: 'critical',
-    required_version: '1',
-    required_contract_hash: `sha256:${'2'.repeat(64)}`,
-    failure_policy: 'block_deploy',
-  });
-  assert.equal(edge.dependency_type, 'runtime');
-  assert.equal(edge.criticality, 'critical');
-  assert.equal(edge.failure_policy, 'block_deploy');
-  assert.throws(() => createRepositoryDependency({ ...edge, criticality: 'whatever' }), /unsupported criticality/);
-  assert.throws(() => createRepositoryDependency({ ...edge, owner_user_id: 'usr_old' }), /legacy ownership field/);
-});
-
-test('published JSON schemas expose the same ownership boundary', () => {
-  const identity = schema('protocol/repository/repository-identity.schema.json');
-  const contract = schema('protocol/repository/repository-contract.schema.json');
-  const dependency = schema('protocol/repository/repository-dependency.schema.json');
-
-  assert.equal(identity.additionalProperties, false);
-  assert.equal(Object.hasOwn(identity.properties, 'account_id'), false);
-  assert.ok(contract.required.includes('account_id'));
-  assert.ok(contract.required.includes('repository_id'));
-  assert.ok(dependency.required.includes('account_id'));
-  assert.ok(dependency.required.includes('source_repository_id'));
-  assert.ok(dependency.required.includes('target_repository_id'));
-
-  for (const item of [identity, contract, dependency]) {
-    for (const legacy of ['tenant_id', 'workspace_id', 'user_id', 'owner_user_id']) {
-      assert.equal(Object.hasOwn(item.properties, legacy), false, `${legacy} must not be part of ${item.title}`);
-    }
-  }
-});

package/test/integration/runtime-migrations.test.mjs

@@ -1,87 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { createLocalSqliteDatabase } from '../../src/local/sqlite.js';
-import { applyRuntimeMigrations } from '../../src/local/migrations.js';
-
-const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
-
-test('portable runtime migration installs AgentSam CLI state tables idempotently', async (t) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runtime-migration-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const db = await createLocalSqliteDatabase(path.join(root, 'agentsam.sqlite'));
-  try {
-    const first = await applyRuntimeMigrations(db);
-    const migrationCount = fs.readdirSync(path.join(repoRoot, 'migrations', 'runtime'))
-      .filter((name) => /^\d+.*\.sql$/i.test(name)).length;
-    assert.equal(first.applied, migrationCount);
-
-    const tables = await db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'agentsam_%' ORDER BY name"
-    ).all();
-    const names = new Set(tables.results.map((row) => row.name));
-    for (const name of [
-      'agentsam_agent_run',
-      'agentsam_approval_queue',
-      'agentsam_compaction_events',
-      'agentsam_context_digest',
-      'agentsam_cron_runs',
-      'agentsam_plans',
-      'agentsam_project_sessions',
-      'agentsam_schema_migrations',
-      'agentsam_todo',
-    ]) assert.equal(names.has(name), true, name);
-
-    const timers = await db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name='active_timers'"
-    ).first();
-    assert.equal(timers.name, 'active_timers');
-
-    const second = await applyRuntimeMigrations(db);
-    assert.equal(second.applied, 0);
-    assert.equal(second.results[0].status, 'already_applied');
-  } finally {
-    db.close();
-  }
-});
-
-test('ephemeral context digests expire and refresh while durable digests stay durable', async (t) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-digest-migration-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const db = await createLocalSqliteDatabase(path.join(root, 'agentsam.sqlite'));
-  try {
-    await applyRuntimeMigrations(db);
-
-    await db.prepare(
-      "INSERT INTO agentsam_context_digest (id,digest_type,source_hash,digest_hash,digest_text) VALUES (?,?,?,?,?)"
-    ).bind('repo_1', 'repo', 's1', 'h1', 'durable').run();
-    const durable = await db.prepare(
-      'SELECT expires_at_unix FROM agentsam_context_digest WHERE id=?'
-    ).bind('repo_1').first();
-    assert.equal(durable.expires_at_unix, null);
-
-    await db.prepare(
-      "INSERT INTO agentsam_context_digest (id,digest_type,source_hash,digest_hash,digest_text) VALUES (?,?,?,?,?)"
-    ).bind('session_1', 'session', 's2', 'h2', 'ephemeral').run();
-    const initial = await db.prepare(
-      'SELECT expires_at_unix FROM agentsam_context_digest WHERE id=?'
-    ).bind('session_1').first();
-    assert.equal(Number(initial.expires_at_unix) > 0, true);
-
-    await db.prepare(
-      'UPDATE agentsam_context_digest SET expires_at_unix = unixepoch() + 60 WHERE id=?'
-    ).bind('session_1').run();
-    await db.prepare(
-      'UPDATE agentsam_context_digest SET hit_count = hit_count + 1 WHERE id=?'
-    ).bind('session_1').run();
-    const refreshed = await db.prepare(
-      'SELECT expires_at_unix, hit_count FROM agentsam_context_digest WHERE id=?'
-    ).bind('session_1').first();
-    assert.equal(refreshed.hit_count, 1);
-    assert.equal(Number(refreshed.expires_at_unix) > Math.floor(Date.now() / 1000) + 2_500_000, true);
-  } finally {
-    db.close();
-  }
-});

package/test/integration/runtime-status.integration.test.mjs

@@ -1,212 +0,0 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import test from 'node:test';
-import {
-  collectCloudflareDeploymentStatus,
-  readCloudflareDeploymentContract,
-  parseWranglerToml,
-  resolveProjectD1Database,
-} from '../../src/cloudflare/runtime-status.js';
-import { collectRuntimeStatus } from '../../src/commands/runtime-status.js';
-import { readProjectConfig } from '../../src/lib/project-config.js';
-import { runStatus } from '../../src/commands/status.js';
-import { renderRuntimeStatus } from '../../src/ui/ansi.js';
-
-const root = path.resolve(new URL('../..', import.meta.url).pathname);
-
-test('checked-in Cloudflare deployment contract resolves the real Worker and portable bindings', () => {
-  const contract = readCloudflareDeploymentContract(root, readProjectConfig(root));
-  assert.equal(contract.worker_name, 'agentsam-sdk');
-  assert.equal(contract.config, 'apps/local-studio/backend/wrangler.jsonc');
-  assert.deepEqual(contract.bindings.map((row) => row.name), [
-    'AGENTSAM_WAI', 'ASSETS', 'CLOUDFLARE_ACCOUNT_ID', 'DB', 'EXECOS',
-    'GOOGLE_CLIENT_ID', 'GOOGLE_DESKTOP_CLIENT_ID', 'HYPERDRIVE', 'IAM_CLIENT_ID',
-    'IAM_OAUTH_ISSUER', 'PTY_SERVICE', 'WEBSITE_ASSETS',
-  ]);
-});
-
-test('Cloudflare runtime status compares the active deployed version to the checked-in binding contract', async () => {
-  const projectConfig = readProjectConfig(root);
-  const contract = readCloudflareDeploymentContract(root, projectConfig);
-  const liveBindings = contract.bindings.map((row) => ({ name: row.name, type: row.type }));
-  liveBindings.push({ name: 'OPENAI_API_KEY', type: 'secret_text' });
-  const calls = [];
-  const result = await collectCloudflareDeploymentStatus({
-    root,
-    projectConfig,
-    runWrangler: async (command, input) => {
-      calls.push({ command, input });
-      if (command === 'whoami') return { data: { loggedIn: true } };
-      if (command === 'deployments.list') return { data: [{ id: 'dep_1', created_on: '2026-09-18T12:00:00Z', versions: [{ version_id: 'ver_1', percentage: 100 }] }] };
-      if (command === 'versions.list') return { data: [{ id: 'ver_1', metadata: { created_on: '2026-09-18T12:00:00Z' } }] };
-      if (command === 'versions.view') return { data: { id: 'ver_1', number: 37, metadata: { created_on: '2026-09-18T12:00:00Z', source: 'wrangler' }, resources: { bindings: liveBindings } } };
-      throw new Error(`unexpected:${command}`);
-    },
-    fetchImpl: async () => ({ ok: true, status: 200, async json() { return { ok: true, app: 'agentsam-sdk' }; } }),
-  });
-  assert.equal(result.connected, true);
-  assert.equal(result.bindings.match, true);
-  assert.equal(result.version.number, 37);
-  assert.equal(result.health.ok, true);
-  assert.equal(calls.find((row) => row.command === 'versions.view').input.version_id, 'ver_1');
-});
-
-test('unified status is ready only when account, model, terminal, deployment and health are real', async () => {
-  const local = {
-    root, project: 'agentsam-sdk', configured: true, git: { branch: 'main', revision: 'abc123', dirty: false },
-    pty: { online: false, url: 'http://127.0.0.1:3099/health' }, api: { online: false }, db: { ready: true, tables: [] },
-  };
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => local,
-    collectIdentity: async () => ({ authenticated: true, active_auth: { kind: 'browser_oauth' }, identity: { account_id: 'acct_1' }, api_key: {} }),
-    collectModels: async () => ({ providers: [{ id: 'openai', configured: true }], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
-    collectTerminal: async () => ({ connected: true, instances: [{ id: 'inst_1' }], connections: [{ id: 'conn_1', active: true, default: true, health: 'online' }], error: null }),
-    collectCloudflare: async () => ({ configured: true, connected: true, worker_name: 'agentsam-sdk', bindings: { match: true, live: [] }, health: { ok: true, status: 200 } }),
-  });
-  assert.equal(status.ready, true);
-  assert.equal(status.local_ready, true);
-  assert.equal(status.state_storage.actor_runtime, 'none');
-  assert.deepEqual(status.checks, { account: true, models: true, terminal: true, cloudflare: true });
-  assert.equal(status.model_summary.verified_provider_models, 1);
-});
-
-test('fresh local project can start before SQLite has been initialized', async () => {
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: false, git: null, pty: { online: false }, api: {}, db: { exists: false, ready: false } }),
-    collectIdentity: async () => ({ authenticated: false, active_auth: {}, api_key: {} }),
-    collectModels: async () => ({ providers: [], providerModels: {}, local: { online: false, models: [] } }),
-    collectCloudflare: async () => ({ configured: false, bindings: { live: [] } }),
-  });
-  assert.equal(status.local_ready, true);
-  assert.equal(status.state_storage.migrated, false);
-  assert.equal(status.state_storage.runtime, 'sqlite');
-});
-
-test('unified status consumes the CLI-authorized terminal inventory returned by IAM context', async () => {
-  let legacyTerminalCalls = 0;
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: true, git: null, pty: { online: false }, api: {}, db: {} }),
-    collectIdentity: async () => ({
-      authenticated: true,
-      active_auth: { kind: 'browser_oauth' },
-      api_key: {},
-      terminal: {
-        available: true,
-        instances: [{ id: 'inst_1', kind: 'local_device' }],
-        connections: [{ id: 'conn_1', instance_id: 'inst_1', is_active: true, is_default: true, health_status: 'online' }],
-      },
-    }),
-    collectModels: async () => ({ providers: [], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
-    collectTerminal: async () => { legacyTerminalCalls += 1; return { connected: false, instances: [], connections: [] }; },
-    collectCloudflare: async () => ({ configured: false }),
-  });
-  assert.equal(legacyTerminalCalls, 0);
-  assert.equal(status.terminal.active_connection_count, 1);
-  assert.equal(status.checks.terminal, true);
-});
-
-test('status command supports machine-readable injected runtime status', async () => {
-  const expected = { schema_version: 'agentsam-runtime-status-v1', ready: true };
-  let output = '';
-  const result = await runStatus(['--json'], { collectRuntime: async () => expected, write(value) { output += value; } });
-  assert.equal(result, expected);
-  const parsed = JSON.parse(output);
-  assert.equal(parsed.schema_version, expected.schema_version);
-  assert.equal(parsed.ready, expected.ready);
-  assert.ok(parsed.next?.actions?.length > 0);
-  assert.ok(parsed.next?.headline);
-});
-
-test('renderRuntimeStatus explicitly displays DB and other resource bindings', () => {
-  const status = {
-    local: { project: 'agentsam-sdk', root: '/path/to/project' },
-    ready: true,
-    local_ready: true,
-    checks: { account: true, models: true, terminal: true, cloudflare: true },
-    cloudflare: {
-      configured: true,
-      worker_name: 'agentsam-sdk',
-      version: { number: 43 },
-      bindings: {
-        match: true,
-        live: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-          { name: 'IAM_CLIENT_ID', type: 'plain_text' },
-          { name: 'OPENAI_API_KEY', type: 'secret_text' },
-        ],
-        declared: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-        ],
-        resources: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-        ],
-        runtime_variables: [{ name: 'IAM_CLIENT_ID', type: 'plain_text' }],
-        runtime_secrets: [{ name: 'OPENAI_API_KEY', type: 'secret_text' }],
-        missing: [],
-      },
-      health: { ok: true, status: 200 },
-    },
-  };
-
-  const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
-  const rendered = stripAnsi(renderRuntimeStatus(status));
-  assert.match(rendered, /bindings\s+.*5 live/);
-  assert.match(rendered, /• DB · d1 \(inneranimalmedia-business\)/);
-  assert.match(rendered, /• WEBSITE_ASSETS · r2 \(agentsam-os-blueprint-content\)/);
-  assert.match(rendered, /• AGENTSAM_WAI · ai/);
-  assert.match(rendered, /1 vars · 1 secrets/);
-});
-
-test('parseWranglerToml parses worker name, d1 databases, r2, hyperdrive, and vars', () => {
-  const sample = `
-name = "my-sample-worker"
-main = "src/index.js"
-
-[vars]
-ENVIRONMENT = "production"
-PORT = 8080
-
-[[d1_databases]]
-binding = "DB"
-database_name = "sample-production-db"
-database_id = "d1-uuid-123"
-
-[[r2_buckets]]
-binding = "UPLOADS"
-bucket_name = "sample-bucket"
-
-[[hyperdrive]]
-binding = "HYPERDRIVE"
-id = "hd-uuid-456"
-
-[ai]
-binding = "AI"
-`;
-
-  const parsed = parseWranglerToml(sample);
-  assert.equal(parsed.name, 'my-sample-worker');
-  assert.equal(parsed.vars.ENVIRONMENT, 'production');
-  assert.equal(parsed.vars.PORT, 8080);
-  assert.equal(parsed.d1_databases.length, 1);
-  assert.equal(parsed.d1_databases[0].binding, 'DB');
-  assert.equal(parsed.d1_databases[0].database_name, 'sample-production-db');
-  assert.equal(parsed.r2_buckets.length, 1);
-  assert.equal(parsed.r2_buckets[0].binding, 'UPLOADS');
-  assert.equal(parsed.hyperdrive.length, 1);
-  assert.equal(parsed.hyperdrive[0].binding, 'HYPERDRIVE');
-  assert.equal(parsed.ai.binding, 'AI');
-});
-
-test('resolveProjectD1Database discovers project DB binding from checked-in config', () => {
-  const resolved = resolveProjectD1Database(root);
-  assert.equal(resolved, 'inneranimalmedia-business');
-});