@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/test/integration/inventory-eligibility.test.mjs

@@ -1,59 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { discoverOpenAIModels, discoverGeminiModels, discoverCursorModels } from '../../src/models/discovery.js';
-import { sanitizeInventoryForClient } from '../../src/models/inventory-core.js';
-
-function json(body) {
-  return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
-}
-
-function sanitized(models) {
-  return sanitizeInventoryForClient({
-    providers: [],
-    discovery: {},
-    availableModels: models,
-  }).availableModels;
-}
-
-test('known OpenAI Responses reference is selectable while unknown live models stay visible', async () => {
-  const result = await discoverOpenAIModels('user-key', async () => json({
-    data: [{ id: 'gpt-5.6-sol' }, { id: 'brand-new-unclassified-model' }],
-  }));
-  const rows = sanitized(result.models);
-  assert.equal(rows.length, 2);
-  assert.equal(rows.find((row) => row.model_id === 'gpt-5.6-sol')?.chat_eligible, true);
-  const unknown = rows.find((row) => row.model_id === 'brand-new-unclassified-model');
-  assert.equal(unknown?.chat_eligible, false);
-  assert.equal(unknown?.eligibility_reason, 'capability_unknown');
-});
-
-test('Cursor inventory is preserved but reports adapter unavailability', async () => {
-  const result = await discoverCursorModels('cursor-key', async () => json({
-    items: [{ id: 'gpt-5.6-sol', displayName: 'GPT-5.6 Sol', parameters: [] }],
-  }));
-  const [row] = sanitized(result.models);
-  assert.equal(row.provider, 'cursor');
-  assert.equal(row.model_id, 'gpt-5.6-sol');
-  assert.equal(row.chat_eligible, false);
-  assert.equal(row.eligibility_reason, 'provider_adapter_unavailable');
-});
-
-test('Gemini provider description keeps TTS visible outside the chat picker', async () => {
-  const result = await discoverGeminiModels('gemini-key', async () => json({
-    models: [{
-      name: 'models/gemini-tts-fixture',
-      baseModelId: 'gemini-tts-fixture',
-      displayName: 'Voice fixture',
-      description: 'Preview Text-to-Speech model',
-      supportedGenerationMethods: ['generateContent'],
-      inputTokenLimit: 8192,
-      outputTokenLimit: 8192,
-    }],
-  }));
-  const [row] = sanitized(result.models);
-  assert.equal(row.model_id, 'gemini-tts-fixture');
-  assert.equal(row.chat_eligible, false);
-  assert.equal(row.eligibility_reason, 'specialized_output_model');
-  assert.equal(row.eligibility_source, 'provider_api');
-});

package/test/integration/inventory-evidence.test.mjs

@@ -1,125 +0,0 @@
-import { describe, it } 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 { execFileSync } from 'node:child_process';
-import { buildInventory } from '../../src/indexing/ingest/inventory.js';
-import {
-  extractStyleEvidence,
-  finalizeStyleEvidence,
-  mergeStyleEvidence,
-} from '../../src/indexing/ingest/style-evidence.js';
-import { inventory as knowledgeInventory } from '../../src/knowledge/source.js';
-
-function write(root, rel, text = '') {
-  const abs = path.join(root, rel);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, text);
-}
-
-describe('inventory classifies by evidence', () => {
-  it('uses dominant evidence, root files, tooling LOC, and git ignore state', () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'inv-evidence-'));
-    try {
-      execFileSync('git', ['init', '-q'], { cwd: root });
-      write(root, '.gitignore', '.sites-runtime/\n');
-
-      write(root, 'app/page.tsx', Array.from({ length: 30 }, (_, i) => `export const x${i} = ${i};`).join('\n'));
-      write(root, 'db/schema.sql', 'create table t (id integer);\n');
-      write(root, 'drizzle/meta/_journal.json', '{"version":"1"}\n');
-      for (let i = 1; i <= 9; i += 1) write(root, `plans/p${i}.md`, `# plan ${i}\ntext\n`);
-      write(root, 'plans/schema.sql', 'create table plan (id integer);\n');
-      write(root, 'public/logo.png', 'x');
-      write(root, 'scripts/harvest.py', Array.from({ length: 80 }, (_, i) => `x_${i} = ${i}`).join('\n'));
-      write(root, '.sites-runtime/cache/blob.bin', 'x'.repeat(2048));
-
-      write(root, 'package.json', '{"name":"fixture"}\n');
-      write(root, 'wrangler.jsonc', '{}\n');
-      write(root, 'drizzle.config.ts', 'export default {};\n');
-      write(root, 'README.md', '# Fixture\n');
-      write(root, 'entry.ts', 'export const root = true;\n');
-      write(root, 'package-lock.json', '{"lockfileVersion":3}\n');
-      write(root, '.env', 'SECRET=do-not-index\n');
-      write(root, '.dev.vars', 'TOKEN=do-not-index\n');
-      write(root, 'tls.pem', 'private material\n');
-
-      execFileSync('git', ['add', '.'], { cwd: root });
-
-      const inventory = buildInventory({ root });
-      const categories = inventory.categories;
-
-      assert.ok(categories.source.includes('app'));
-      assert.ok(categories.source.includes('db'));
-      assert.ok(categories.docs.includes('plans'), '9 markdown + 1 SQL is dominantly docs');
-      assert.ok(categories.data.includes('drizzle'), 'JSON-only drizzle metadata is data');
-      assert.ok(categories.assets.includes('public'));
-      assert.ok(categories.operational.includes('.sites-runtime'));
-      assert.ok(categories.tooling.includes('scripts'));
-      assert.deepEqual(categories.unknown, []);
-
-      assert.ok(inventory.suggested.include.includes('scripts'), 'tracked top-2 language tooling is promoted');
-      assert.ok(inventory.top_level_details.scripts.loc >= 80);
-      assert.equal(inventory.top_level_details.scripts.dominant_language, 'Python');
-
-      assert.ok(inventory.root_files.manifest.includes('package.json'));
-      assert.ok(inventory.root_files.manifest.includes('wrangler.jsonc'));
-      assert.ok(inventory.root_files.manifest.includes('drizzle.config.ts'));
-      assert.ok(inventory.root_files.docs.includes('README.md'));
-      assert.ok(inventory.root_files.source.includes('entry.ts'));
-      assert.ok(inventory.root_files.lockfile.includes('package-lock.json'));
-      assert.ok(inventory.root_files.secret.includes('.env'));
-      assert.ok(inventory.root_files.secret.includes('.dev.vars'));
-      assert.ok(inventory.root_files.secret.includes('tls.pem'));
-
-      for (const wanted of ['package.json', 'wrangler.jsonc', 'drizzle.config.ts', 'README.md', 'entry.ts']) {
-        assert.ok(inventory.suggested.include_files.includes(wanted), wanted);
-      }
-      for (const forbidden of ['package-lock.json', '.env', '.dev.vars', 'tls.pem']) {
-        assert.ok(!inventory.suggested.include_files.includes(forbidden), forbidden);
-      }
-
-      const files = knowledgeInventory(root, { include: ['.'], exclude: [] });
-      assert.ok(files.includes('entry.ts'));
-      assert.ok(!files.includes('.env'));
-      assert.ok(!files.includes('.dev.vars'));
-      assert.ok(!files.includes('tls.pem'));
-      assert.ok(!files.includes('package-lock.json'));
-    } finally {
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it('detects coherent theme signatures from markup and CSS evidence', () => {
-    const evidence = extractStyleEvidence(`
-      <html data-theme-preset="fuel-free-time" data-header-preset="adaptive-bar">
-        <link rel="stylesheet" href="/css/heuristic-theme.css">
-        <body>
-          <header class="fnf-header fnf-header--adaptive-bar">
-            <a class="fnf-logo"></a>
-            <nav class="fnf-primary"></nav>
-          </header>
-        </body>
-      </html>
-      <style>
-        :root { --fnf-accent: #ff4d00; --fnf-logo-height: 58px; }
-        .fnf-header { color: var(--fnf-accent); }
-        .fnf-logo { height: var(--fnf-logo-height); }
-      </style>
-    `);
-
-    assert.equal(evidence.theme_presets['fuel-free-time'], 1);
-    assert.equal(evidence.header_presets['adaptive-bar'], 1);
-    assert.equal(evidence.stylesheets['/css/heuristic-theme.css'], 1);
-    const fnf = evidence.namespaces.find((row) => row.prefix === 'fnf');
-    assert.ok(fnf);
-    assert.ok(fnf.signal_kinds >= 2);
-    assert.ok(fnf.signals.class_tokens >= 3);
-    assert.ok(fnf.signals.custom_properties >= 2);
-
-    const final = finalizeStyleEvidence(mergeStyleEvidence(null, evidence));
-    const finalFnf = final.namespaces.find((row) => row.prefix === 'fnf');
-    assert.equal(final.theme_candidate, true);
-    assert.equal(finalFnf?.candidate, true);
-  });
-});

package/test/integration/knowledge-rpc.test.mjs

@@ -1,112 +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 { fileURLToPath } from 'node:url';
-import { defaultConfig } from '../../src/knowledge/config.js';
-import { createKnowledgeJobEngine } from '../../src/knowledge/service/job-engine.js';
-import { startKnowledgeHttpServer } from '../../src/knowledge/service/server.js';
-import { startKnowledgeGrpcServer } from '../../src/knowledge/service/grpc-server.js';
-import { createKnowledgeServiceClient } from '../../src/knowledge/service/client.js';
-import { createKnowledgeGrpcClient } from '../../src/knowledge/service/grpc-client.js';
-import { grpc } from '../../src/knowledge/service/grpc-codec.js';
-
-const fixtureWorker = fileURLToPath(new URL('../fixtures/knowledge-rpc-worker.mjs', import.meta.url));
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-async function waitFor(client, id, wanted = new Set(['completed', 'failed'])) {
-  for (let i = 0; i < 200; i++) {
-    const job = await client.job(id);
-    if (wanted.has(job.status)) return job;
-    await sleep(10);
-  }
-  throw new Error(`Job ${id} did not reach ${[...wanted].join('/')}.`);
-}
-
-async function collect(stream) {
-  const events = [];
-  for await (const event of stream) events.push(event);
-  return events;
-}
-
-test('knowledge HTTP and gRPC adapters share auth, validation, idempotency, lifecycle, cancellation, and durable jobs', async t => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-rpc-'));
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const root = path.join(tmp, 'repo');
-  const stateDir = path.join(tmp, 'state');
-  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'src', 'sample.js'), 'export const sample = true;\n');
-  const config = defaultConfig({ include: ['src'] });
-  const repositories = { sample: { root, config } };
-  const token = 'r'.repeat(64);
-  const engine = createKnowledgeJobEngine({ stateDir, repositories, workerPath: fixtureWorker, jobTimeoutMs: 2_000 });
-  const http = await startKnowledgeHttpServer({ engine, token, port: 0 });
-  const rpcServer = await startKnowledgeGrpcServer({ engine, token, port: 0 });
-  const httpClient = createKnowledgeServiceClient({ baseUrl: `http://127.0.0.1:${http.address.port}`, token });
-  const rpc = createKnowledgeGrpcClient({ target: rpcServer.target, token });
-  const unauthorized = createKnowledgeGrpcClient({ target: rpcServer.target, token: 'x'.repeat(64) });
-  t.after(async () => {
-    unauthorized.close();
-    rpc.close();
-    await rpcServer.close();
-    await http.close();
-    await engine.close();
-  });
-
-  const repos = await rpc.repositories();
-  assert.deepEqual(repos.repositories, ['sample']);
-  assert.equal(repos.repository_details[0].repository_id, config.repository_id);
-  assert.equal(repos.embeddings_enabled, false);
-  await assert.rejects(unauthorized.repositories(), error => error.status === 401 && error.grpcCode === grpc.status.UNAUTHENTICATED);
-  await assert.rejects(
-    rpc.submit({ repository: 'sample', operation: 'bogus' }),
-    error => error.status === 400 && error.grpcCode === grpc.status.INVALID_ARGUMENT,
-  );
-
-  const request = { repository: 'sample', operation: 'index', generation_id: 'equivalent' };
-  const fromHttp = await httpClient.submit(request, 'cross-transport');
-  const fromGrpc = await rpc.submit(request, 'cross-transport');
-  assert.equal(fromGrpc.id, fromHttp.id);
-  await assert.rejects(
-    rpc.submit({ ...request, scope: 'different' }, 'cross-transport'),
-    error => error.status === 409 && error.grpcCode === grpc.status.ABORTED,
-  );
-  const completed = await waitFor(rpc, fromGrpc.id);
-  assert.equal(completed.status, 'completed');
-  assert.equal((await httpClient.job(fromGrpc.id)).result.repository_id, completed.result.repository_id);
-
-  const blocker = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'blocker');
-  await waitFor(rpc, blocker.id, new Set(['running']));
-  const watched = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'watch' }, 'watched');
-  const lifecycle = await collect(rpc.watch(watched.id));
-  assert.deepEqual(lifecycle.map(event => event.job.status), ['queued', 'running', 'completed']);
-  assert.deepEqual(lifecycle.map(event => event.sequence), [1, 2, 3]);
-
-  const failed = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'fail' }, 'failed');
-  const failureEvents = await collect(rpc.watch(failed.id));
-  assert.equal(failureEvents.at(-1).job.status, 'failed');
-  assert.match(failureEvents.at(-1).job.error, /fixture knowledge failure/);
-
-  const cancellable = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'cancel-watch');
-  const controller = new AbortController();
-  const iterator = rpc.watch(cancellable.id, { signal: controller.signal })[Symbol.asyncIterator]();
-  const first = await iterator.next();
-  assert.equal(first.done, false);
-  controller.abort();
-  const afterAbort = await iterator.next();
-  assert.equal(afterAbort.done, true);
-  assert.equal((await waitFor(rpc, cancellable.id)).status, 'completed');
-
-  const deadlineJob = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'deadline-watch');
-  let deadlineError = null;
-  try {
-    await collect(rpc.watch(deadlineJob.id, { timeoutMs: 15 }));
-  } catch (error) {
-    deadlineError = error;
-  }
-  assert.ok(deadlineError);
-  assert.equal(deadlineError.grpcCode, grpc.status.DEADLINE_EXCEEDED);
-  assert.equal(deadlineError.status, 504);
-  assert.equal((await waitFor(rpc, deadlineJob.id)).status, 'completed');
-});

package/test/integration/local-fs.test.mjs

@@ -1,113 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, it, before, after } from 'node:test';
-import {
-  createLocalFilesystem,
-  createTempWorkspaceRoot,
-  LOCAL_FS_ENGINE,
-} from '../../src/local-fs/index.js';
-import { resolveContainedPath } from '../../src/local-fs/paths.js';
-
-describe('local-fs path containment', () => {
-  /** @type {string} */
-  let root;
-  before(() => {
-    root = createTempWorkspaceRoot();
-    fs.writeFileSync(path.join(root, 'ok.txt'), 'hello\n');
-    fs.mkdirSync(path.join(root, 'sub'));
-  });
-  after(() => {
-    fs.rmSync(root, { recursive: true, force: true });
-  });
-
-  it('resolves relative paths inside root', () => {
-    const r = resolveContainedPath(root, 'ok.txt');
-    assert.equal(r.ok, true);
-    assert.equal(r.rel, 'ok.txt');
-  });
-
-  it('rejects traversal', () => {
-    const r = resolveContainedPath(root, '../outside.txt');
-    assert.equal(r.ok, false);
-    assert.equal(r.code, 'path_escape');
-  });
-
-  it('rejects NUL', () => {
-    const r = resolveContainedPath(root, 'a\0b.txt');
-    assert.equal(r.ok, false);
-    assert.equal(r.code, 'invalid_path');
-  });
-
-  it('rejects symlink escape when possible', () => {
-    const outside = createTempWorkspaceRoot('agentsam-fs-out-');
-    try {
-      fs.writeFileSync(path.join(outside, 'secret.txt'), 'nope');
-      const link = path.join(root, 'escape-link');
-      try {
-        fs.symlinkSync(path.join(outside, 'secret.txt'), link);
-      } catch {
-        // Windows may lack symlink privilege — skip
-        return;
-      }
-      const r = resolveContainedPath(root, 'escape-link');
-      assert.equal(r.ok, false);
-      assert.equal(r.code, 'path_escape');
-    } finally {
-      fs.rmSync(outside, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('local-fs operations', () => {
-  /** @type {string} */
-  let root;
-  /** @type {ReturnType<typeof createLocalFilesystem>} */
-  let fsApi;
-
-  before(() => {
-    root = createTempWorkspaceRoot();
-    fsApi = createLocalFilesystem(root);
-  });
-  after(() => {
-    fs.rmSync(root, { recursive: true, force: true });
-  });
-
-  it('create / read / write with version conflict detection', () => {
-    assert.equal(fsApi.engine, LOCAL_FS_ENGINE);
-    const created = fsApi.create('README.md', '# one\n');
-    assert.equal(created.ok, true);
-    const v1 = created.version;
-
-    const read1 = fsApi.read('README.md');
-    assert.equal(read1.ok, true);
-    assert.equal(read1.content, '# one\n');
-    assert.equal(read1.version, v1);
-
-    const conflict = fsApi.write('README.md', '# stale\n', { expectedVersion: 'sha256:dead' });
-    assert.equal(conflict.ok, false);
-    assert.equal(conflict.code, 'version_conflict');
-
-    const wrote = fsApi.write('README.md', '# two\n', { expectedVersion: v1 });
-    assert.equal(wrote.ok, true);
-    assert.notEqual(wrote.version, v1);
-    assert.equal(fs.readFileSync(path.join(root, 'README.md'), 'utf8'), '# two\n');
-  });
-
-  it('list / rename / remove', () => {
-    fsApi.create('a.txt', 'a');
-    fsApi.mkdir('dir');
-    const listed = fsApi.list('.');
-    assert.equal(listed.ok, true);
-    assert.ok(listed.entries.some((e) => e.path === 'a.txt'));
-
-    const renamed = fsApi.rename('a.txt', 'b.txt');
-    assert.equal(renamed.ok, true);
-    assert.ok(fs.existsSync(path.join(root, 'b.txt')));
-    assert.equal(fs.existsSync(path.join(root, 'a.txt')), false);
-
-    const removed = fsApi.remove('b.txt');
-    assert.equal(removed.ok, true);
-    assert.equal(fs.existsSync(path.join(root, 'b.txt')), false);
-  });
-});

package/test/integration/local-provider-bridge.test.mjs

@@ -1,65 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { executeLocalProviderBridge } from '../../packages/agentsam-desktop-shell/scripts/local-provider-bridge.mjs';
-
-const CANARY = 'sk-test-CANARY-123456';
-
-function json(body, status = 200) {
-  return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
-}
-
-function openAiFetch(url, init = {}) {
-  assert.equal(init.headers?.authorization, `Bearer ${CANARY}`);
-  if (String(url).endsWith('/v1/models')) {
-    return Promise.resolve(json({ data: [{ id: 'gpt-5.6-sol', object: 'model' }] }));
-  }
-  if (String(url).endsWith('/v1/responses')) {
-    return Promise.resolve(json({
-      id: 'resp_local_fixture',
-      status: 'completed',
-      output_text: 'offline bridge works',
-      output: [],
-      usage: { input_tokens: 3, output_tokens: 4 },
-    }));
-  }
-  throw new Error(`unexpected_url:${url}`);
-}
-
-test('device OpenAI credential discovers live inventory without leaking the key', async () => {
-  const result = await executeLocalProviderBridge({
-    operation: 'inventory',
-    credentials: { openai: CANARY },
-  }, { fetchImpl: openAiFetch });
-  assert.equal(result.ok, true);
-  assert.equal(result.credential_plane, 'device_keychain');
-  assert.equal(result.providers.find((row) => row.id === 'openai')?.configured, true);
-  assert.equal(result.availableModels.some((row) => row.provider === 'openai' && row.model_id === 'gpt-5.6-sol'), true);
-  assert.equal(JSON.stringify(result).includes(CANARY), false);
-});
-
-test('device OpenAI credential chats through canonical Responses adapter without leaking the key', async () => {
-  const result = await executeLocalProviderBridge({
-    operation: 'chat',
-    provider: 'openai',
-    model_id: 'gpt-5.6-sol',
-    messages: [{ role: 'user', content: 'hello' }],
-    credentials: { openai: CANARY },
-  }, { fetchImpl: openAiFetch });
-  assert.deepEqual(result, {
-    ok: true,
-    provider: 'openai',
-    model_id: 'gpt-5.6-sol',
-    text: 'offline bridge works',
-  });
-  assert.equal(JSON.stringify(result).includes(CANARY), false);
-});
-
-test('provider rejection is sanitized and never echoes credential material', async () => {
-  const result = await executeLocalProviderBridge({
-    operation: 'inventory',
-    credentials: { openai: CANARY },
-  }, {
-    fetchImpl: async () => json({ error: { message: `bad ${CANARY}` } }, 401),
-  });
-  assert.equal(JSON.stringify(result).includes(CANARY), false);
-});

package/test/integration/local-studio-settings-production.test.mjs

@@ -1,40 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-
-function read(path) {
-  return readFileSync(new URL(`../../${path}`, import.meta.url), 'utf8');
-}
-
-const settingsPage = read('apps/local-studio/frontend/src/components/settings/LocalStudioSettingsPage.tsx');
-const settingsHost = read('apps/local-studio/frontend/src/components/settings/localStudioSettingsHost.ts');
-const shell = read('apps/local-studio/frontend/agentsam/AgentSamShell.tsx');
-const keysPage = read('apps/local-studio/frontend/src/components/settings/LiveKeysSettingsPage.tsx');
-const apiKeys = read('apps/local-studio/frontend/src/components/settings/ApiKeysTable.tsx');
-const settingsFrontend = read('packages/agentsam-settings/src/frontend/index.tsx');
-
-test('production Settings never mounts fixture data', () => {
-  assert.doesNotMatch(settingsPage, /createFixtureSettingsHost|getSettingsFixture|SettingsFixtureName/);
-  assert.doesNotMatch(settingsHost, /demo-app|Demo Org|health:\s*["']healthy["']/i);
-  assert.match(settingsHost, /repositoryLabel:\s*["']Not connected["']/);
-  assert.match(settingsHost, /browser:\s*["']Not checked["']/);
-  assert.match(settingsHost, /health:\s*["']unknown["']/);
-  assert.doesNotMatch(settingsFrontend, /demo-app|Demo Org/);
-});
-
-test('Settings route suppresses the outer application sidenav', () => {
-  assert.match(shell, /const isSettings = pathname === ['"]\/settings['"] \|\| pathname\.startsWith\(['"]\/settings\/['"]\)/);
-  assert.match(shell, /!isSettings \? <Nav\.Sidenav \/> : null/);
-});
-
-test('Keys page has a visible explicit AgentSam key trigger', () => {
-  assert.match(keysPage, /variant="secondary"/);
-  assert.match(keysPage, /Create AgentSam key/);
-});
-
-test('account provider rows show live discovery trust status', () => {
-  assert.match(apiKeys, /accountInventoryRequest/);
-  assert.match(apiKeys, /Connected · \$\{count\} model/);
-  assert.match(apiKeys, /rejected this key/);
-  assert.match(apiKeys, /Not selected/);
-});

package/test/integration/lockfile-sync.test.mjs

@@ -1,26 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
-
-test('every workspace and link path in package-lock.json exists on disk', () => {
-  const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
-  const paths = new Set();
-  for (const [key, value] of Object.entries(lock.packages)) {
-    if (key && !key.includes('node_modules/')) paths.add(key);
-    if (value.link && value.resolved) paths.add(value.resolved);
-  }
-  const missing = [...paths].filter((p) => !fs.existsSync(path.join(root, p)));
-  assert.deepEqual(missing, []);
-});
-
-test('package.json bin map matches package-lock packages[""].bin', () => {
-  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-  const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
-  const pkgBin = pkg.bin || {};
-  const lockBin = (lock.packages && lock.packages[''] && lock.packages[''].bin) || {};
-  assert.deepEqual(lockBin, pkgBin);
-});

package/test/integration/merkle-cli.test.mjs

@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const cli = fileURLToPath(new URL('../../src/cli.js', import.meta.url));
-
-async function fixture(t) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'agentsam-merkle-cli-test-'));
-  t.after(() => fs.rm(root, { recursive: true, force: true }));
-  return root;
-}
-
-async function write(root, name, content = name) {
-  await fs.mkdir(path.dirname(path.join(root, name)), { recursive: true });
-  await fs.writeFile(path.join(root, name), content);
-}
-
-function run(args, cwd) {
-  return spawnSync(process.execPath, [cli, 'merkle', ...args], {
-    cwd,
-    encoding: 'utf8',
-    timeout: 15000,
-  });
-}
-
-test('CLI snapshot/verify/diff supports JSON, moved roots, and distinct mismatch/error exit codes', async (t) => {
-  const root = await fixture(t), moved = await fixture(t);
-  await write(root, 'a.txt', 'hello');
-  await write(moved, 'a.txt', 'hello');
-
-  const saved = run(['snapshot', '.', '--json'], root);
-  assert.equal(saved.status, 0, saved.stderr);
-  const manifest = JSON.parse(saved.stdout);
-  assert.ok(manifest.output.endsWith('merkle.json'));
-
-  const matching = run(['verify', manifest.output, '--root', moved, '--json'], root);
-  assert.equal(matching.status, 0, matching.stderr);
-  assert.equal(JSON.parse(matching.stdout).equal, true);
-
-  await write(moved, 'a.txt', 'changed');
-  await write(moved, 'b.txt', 'new');
-  const changed = run(['verify', manifest.output, '--root', moved, '--json'], root);
-  assert.equal(changed.status, 1, changed.stderr);
-  assert.deepEqual(JSON.parse(changed.stdout).stats, { unchanged: 0, modified: 1, added: 1, removed: 0 });
-
-  const diff = run(['diff', root, moved, '--json'], root);
-  assert.equal(diff.status, 1, diff.stderr);
-
-  const invalid = run(['root', '.', '--typo', '--json'], root);
-  assert.equal(invalid.status, 2);
-  assert.equal(invalid.stdout, '');
-  assert.match(JSON.parse(invalid.stderr).error, /Unknown option/);
-
-  const piped = run(['inspect', '.', '--tui'], root);
-  assert.equal(piped.status, 0, piped.stderr);
-  assert.ok(!piped.stdout.includes('\x1b'));
-});

package/test/integration/merkle-persistence-identity.test.mjs

@@ -1,48 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { test } from 'node:test';
-import { resolveMerklePersistenceIdentity } from '../../src/commands/merkle-persist.js';
-
-async function gitFixture(t, remote = null) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'agentsam-merkle-identity-'));
-  t.after(() => fs.rm(root, { recursive: true, force: true }));
-  execFileSync('git', ['init', '-q', root]);
-  if (remote) execFileSync('git', ['-C', root, 'remote', 'add', 'origin', remote]);
-  return root;
-}
-
-test('Merkle persistence identity uses authenticated session + Git provider identity', async (t) => {
-  const root = await gitFixture(t, 'git@github.com:SamPrimeaux/agentsam-sdk.git');
-  const identity = resolveMerklePersistenceIdentity(root, {
-    session: { account_id: 'au_test' },
-    projectConfig: { repository: { id: 'local:should-not-win' } },
-  });
-  assert.deepEqual(identity, {
-    accountId: 'au_test',
-    repositoryId: 'github:samprimeaux/agentsam-sdk',
-    repositoryIdentitySource: 'git',
-  });
-});
-
-test('local repositories fall back to committed project identity', async (t) => {
-  const root = await gitFixture(t);
-  const identity = resolveMerklePersistenceIdentity(root, {
-    session: { account_id: 'au_test' },
-    projectConfig: { repository: { id: 'local:fixture-repository' } },
-  });
-  assert.equal(identity.repositoryId, 'local:fixture-repository');
-  assert.equal(identity.repositoryIdentitySource, 'project_manifest');
-});
-
-test('Merkle persistence refuses unauthenticated ownership', async (t) => {
-  const root = await gitFixture(t, 'https://github.com/SamPrimeaux/agentsam-sdk.git');
-  assert.throws(() => resolveMerklePersistenceIdentity(root, { session: null }), /agentsam_login_required_for_merkle_persistence/);
-});
-
-test('Merkle persistence CLI has no account/repository ownership env shortcuts', async () => {
-  const source = await fs.readFile(new URL('../../src/commands/merkle-persist.js', import.meta.url), 'utf8');
-  assert.doesNotMatch(source, /AGENTSAM_ACCOUNT_ID|AGENTSAM_REPOSITORY_ID|--account-id|--repository-id/);
-});