@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/integration/codebaseindex-ingest.test.mjs

@@ -1,214 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it, before } from 'node:test';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import {
-  getCliCommand,
-  listCliCommands,
-  printAssistTip,
-  suggestCliCommands,
-} from '../../src/cli/command-catalog.js';
-import { parsePastedPaths, classifyMaterial, stageMaterials } from '../../src/indexing/ingest/materials.js';
-import { ensureSeedOperations, getSamOperation, AgentSamClient } from '../../src/sam/index.js';
-import { getSkill, loadSkill } from '../../src/skills/index.js';
-import { resolveHelpTopic, renderHelpOverview } from '../../src/ui/cli/help.js';
-import { runCodebaseindexIngest } from '../../src/commands/codebaseindex.js';
-import { buildInventory } from '../../src/indexing/ingest/inventory.js';
-
-describe('CLI command catalog assist', () => {
-  it('maps ingest alias to codebaseindex with skill tip', () => {
-    const entry = getCliCommand('ingest');
-    assert.equal(entry?.id, 'codebaseindex');
-    assert.equal(entry?.skill, 'agentsam-codebaseindex');
-    assert.equal(entry?.operation, 'codebaseindex.ingest');
-  });
-
-  it('prints tip: use skill for every catalogued command', () => {
-    const chunks = [];
-    for (const entry of listCliCommands()) {
-      if (!entry.skill) continue;
-      printAssistTip(entry, { write: (s) => chunks.push(s) });
-    }
-    const text = chunks.join('');
-    assert.match(text, /tip: use skill agentsam-codebaseindex/);
-    assert.match(text, /tip: use skill agentsam-app-fundamentals/);
-  });
-
-  it('suggests commands for typos', () => {
-    const hits = suggestCliCommands('codebase');
-    assert.ok(hits.some((h) => h.id === 'codebaseindex'));
-  });
-});
-
-describe('material paste/drop intake', () => {
-  it('parses pasted multi-path text', () => {
-    const paths = parsePastedPaths('/tmp/a.tar.gz\n"./site build"/index.html  screenshot.png');
-    assert.ok(paths.includes('/tmp/a.tar.gz'));
-    assert.ok(paths.some((p) => p.includes('index.html') || p.endsWith('screenshot.png')));
-  });
-
-  it('stages html and classifies archives', () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ingest-'));
-    const html = path.join(root, 'page.html');
-    fs.writeFileSync(html, '<html><body>hi</body></html>');
-    const classified = classifyMaterial(html);
-    assert.equal(classified.kind, 'document');
-
-    const tarPath = path.join(root, 'site.tar');
-    const bundle = path.join(root, 'bundle');
-    fs.mkdirSync(bundle);
-    fs.writeFileSync(path.join(bundle, 'index.html'), '<html>build</html>');
-    execFileSync('tar', ['-cf', tarPath, '-C', bundle, '.']);
-
-    const staged = stageMaterials({ root, materials: [html, tarPath] });
-    assert.equal(staged.schema, 'agentsam.ingest.materials.v1');
-    assert.ok(staged.include.length >= 1);
-    assert.ok(staged.assets.some((a) => a.kind === 'document') || staged.items.some((i) => i.kind === 'archive'));
-    assert.ok(fs.existsSync(path.join(root, staged.stage_root, 'manifest.json')));
-  });
-});
-
-describe('codebaseindex SAM primitive', () => {
-  before(() => ensureSeedOperations());
-
-  it('registers codebaseindex.ingest', () => {
-    const op = getSamOperation('codebaseindex.ingest');
-    assert.ok(op);
-    assert.equal(op.execution.model, 'optional');
-    assert.deepEqual(op.cli.command[0], ['codebaseindex']);
-  });
-
-  it('skill agentsam-codebaseindex loads', () => {
-    assert.ok(getSkill('ingest'));
-    const loaded = loadSkill('agentsam-codebaseindex');
-    assert.match(loaded.instructions, /codebaseindex\.ingest/);
-    assert.match(loaded.instructions, /sam\.codebaseindex\.index\.run/);
-  });
-
-  it('describe + discover surface ingest', async () => {
-    const sam = new AgentSamClient();
-    const info = await sam.describe('codebaseindex.ingest');
-    assert.equal(info.ok, true);
-    const found = await sam.discover({ query: 'ingest archive embedding' });
-    assert.ok(found.operations.some((c) => c.id === 'codebaseindex.ingest'));
-  });
-
-  it('plan-only ingest via invoke (repo allowlist)', async () => {
-    const sam = new AgentSamClient();
-    const result = await sam.invoke('codebaseindex.ingest', {
-      root: process.cwd(),
-      include: ['src/sam'],
-      exclude: ['node_modules', '.git'],
-      embeddingChoice: 'none',
-      planOnly: true,
-    });
-    assert.equal(result.ok, true);
-    assert.equal(result.data?.pipeline, 'sam.codebaseindex.index.run');
-    assert.equal(result.data?.mode, 'plan');
-  });
-});
-
-describe('codebaseindex real execution', () => {
-  it('publishes, smoke-searches, completes the graph, and returns portable paths', async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-codebaseindex-run-'));
-    fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, 'src', 'demo.js'),
-      'export function hello() { return "hello AgentSam"; }\n',
-    );
-
-    const result = await runCodebaseindexIngest({
-      root,
-      include: ['src'],
-      exclude: [],
-      embeddingChoice: 'none',
-      embed: false,
-      planOnly: false,
-    });
-
-    assert.equal(result.mode, 'run');
-    assert.equal(result.root, '.');
-    assert.equal(result.inventory.root, '.');
-
-    assert.equal(result.index.published, true);
-    assert.equal(result.job_graph.status, 'completed');
-    assert.equal(result.job_graph.current, null);
-    assert.equal(
-      result.job_graph.nodes.find((node) => node.id === 'embedding.generate')?.status,
-      'skipped',
-    );
-    assert.equal(
-      result.job_graph.nodes.find((node) => node.id === 'search.smoke')?.status,
-      'done',
-    );
-
-    assert.equal(
-      result.search_smoke.generation_id,
-      result.index.generation_id,
-    );
-    assert.ok(result.search_smoke.sources_included >= 1);
-  });
-});
-
-describe('catalog-driven help', () => {
-  it('resolves ingest topic from catalog', () => {
-    const topic = resolveHelpTopic('ingest');
-    assert.ok(topic);
-    assert.ok(topic.rows.some(([cmd]) => cmd.includes('codebaseindex')));
-  });
-
-  it('overview mentions skill baseline', () => {
-    const text = renderHelpOverview('2.6.3');
-    assert.match(text, /tip: use skill/);
-    assert.match(text, /command catalog/i);
-  });
-});
-
-describe('Cargo workspace inventory', () => {
-  it('treats workspace members as source and keeps generated/operational state out of the starting scope', () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-cargo-workspace-'));
-    try {
-      fs.writeFileSync(path.join(root, 'Cargo.toml'), `[workspace]
-members = [
-  "core",
-  "worker",
-]
-resolver = "2"
-`);
-      for (const crate of ['core', 'worker']) {
-        fs.mkdirSync(path.join(root, crate, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(root, crate, 'Cargo.toml'), `[package]
-name = "${crate}"
-version = "0.1.0"
-edition = "2024"
-`);
-        fs.writeFileSync(path.join(root, crate, 'src', 'lib.rs'), `pub fn ${crate}_value() -> u32 { 1 }
-`);
-      }
-      fs.mkdirSync(path.join(root, 'docs'), { recursive: true });
-      fs.writeFileSync(path.join(root, 'docs', 'README.md'), '# docs\n');
-      fs.mkdirSync(path.join(root, 'target'), { recursive: true });
-      fs.writeFileSync(path.join(root, 'target', 'build.txt'), 'generated\n');
-      fs.mkdirSync(path.join(root, '.agentsam', 'machine'), { recursive: true });
-      fs.writeFileSync(path.join(root, '.agentsam', 'machine', 'state.sqlite'), '');
-
-      const inventory = buildInventory({ root });
-      assert.deepEqual(inventory.cargo_workspace_roots, ['core', 'worker']);
-      assert.ok(inventory.categories.source.includes('core'));
-      assert.ok(inventory.categories.source.includes('worker'));
-      assert.ok(inventory.categories.docs.includes('docs'));
-      assert.ok(inventory.categories.dependencies.includes('target'));
-      assert.ok(inventory.categories.operational.includes('.agentsam'));
-
-      assert.ok(inventory.suggested.include.includes('core'));
-      assert.ok(inventory.suggested.include.includes('worker'));
-      assert.ok(inventory.suggested.include.includes('docs'));
-      assert.ok(inventory.suggested.exclude.includes('target'));
-      assert.ok(inventory.suggested.exclude.includes('.agentsam'));
-    } finally {
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  });
-});

package/test/integration/core-client.integration.test.mjs

@@ -1,55 +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 { getJson } from '../../src/lib/core-client.js';
-import { saveAccountSession } from '../../src/lib/account-session.js';
-
-test('core client accepts an already-resolved browser OAuth bearer without reclassifying it as an API key', async () => {
-  let authorization = '';
-  const result = await getJson('/api/sdk/context', {
-    bearer: 'browser_oauth_access_token',
-    env: { IAM_OAUTH_ISSUER: 'https://iam.example.test' },
-    fetchImpl: async (_url, options) => {
-      authorization = options.headers.Authorization;
-      return { ok: true, async json() { return { ok: true }; } };
-    },
-  });
-  assert.equal(result.ok, true);
-  assert.equal(authorization, 'Bearer browser_oauth_access_token');
-});
-
-test('legacy string credential form is treated as a resolved bearer for both API keys and OAuth tokens', async () => {
-  const original = globalThis.fetch;
-  let authorization = '';
-  globalThis.fetch = async (_url, options) => {
-    authorization = options.headers.Authorization;
-    return { ok: true, async json() { return { ok: true }; } };
-  };
-  try {
-    await getJson('/api/sdk/context', 'browser_oauth_access_token');
-    assert.equal(authorization, 'Bearer browser_oauth_access_token');
-  } finally {
-    globalThis.fetch = original;
-  }
-});
-
-test('core client refreshes browser OAuth once when IAM returns 401 before local expiry', async t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-core-client-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  saveAccountSession({ access_token: 'stale_browser_token', refresh_token: 'refresh_token', expires_in: 3600 }, { home });
-  const seen = [];
-  const result = await getJson('/api/sdk/context', {
-    home,
-    env: { IAM_OAUTH_ISSUER: 'https://iam.example.test' },
-    refreshImpl: async () => ({ access_token: 'fresh_browser_token', refresh_token: 'refresh_token' }),
-    fetchImpl: async (_url, options) => {
-      seen.push(options.headers.Authorization);
-      const ok = seen.length > 1;
-      return { ok, status: ok ? 200 : 401, async json() { return ok ? { ok: true } : { error: 'Unauthorized' }; } };
-    },
-  });
-  assert.equal(result.ok, true);
-  assert.deepEqual(seen, ['Bearer stale_browser_token', 'Bearer fresh_browser_token']);
-});

package/test/integration/error-runtime-rpc.test.mjs

@@ -1,71 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import {
-  AgentSamError,
-  createErrorEnvelope,
-} from '../../packages/agentsam-errors/src/index.js';
-import {
-  decodeErrorDetail,
-  decodeJob,
-  encodeErrorDetail,
-  encodeJob,
-  fromGrpcError,
-  toGrpcError,
-} from '../../src/knowledge/service/grpc-codec.js';
-
-function sampleEnvelope() {
-  return createErrorEnvelope({
-    reason: 'provider_budget_exhausted',
-    message: 'Provider account budget is exhausted.',
-    source: { kind: 'provider', name: 'openai', service: 'responses' },
-    resolution_owner: 'agentsam',
-    severity: 'blocking_internal',
-    remediation: { action: 'inspect_platform', message: 'AgentSam must inspect its platform-owned OpenAI account.' },
-    domain: 'provider',
-    tool: 'openai',
-    stage: 'request',
-    provider: 'openai',
-    provider_code: 'project_spend_limit_exceeded',
-    request_id: 'req_123',
-    trace_id: 'trace_123',
-    transport: 'grpc',
-    resource: { type: 'provider_account', id: 'platform', name: 'OpenAI' },
-    native: { code: 'project_spend_limit_exceeded', exception_type: 'insufficient_quota' },
-    environment: { component: 'responses', runtime: 'node', platform: 'linux' },
-    details: { tier: 'default' },
-  });
-}
-
-test('protobuf ErrorDetail preserves the canonical AgentSam envelope', () => {
-  const source = sampleEnvelope();
-  const roundTrip = decodeErrorDetail(encodeErrorDetail(source));
-  assert.deepEqual(roundTrip, source);
-});
-
-test('gRPC exception metadata round-trips one canonical AgentSamError', () => {
-  const source = sampleEnvelope();
-  const wireError = toGrpcError(new AgentSamError(source));
-  const decoded = fromGrpcError(wireError);
-  assert.ok(decoded instanceof AgentSamError);
-  assert.deepEqual(decoded.envelope, source);
-  assert.equal(decoded.grpcCode, 8);
-  assert.equal(decoded.rpcCode, 'RESOURCE_EXHAUSTED');
-});
-
-test('durable job protobuf retains structured failure and compatibility message', () => {
-  const failure = sampleEnvelope();
-  const message = encodeJob({
-    id: '11111111-1111-1111-1111-111111111111',
-    status: 'failed',
-    attempts: 2,
-    created_at: '2026-09-17T00:00:00.000Z',
-    updated_at: '2026-09-17T00:01:00.000Z',
-    result: null,
-    failure,
-  });
-  const decoded = decodeJob(message);
-  assert.equal(decoded.status, 'failed');
-  assert.deepEqual(decoded.failure, failure);
-  assert.equal(decoded.error, failure.message);
-});

package/test/integration/features-resolve.test.mjs

@@ -1,147 +0,0 @@
-/**
- * Feature-packet resolver tests — package-local oauth-login-portal compartment.
- */
-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 { fileURLToPath } from 'node:url';
-
-import {
-  formatResourcesSummary,
-  getIdentityProviderTemplate,
-  loadIdentityResources,
-  loadOAuthLoginPortalFeature,
-  resolveAuthFeature,
-  writeFeatureSelections,
-  writeFeaturesResolved,
-} from '../../src/features/resolve.js';
-
-const SDK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
-
-test('oauth-login-portal feature packet loads with artifacts', () => {
-  const feature = loadOAuthLoginPortalFeature();
-  assert.equal(feature.id, 'identity.oauth-login-portal');
-  assert.ok(Array.isArray(feature.artifacts));
-  assert.ok(feature.artifacts.some((a) => a.kind === 'provider-catalog'));
-  assert.ok(!fs.existsSync(path.join(SDK_ROOT, 'protocol/identity')));
-  assert.ok(!fs.existsSync(path.join(SDK_ROOT, 'protocol/features/auth.json')));
-});
-
-test('auth feature resolves real D1 resources, not a pretend iam-d1 profile', () => {
-  const resolved = resolveAuthFeature({
-    selected: true,
-    capabilities: ['identity.init'],
-    provider_template: 'google',
-    selected_at: '2026-09-24T04:25:12.860Z',
-  });
-  assert.equal(resolved.provider_template, 'google');
-  assert.equal(resolved.provider.id, 'google');
-  assert.equal(resolved.provider.status, 'ready');
-  assert.equal(resolved.schema_profile, undefined);
-  assert.equal(resolved.resources.engine, 'd1');
-  assert.deepEqual(resolved.resources.migration_sources, [
-    'src/migrations/0001_identity_core.sql',
-    'src/migrations/0002_company.sql',
-    'src/migrations/0003_accounts_ssot.sql',
-  ]);
-  const names = resolved.resources.tables.map((t) => t.name);
-  assert.deepEqual(names, [
-    'accounts',
-    'auth_users',
-    'auth_sessions',
-    'account_identities',
-    'oauth_states',
-    'password_reset_tokens',
-    'company',
-  ]);
-  assert.match(formatResourcesSummary(resolved.resources), /tables=accounts,auth_users,/);
-  assert.doesNotMatch(formatResourcesSummary(resolved.resources), /iam-d1/);
-});
-
-test('legacy iam provider_template normalizes to inneranimalmedia', () => {
-  const resolved = resolveAuthFeature({
-    selected: true,
-    capabilities: ['identity.init'],
-    provider_template: 'iam',
-  });
-  assert.equal(resolved.provider_template, 'inneranimalmedia');
-  assert.equal(resolved.provider.id, 'inneranimalmedia');
-  assert.equal(resolved.provider.oauth_provider_key, 'iam');
-  assert.equal(resolved.provider.status, 'ready');
-});
-
-test('cloudflare is registered ready in provider catalog', () => {
-  const provider = getIdentityProviderTemplate('cloudflare');
-  assert.equal(provider?.status, 'ready');
-  assert.equal(provider?.registered, true);
-});
-
-test('resources.json indexes D1 tables without owning DDL', () => {
-  const resources = loadIdentityResources();
-  assert.equal(resources.engine, 'd1');
-  assert.deepEqual(resources.migration_sources, [
-    'src/migrations/0001_identity_core.sql',
-    'src/migrations/0002_company.sql',
-    'src/migrations/0003_accounts_ssot.sql',
-  ]);
-  const names = resources.tables.map((t) => t.name);
-  assert.ok(names.includes('auth_users'));
-  assert.ok(names.includes('company'));
-});
-
-test('writeFeatureSelections emits schema_version 2 and resolved snapshot', () => {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-features-'));
-  try {
-    fs.mkdirSync(path.join(cwd, '.agentsam'), { recursive: true });
-    const { state_path, resolved_path, snapshot } = writeFeatureSelections(cwd, {
-      schema_version: 2,
-      features: {
-        auth: {
-          selected: true,
-          capabilities: ['identity.init'],
-          provider_template: 'inneranimalmedia',
-          selected_at: '2026-09-24T04:25:12.860Z',
-        },
-      },
-    });
-    const state = JSON.parse(fs.readFileSync(state_path, 'utf8'));
-    assert.equal(state.schema_version, 2);
-    assert.equal(state.features.auth.provider_template, 'inneranimalmedia');
-    assert.equal(snapshot.features.auth.resources.engine, 'd1');
-    assert.ok(snapshot.features.auth.resources.tables.some((t) => t.name === 'auth_users'));
-    assert.equal(snapshot.features.auth.schema_profile, undefined);
-    assert.ok(fs.existsSync(resolved_path));
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('sdk-style project selections resolve against package packet without local machine state', () => {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-sdk-feature-select-'));
-  try {
-    const { snapshot } = writeFeaturesResolved(cwd, null, {
-      selections: {
-        schema_version: 2,
-        features: {
-          auth: {
-            selected: true,
-            capabilities: ['identity.init'],
-            provider_template: 'inneranimalmedia',
-          },
-        },
-      },
-    });
-    assert.equal(snapshot.schema, 'agentsam.features.resolved.v1');
-    assert.equal(snapshot.features.auth.provider_template, 'inneranimalmedia');
-    assert.equal(snapshot.features.auth.feature.id, 'identity.oauth-login-portal');
-    assert.equal(snapshot.features.auth.resources.engine, 'd1');
-    assert.match(
-      formatResourcesSummary(snapshot.features.auth.resources),
-      /auth_users,auth_sessions,account_identities/,
-    );
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});

package/test/integration/icon-registry.test.mjs

@@ -1,67 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import {
-  AGENTSAM_ICON_KEYS,
-  normalizeIconKey,
-  isAgentsamIconKey,
-  resolveCliIconGlyph,
-  createIconRenderer,
-  ICON_ALIASES,
-} from '../../protocol/ui/icon-registry.mjs';
-import iconSchema from '../../protocol/ui/icon.v1.schema.json' with { type: 'json' };
-
-describe('agentsam.icon.v1', () => {
-  it('schema enum matches registry keys', () => {
-    assert.deepEqual([...(iconSchema.enum || [])].sort(), [...AGENTSAM_ICON_KEYS].sort());
-  });
-
-  it('includes generic fallback and first-class AgentSam concepts', () => {
-    for (const key of [
-      'generic',
-      'database',
-      'vector',
-      'identity',
-      'key',
-      'brand',
-      'theme',
-      'app',
-      'repository',
-      'connection',
-      'metrics',
-    ]) {
-      assert.equal(isAgentsamIconKey(key), true, key);
-    }
-  });
-
-  it('normalizes aliases and rejects lucide/emoji-like values to generic', () => {
-    assert.equal(normalizeIconKey('db'), 'database');
-    assert.equal(normalizeIconKey('repo'), 'repository');
-    assert.equal(normalizeIconKey('lucide-database'), 'database');
-    assert.equal(normalizeIconKey('🗄️'), 'generic');
-    assert.equal(normalizeIconKey(''), 'generic');
-    assert.equal(normalizeIconKey('unknown-future-key'), 'generic');
-  });
-
-  it('createIconRenderer falls back to generic without throwing', () => {
-    const render = createIconRenderer(
-      { database: 'DB', generic: 'G', identity: 'ID' },
-      'FALLBACK',
-    );
-    assert.equal(render('database'), 'DB');
-    assert.equal(render('db'), 'DB');
-    assert.equal(render('not-a-real-icon'), 'G');
-    assert.equal(render('identity'), 'ID');
-  });
-
-  it('CLI glyphs always resolve', () => {
-    assert.ok(resolveCliIconGlyph('database'));
-    assert.equal(resolveCliIconGlyph('totally-unknown'), resolveCliIconGlyph('generic'));
-  });
-
-  it('aliases only map to canonical vocabulary', () => {
-    for (const [from, to] of Object.entries(ICON_ALIASES)) {
-      assert.equal(isAgentsamIconKey(to), true, `${from} → ${to}`);
-      assert.equal(normalizeIconKey(from), to);
-    }
-  });
-});

package/test/integration/ingest-discover-models.test.mjs

@@ -1,30 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import {
-  encodeEmbeddingChoice,
-  parseEmbeddingChoice,
-  looksLikeEmbedModel,
-} from '../../src/indexing/ingest/discover-models.js';
-
-describe('ingest model discovery helpers', () => {
-  it('encodes/decodes embedding choices without breaking model ids that contain colons', () => {
-    const value = encodeEmbeddingChoice('ollama', 'mxbai-embed-large:latest', 1024);
-    assert.equal(value, 'ollama|mxbai-embed-large:latest|1024');
-    const parsed = parseEmbeddingChoice(value);
-    assert.equal(parsed.provider, 'ollama');
-    assert.equal(parsed.model, 'mxbai-embed-large:latest');
-    assert.equal(parsed.dimensions, 1024);
-  });
-
-  it('treats none as disabled embedding', () => {
-    const parsed = parseEmbeddingChoice('none');
-    assert.equal(parsed.provider, 'none');
-    assert.equal(parsed.dimensions, 0);
-  });
-
-  it('classifies ollama embed vs chat tags', () => {
-    assert.equal(looksLikeEmbedModel('mxbai-embed-large:latest'), true);
-    assert.equal(looksLikeEmbedModel('nomic-embed-text'), true);
-    assert.equal(looksLikeEmbedModel('qwen2.5-coder:latest'), false);
-  });
-});

package/test/integration/inspect-path-cli.test.mjs

@@ -1,46 +0,0 @@
-import test from 'node:test';
-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 { fileURLToPath } from 'node:url';
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
-const CLI = path.join(ROOT, 'bin/agentsam');
-
-function run(args, cwd = ROOT) {
-  return spawnSync(process.execPath, [CLI, ...args], {
-    cwd,
-    encoding: 'utf8',
-    env: { ...process.env, NO_COLOR: '1' },
-  });
-}
-
-function jsonFrom(text) {
-  const start = text.indexOf('{');
-  assert.notEqual(start, -1, `expected JSON output, received: ${text}`);
-  return JSON.parse(text.slice(start));
-}
-
-test('agentsam inspect --help documents the positional path world-state contract', () => {
-  const result = run(['inspect', '--help']);
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /agentsam inspect \[path\]/);
-  assert.match(result.stdout, /deterministic repository world state/i);
-  assert.match(result.stdout, /No model, embeddings, network, provider spend/i);
-});
-
-test('agentsam inspect accepts a repository path as the first positional argument', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-inspect-path-'));
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'inspect-fixture', version: '1.0.0' }));
-  fs.mkdirSync(path.join(root, 'src'));
-  fs.writeFileSync(path.join(root, 'src/index.js'), 'export function fixture() { return 42; }\n');
-
-  const result = run(['inspect', root, '--json', '--index']);
-  assert.equal(result.status, 0, result.stderr || result.stdout);
-  const output = jsonFrom(result.stdout);
-  assert.ok(output.snapshot_id);
-  assert.ok(output.merkle_root || output.tree?.merkle_root);
-  assert.match(JSON.stringify(output), /inspect-fixture|src\/index\.js/);
-});