@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/test/openai-responses.test.mjs

@@ -1,155 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createOpenAIResponsesAdapter } from '../src/providers/index.js';
-
-function jsonResponse(body, status = 200) {
-  return { ok: status >= 200 && status < 300, status, async json() { return body; } };
-}
-
-test('Responses adapter sends reasoning/service tier without legacy sampling parameters and reconciles provider usage', async () => {
-  let request = null;
-  const events = [];
-  const adapter = createOpenAIResponsesAdapter({
-    apiKey: 'test-key',
-    emit: event => events.push(event),
-    fetchImpl: async (url, options) => {
-      request = { url, options, body: JSON.parse(options.body) };
-      return jsonResponse({
-        id: 'resp_test', status: 'completed', model: 'gpt-6-astra', service_tier: 'fast',
-        output: [{ type: 'message', content: [{ type: 'output_text', text: 'done' }] }],
-        usage: {
-          input_tokens: 100_000,
-          input_tokens_details: { cached_tokens: 80_000, cache_write_tokens: 10_000 },
-          output_tokens: 5_000,
-          output_tokens_details: { reasoning_tokens: 2_000 },
-        },
-      });
-    },
-  });
-  const result = await adapter.create({ model: 'gpt-6-astra', input: 'work', reasoningEffort: 'high', serviceTier: 'fast' });
-  assert.equal(request.url, 'https://api.openai.com/v1/responses');
-  assert.equal(request.body.reasoning.effort, 'high');
-  assert.equal(request.body.service_tier, 'fast');
-  assert.equal(request.body.truncation, 'disabled');
-  assert.equal('temperature' in request.body, false);
-  assert.equal('top_p' in request.body, false);
-  assert.equal(result.output_text, 'done');
-  assert.equal(result.usage_snapshot.current_context.input_tokens, 100_000);
-  assert.equal(result.usage_snapshot.current_context.window_tokens, 1_050_000);
-  assert.equal(result.actual_service_tier, 'fast');
-  assert.equal(result.cost.rates_per_million.input, 20);
-  assert.deepEqual(events.map(event => event.type), ['model.started', 'usage.snapshot', 'cost.snapshot', 'model.completed']);
-});
-
-test('Responses adapter carries hosted built-ins and function tools through /v1/responses with model capability checks', async () => {
-  let request = null;
-  const adapter = createOpenAIResponsesAdapter({
-    apiKey: 'test-key',
-    fetchImpl: async (url, options) => {
-      request = { url, body: JSON.parse(options.body) };
-      return jsonResponse({
-        id: 'resp_tools',
-        status: 'completed',
-        service_tier: 'default',
-        output: [{ type: 'message', content: [{ type: 'output_text', text: 'done' }] }],
-        usage: { input_tokens: 100, output_tokens: 10 },
-      });
-    },
-  });
-
-  await adapter.create({
-    model: 'gpt-6-luna',
-    input: 'research and summarize',
-    reasoningEffort: 'medium',
-    serviceTier: 'default',
-    tools: [
-      { type: 'web_search' },
-      { type: 'function', name: 'repository_snapshot', description: 'Snapshot repo', parameters: { type: 'object', properties: {} } },
-    ],
-  });
-
-  assert.equal(request.url, 'https://api.openai.com/v1/responses');
-  assert.equal(request.body.reasoning.effort, 'medium');
-  assert.deepEqual(request.body.tools[0], { type: 'web_search' });
-  assert.equal(request.body.tools[1].type, 'function');
-  assert.equal(request.body.tools[1].name, 'repository_snapshot');
-
-  await assert.rejects(
-    () => adapter.create({
-      model: 'gpt-5.3-codex',
-      input: 'search',
-      reasoningEffort: 'medium',
-      serviceTier: 'default',
-      tools: [{ type: 'web_search' }],
-    }),
-    /does not declare Responses tool support: web_search/,
-  );
-});
-
-test('Responses adapter preserves function call_id when returning tool output', async () => {
-  const bodies = [];
-  const adapter = createOpenAIResponsesAdapter({
-    apiKey: 'test-key',
-    fetchImpl: async (_url, options) => {
-      const body = JSON.parse(options.body);
-      bodies.push(body);
-      if (bodies.length === 1) {
-        return jsonResponse({
-          id: 'resp_calls', status: 'completed', service_tier: 'default',
-          output: [{ type: 'function_call', id: 'fc_1', call_id: 'call_abc', name: 'repository_snapshot', arguments: '{"depth":"quick"}', status: 'completed' }],
-          usage: { input_tokens: 100, output_tokens: 20 },
-        });
-      }
-      return jsonResponse({
-        id: 'resp_done', status: 'completed', service_tier: 'default',
-        output: [{ type: 'message', content: [{ type: 'output_text', text: 'complete' }] }],
-        usage: { input_tokens: 200, output_tokens: 30 },
-      });
-    },
-  });
-  const first = await adapter.create({
-    model: 'gpt-6-astra', input: 'inspect', reasoningEffort: 'low', serviceTier: 'default',
-    tools: [{ type: 'function', name: 'repository_snapshot', description: 'Snapshot repo', parameters: { type: 'object', properties: {} } }],
-  });
-  assert.equal(first.tool_calls[0].call_id, 'call_abc');
-  const second = await adapter.continueWithToolOutputs({
-    model: 'gpt-6-astra', previousResponseId: first.response_id, reasoningEffort: 'low', serviceTier: 'default',
-    toolOutputs: [{ call_id: first.tool_calls[0].call_id, output: { ok: true } }],
-  });
-  assert.equal(bodies[1].previous_response_id, 'resp_calls');
-  assert.deepEqual(bodies[1].input, [{ type: 'function_call_output', call_id: 'call_abc', output: '{"ok":true}' }]);
-  assert.equal(second.output_text, 'complete');
-});
-
-test('compaction is an explicit provider operation and has no arbitrary default wall-clock timeout', async () => {
-  let signal = 'unset';
-  let body = null;
-  const adapter = createOpenAIResponsesAdapter({
-    apiKey: 'test-key',
-    fetchImpl: async (url, options) => {
-      assert.equal(url, 'https://api.openai.com/v1/responses/compact');
-      signal = options.signal;
-      body = JSON.parse(options.body);
-      return jsonResponse({ id: 'cmp_1', object: 'response.compaction', output: [{ type: 'compaction', encrypted_content: 'opaque' }], usage: { input_tokens: 1_000, output_tokens: 100 } });
-    },
-  });
-  const compacted = await adapter.compact({ model: 'gpt-6-astra', previousResponseId: 'resp_previous' });
-  assert.equal(signal, undefined);
-  assert.equal(body.previous_response_id, 'resp_previous');
-  assert.equal(compacted.compaction_id, 'cmp_1');
-});
-
-test('OpenAI server-side compaction uses canonical policy and honors disable with previous_response_id', async () => {
-  const { getModelRecord } = await import('../src/models/index.js');
-  const bodies = [];
-  const adapter = createOpenAIResponsesAdapter({ apiKey: 'test', fetchImpl: async (_, init) => {
-    bodies.push(JSON.parse(init.body));
-    return jsonResponse({ id: 'resp_1', output: [], usage: {} });
-  } });
-  await adapter.create({ model: 'gpt-6-astra', previousResponseId: 'resp_previous', input: 'new message' });
-  assert.deepEqual(bodies[0].context_management, [{ type: 'compaction', compact_threshold: getModelRecord('gpt-6-astra').context_policy.compact_at_tokens }]);
-  assert.equal(bodies[0].input, 'new message');
-  assert.equal(bodies[0].previous_response_id, 'resp_previous');
-  await adapter.create({ model: 'gpt-6-astra', input: 'test', autoCompact: false });
-  assert.equal(bodies[1].context_management, undefined);
-});

package/test/portable-context.test.mjs

@@ -1,94 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, realpathSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  normalizeGitRemote,
-  resolveGitContext,
-} from '../packages/agentsam-repository/src/git-context.js';
-import {
-  buildBridgeHeaders,
-  createBridgeClient,
-  resolveAgentSamBaseUrl,
-} from '../src/lib/bridge-client.js';
-import { buildContextReport } from '../src/commands/context.js';
-
-test('normalizeGitRemote handles HTTPS and SSH GitHub remotes', () => {
-  assert.equal(normalizeGitRemote('https://github.com/SamPrimeaux/agentsam-sdk.git').repoFullName, 'SamPrimeaux/agentsam-sdk');
-  assert.equal(normalizeGitRemote('git@github.com:SamPrimeaux/AgentSamRemix.git').repoFullName, 'SamPrimeaux/AgentSamRemix');
-});
-
-test('resolveGitContext derives repository identity from Git without user/workspace env', () => {
-  const root = mkdtempSync(join(tmpdir(), 'agentsam-sdk-git-'));
-  execFileSync('git', ['init'], { cwd: root, stdio: 'ignore' });
-  execFileSync('git', ['config', 'user.email', 'sdk-test@example.com'], { cwd: root });
-  execFileSync('git', ['config', 'user.name', 'SDK Test'], { cwd: root });
-  execFileSync('git', ['remote', 'add', 'origin', 'git@github.com:SamPrimeaux/example-repo.git'], { cwd: root });
-  writeFileSync(join(root, 'README.md'), '# test\n');
-  execFileSync('git', ['add', 'README.md'], { cwd: root });
-  execFileSync('git', ['commit', '-m', 'test'], { cwd: root, stdio: 'ignore' });
-
-  const ctx = resolveGitContext({ cwd: root });
-  assert.equal(ctx.repoFullName, 'SamPrimeaux/example-repo');
-  assert.match(ctx.revisionSha, /^[0-9a-f]{40}$/);
-  assert.equal(ctx.dirty, false);
-  assert.equal('workspaceId' in ctx, false);
-  assert.equal('userId' in ctx, false);
-});
-
-test('resolveGitContext supports an initialized repository before its first commit', () => {
-  const root = mkdtempSync(join(tmpdir(), 'agentsam-sdk-unborn-'));
-  execFileSync('git', ['init'], { cwd: root, stdio: 'ignore' });
-  writeFileSync(join(root, 'README.md'), '# unborn\n');
-  const ctx = resolveGitContext({ cwd: root });
-  assert.equal(ctx.root, realpathSync(root));
-  assert.equal(ctx.revisionSha, null);
-  assert.equal(ctx.dirty, true);
-});
-
-test('bridge headers authenticate only the machine principal', () => {
-  const headers = buildBridgeHeaders({
-    env: {
-      AGENTSAM_BRIDGE_KEY: 'bridge_test_key',
-      AGENTSAM_USER_ID: 'should-not-leak',
-      AGENTSAM_WORKSPACE_ID: 'should-not-leak',
-    },
-  });
-  assert.equal(headers.Authorization, 'Bearer bridge_test_key');
-  assert.equal(headers['X-Bridge-Key'], 'bridge_test_key');
-  assert.equal(Object.values(headers).includes('should-not-leak'), false);
-});
-
-test('bridge client uses shared service principal and explicit base URL', async () => {
-  let observed;
-  const client = createBridgeClient({
-    baseUrl: 'https://agent.example.test/',
-    key: 'bridge_test_key',
-    fetchImpl: async (url, options) => {
-      observed = { url, options };
-      return new Response(JSON.stringify({ ok: true }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    },
-  });
-
-  assert.deepEqual(await client.post('/api/proof', { repo: 'SamPrimeaux/example-repo' }), { ok: true });
-  assert.equal(observed.url, 'https://agent.example.test/api/proof');
-  assert.equal(observed.options.headers['X-Bridge-Key'], 'bridge_test_key');
-  assert.deepEqual(JSON.parse(observed.options.body), { repo: 'SamPrimeaux/example-repo' });
-});
-
-test('context report exposes repo facts and bridge readiness without secret value', () => {
-  const report = buildContextReport({
-    cwd: process.cwd(),
-    env: { AGENTSAM_BRIDGE_KEY: 'super-secret', AGENTSAM_BASE_URL: 'https://example.test' },
-  });
-  assert.equal(report.bridge.configured, true);
-  assert.equal(report.bridge.baseUrl, 'https://example.test');
-  assert.equal(JSON.stringify(report).includes('super-secret'), false);
-  assert.equal(resolveAgentSamBaseUrl({}), 'https://inneranimalmedia.com');
-});

package/test/project-config.test.mjs

@@ -1,81 +0,0 @@
-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 test from 'node:test';
-import {
-  createProjectManifest,
-  getDefaultProfile,
-  getDefaultRuntime,
-  getDeployTarget,
-  getLocalDatabasePath,
-  getProjectName,
-  getProjectPreset,
-  getProjectRulesPath,
-  getRepositoryId,
-  portableRepositoryIdFromGit,
-} from '../src/lib/project-config.js';
-
-function git(cwd, args) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-}
-
-test('portable project manifest is small and excludes runtime/account history', () => {
-  const config = createProjectManifest({
-    projectName: 'demo',
-    preset: 'cms',
-    profile: 'cms',
-    runTarget: 'local',
-    sdkVersion: '2.5.0',
-    repositoryId: 'github:owner/demo',
-  });
-
-  assert.equal(config.schema_version, 2);
-  assert.deepEqual(config.project, { name: 'demo' });
-  assert.equal(config.repository.id, 'github:owner/demo');
-  assert.equal(config.product.preset, 'cms');
-  assert.equal(config.defaults.profile, 'cms');
-  assert.equal(config.defaults.runtime, 'local');
-  assert.equal(config.defaults.model, 'auto');
-  assert.deepEqual(config.merkle, { enabled: true, semantic: true, persistence: 'auto' });
-  assert.equal(config.rules.file, '.agentsamrules');
-  assert.equal(getProjectRulesPath(config), '.agentsamrules');
-  assert.equal(config.knowledge.config, '.agentsam/knowledge.json');
-  assert.equal(config.local.database, '.agentsam/data/agentsam.sqlite');
-
-  const forbidden = [
-    'account_id', 'user_id', 'tenant_id', 'workspace_id', 'current_run_id', 'plan_id', 'task_id',
-    'connection_id', 'runtime_lease_id', 'latest_merkle_root', 'root_hash', 'model_history',
-    'subagent_runs', 'pty_port', 'dev_port', 'deployed_at', 'cloudflare',
-  ];
-  const serialized = JSON.stringify(config);
-  for (const field of forbidden) assert.equal(serialized.includes(`"${field}"`), false, field);
-});
-
-test('project config accessors keep legacy flat projects readable during migration', () => {
-  const legacy = {
-    project: 'legacy-demo',
-    lane: 'data',
-    agent: 'data',
-    run_target: 'local',
-    deploy_target: 'gcp',
-    db_path: '.agentsam/old.sqlite',
-  };
-  assert.equal(getProjectName(legacy), 'legacy-demo');
-  assert.equal(getProjectPreset(legacy), 'data');
-  assert.equal(getDefaultProfile(legacy), 'data');
-  assert.equal(getDefaultRuntime(legacy), 'local');
-  assert.equal(getDeployTarget(legacy), 'gcp');
-  assert.equal(getLocalDatabasePath(legacy), '.agentsam/old.sqlite');
-  assert.equal(getRepositoryId(legacy), null);
-  assert.equal(getProjectRulesPath(legacy), '.agentsamrules');
-});
-
-test('GitHub remote becomes portable repository identity when adopting an existing repo', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-project-config-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  git(root, ['init', '-q']);
-  git(root, ['remote', 'add', 'origin', 'git@github.com:ExampleOrg/DemoRepo.git']);
-  assert.equal(portableRepositoryIdFromGit(root), 'github:exampleorg/demorepo');
-});

package/test/project-rules.test.mjs

@@ -1,44 +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 { defaultProjectRules, findProjectRules, loadProjectRules } from '../src/lib/project-rules.js';
-
-test('.agentsamrules behaves like a committed repo-level instruction file', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-rules-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const nested = path.join(root, 'src', 'nested');
-  fs.mkdirSync(nested, { recursive: true });
-  const content = defaultProjectRules('demo');
-  fs.writeFileSync(path.join(root, '.agentsamrules'), content);
-
-  assert.equal(findProjectRules(nested), path.join(root, '.agentsamrules'));
-  const loaded = loadProjectRules(nested);
-  assert.equal(loaded.found, true);
-  assert.equal(loaded.content, content);
-  assert.match(loaded.hash, /^sha256:[a-f0-9]{64}$/);
-  assert.equal(loaded.truncated, false);
-});
-
-test('project rules are deterministically bounded before entering context', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-rules-bound-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  fs.writeFileSync(path.join(root, '.agentsamrules'), 'x'.repeat(200));
-  const loaded = loadProjectRules(root, { maxChars: 40 });
-  assert.equal(loaded.chars, 40);
-  assert.equal(loaded.source_chars, 200);
-  assert.equal(loaded.truncated, true);
-});
-
-
-test('project rules discovery never leaks across the repository boundary', t => {
-  const parent = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-rules-boundary-'));
-  t.after(() => fs.rmSync(parent, { recursive: true, force: true }));
-  fs.writeFileSync(path.join(parent, '.agentsamrules'), 'parent rules\n');
-  const repo = path.join(parent, 'repo');
-  const nested = path.join(repo, 'src');
-  fs.mkdirSync(path.join(repo, '.git'), { recursive: true });
-  fs.mkdirSync(nested, { recursive: true });
-  assert.equal(findProjectRules(nested), null);
-});

package/test/provider-credentials.test.mjs

@@ -1,106 +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 { describeProviderCredential, ensureProviderEnvProfile, resolveProviderCredential } from '../src/lib/provider-credentials.js';
-
-function fixtureHome(t) {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-credentials-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  fs.mkdirSync(path.join(home, '.agentsam', 'env.d'), { recursive: true });
-  return home;
-}
-
-test('provider credential resolver loads a secure AgentSam env file without exposing it in status', t => {
-  const home = fixtureHome(t);
-  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
-  fs.writeFileSync(filename, 'export OPENAI_API_KEY="secret-from-file"\n', { mode: 0o600 });
-  if (process.platform !== 'win32') fs.chmodSync(filename, 0o600);
-
-  const resolved = resolveProviderCredential('openai', { env: {}, home });
-  assert.equal(resolved.configured, true);
-  assert.equal(resolved.source, 'agentsam_env_file');
-  assert.equal(resolved.value, 'secret-from-file');
-
-  const safe = describeProviderCredential('openai', { env: {}, home });
-  assert.equal(safe.configured, true);
-  assert.equal(safe.source, 'agentsam_env_file');
-  assert.equal(Object.hasOwn(safe, 'value'), false);
-  assert.doesNotMatch(JSON.stringify(safe), /secret-from-file/);
-});
-
-test('environment credential wins over disk fallback', t => {
-  const home = fixtureHome(t);
-  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
-  fs.writeFileSync(filename, 'OPENAI_API_KEY=file-value\n', { mode: 0o600 });
-  if (process.platform !== 'win32') fs.chmodSync(filename, 0o600);
-  const resolved = resolveProviderCredential('openai', { env: { OPENAI_API_KEY: 'env-value' }, home });
-  assert.equal(resolved.source, 'environment');
-  assert.equal(resolved.value, 'env-value');
-});
-
-test('AgentSam refuses provider credential files with broad POSIX permissions', { skip: process.platform === 'win32' }, t => {
-  const home = fixtureHome(t);
-  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
-  fs.writeFileSync(filename, 'OPENAI_API_KEY=unsafe-value\n', { mode: 0o644 });
-  fs.chmodSync(filename, 0o644);
-  const resolved = resolveProviderCredential('openai', { env: {}, home });
-  assert.equal(resolved.configured, false);
-  assert.equal(resolved.error, 'permissions_too_open');
-  assert.equal(resolved.value, '');
-});
-
-
-test('provider env profiles create a secure reusable source loader without embedding secrets', { skip: process.platform === 'win32' }, t => {
-  const home = fixtureHome(t);
-  const openai = ensureProviderEnvProfile('openai', { home });
-  assert.equal(openai.source_command, 'source ~/.agentsam/load-agent-env.sh openai');
-  assert.equal(fs.statSync(openai.file).mode & 0o777, 0o600);
-  assert.equal(fs.statSync(openai.loader).mode & 0o777, 0o700);
-  assert.match(fs.readFileSync(openai.file, 'utf8'), /OPENAI_API_KEY=""/);
-  assert.doesNotMatch(fs.readFileSync(openai.loader, 'utf8'), /sk-|secret-/);
-
-  const cloudflare = ensureProviderEnvProfile('cloudflare', { home });
-  const source = fs.readFileSync(cloudflare.file, 'utf8');
-  assert.match(source, /CLOUDFLARE_ACCOUNT_ID=""/);
-  assert.match(source, /CLOUDFLARE_API_TOKEN=""/);
-});
-
-test('Cloudflare credential identity never falls back to generic ACCOUNT_ID', t => {
-  const home = fixtureHome(t);
-  const resolved = resolveProviderCredential('cloudflare', {
-    env: { CLOUDFLARE_API_TOKEN: 'token-secret', ACCOUNT_ID: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
-    home,
-  });
-  assert.equal(resolved.configured, true);
-  assert.equal(resolved.account_id, null);
-});
-
-test('Cloudflare credential status carries non-secret account identity from the provider profile', t => {
-  const home = fixtureHome(t);
-  const profile = path.join(home, '.agentsam', 'env.d', 'cloudflare.env');
-  fs.writeFileSync(profile, 'export CLOUDFLARE_ACCOUNT_ID="0123456789abcdef0123456789abcdef"\nexport CLOUDFLARE_API_TOKEN="token-secret"\n', { mode: 0o600 });
-  if (process.platform !== 'win32') fs.chmodSync(profile, 0o600);
-  const resolved = resolveProviderCredential('cloudflare', { env: {}, home });
-  assert.equal(resolved.account_id, '0123456789abcdef0123456789abcdef');
-  const safe = describeProviderCredential('cloudflare', { env: {}, home });
-  assert.equal(safe.account_id, '0123456789abcdef0123456789abcdef');
-  assert.doesNotMatch(JSON.stringify(safe), /token-secret/);
-});
-
-
-test('Cloudflare profile account backfill never overwrites an existing token or account choice', t => {
-  const home = fixtureHome(t);
-  const profile = path.join(home, '.agentsam', 'env.d', 'cloudflare.env');
-  fs.writeFileSync(profile, 'export CLOUDFLARE_ACCOUNT_ID=""\nexport CLOUDFLARE_API_TOKEN="keep-me"\n', { mode: 0o600 });
-  ensureProviderEnvProfile('cloudflare', { home, accountId: '11111111111111111111111111111111' });
-  let source = fs.readFileSync(profile, 'utf8');
-  assert.match(source, /CLOUDFLARE_ACCOUNT_ID="11111111111111111111111111111111"/);
-  assert.match(source, /CLOUDFLARE_API_TOKEN="keep-me"/);
-
-  ensureProviderEnvProfile('cloudflare', { home, accountId: '22222222222222222222222222222222' });
-  source = fs.readFileSync(profile, 'utf8');
-  assert.match(source, /CLOUDFLARE_ACCOUNT_ID="11111111111111111111111111111111"/);
-  assert.doesNotMatch(source, /22222222222222222222222222222222/);
-});

package/test/rehydrate.test.mjs

@@ -1,25 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import test from 'node:test';
-import { compactConsumedToolResult, rehydrateContextRef } from '../src/context/index.js';
-
-const sha = value => `sha256:${createHash('sha256').update(value).digest('hex')}`;
-
-test('large consumed evidence can leave active context and later rehydrate by stable ref/hash', async () => {
-  const source = 'important evidence '.repeat(800);
-  const ref = 'tool:call_123';
-  const digest = sha(source);
-  const compacted = compactConsumedToolResult(source, { ref, hash: digest });
-  assert.equal(compacted.compacted, true);
-  assert.equal(compacted.chars, 4_000);
-  assert.equal(compacted.source_chars, source.length);
-  const adapter = { async read(requested) { assert.equal(requested, ref); return { content: source, hash: digest, kind: 'tool_result' }; } };
-  const restored = await rehydrateContextRef(ref, adapter, { expectedHash: digest, kind: 'tool_result', maxChars: 64_000 });
-  assert.equal(restored.content, source);
-  assert.equal(restored.hash, digest);
-  assert.equal(restored.truncated, false);
-});
-
-test('rehydration fails closed when stable source hash changed', async () => {
-  await assert.rejects(() => rehydrateContextRef('file:x', async () => ({ content: 'changed' }), { expectedHash: sha('original') }), /rehydration_hash_mismatch/);
-});

package/test/release-hygiene.test.mjs

@@ -1,42 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-const root = path.resolve(import.meta.dirname, '..');
-const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
-
-test('release candidate metadata and public terminal vocabulary are aligned', () => {
-  const pkg = JSON.parse(read('package.json'));
-  const manifest = read('agentsam.yaml');
-  const readme = read('README.md');
-  const escapedVersion = pkg.version.replaceAll('.', '\\.');
-
-  assert.match(
-    manifest,
-    new RegExp(`packages:[\\s\\S]*?root_sdk:[\\s\\S]*?version: "${escapedVersion}"`),
-  );
-  assert.match(
-    manifest,
-    new RegExp(`release:[\\s\\S]*?root_sdk:[\\s\\S]*?target_version: "${escapedVersion}"`),
-  );
-  assert.match(manifest, /state: (candidate|published)/);
-  assert.match(manifest, /current_latest: "\d+\.\d+\.\d+"/);
-  assert.match(manifest, /verification_command: npm run verify:release/);
-  assert.doesNotMatch(manifest, /^\s*- tui\s*$/m);
-  assert.doesNotMatch(readme, /agentsam tui|CLI\/TUI/);
-});
-
-test('dead branded splash paths are gone and UI preview stays dev-only', () => {
-  for (const rel of ['src/ui/splash.js', 'src/ui/splash-xterm.js', 'src/commands/tui.js']) {
-    assert.equal(fs.existsSync(path.join(root, rel)), false, `${rel} should not ship`);
-  }
-  for (const rel of ['scripts/internal/ui-preview-runner.mjs', 'scripts/internal/ansi-ui-preview.mjs']) {
-    assert.equal(fs.existsSync(path.join(root, rel)), true, `${rel} should remain available to contributors`);
-  }
-  assert.equal(fs.existsSync(path.join(root, 'src/ui/runtime-activity.js')), true, 'automatic runtime activity must ship with the product CLI');
-
-  const pkg = JSON.parse(read('package.json'));
-  assert.ok(pkg.files.includes('skills'));
-  assert.equal(pkg.files.includes('scripts'), false, 'internal preview scripts must not be published');
-});