@inneranimalmedia/agentsam-sdk 2.4.1 → 2.6.0

package/test/merkle.test.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { buildMerkleTree, saveSnapshot, readSnapshot, validateSnapshot, diffTrees } from '../src/lib/merkle/index.js';
+import { buildMerkleTree, saveSnapshot, readSnapshot, validateSnapshot, diffTrees, metadataRoot } from '../src/lib/merkle/index.js';
 
 const cli = fileURLToPath(new URL('../src/cli.js', import.meta.url));
 async function fixture(t) {
@@ -60,6 +60,55 @@ test('default ignores, explicit dist inclusion, literal exclusions, and empty-di
   assert.equal(excluded.stats.files, 0);
 });
 
+test('semantic metadata adds package/system/category/mode and AST evidence without changing the content root', async (t) => {
+  const root = await fixture(t);
+  await write(root, 'package.json', JSON.stringify({ name: 'fixture-root', version: '1.0.0' }));
+  await write(root, 'packages/identity/package.json', JSON.stringify({
+    name: '@example/identity',
+    version: '1.0.0',
+    agentsam: { system: 'identity', kind: 'library', tags: ['authentication'] },
+  }));
+  await write(root, 'packages/identity/src/core/accounts.js', "import { helper } from '../shared/helper.js';\nexport function resolveAccount() { return helper; }\n");
+  await write(root, 'packages/identity/src/shared/helper.js', 'export const helper = 1;\n');
+  await fs.chmod(path.join(root, 'packages/identity/src/core/accounts.js'), 0o644);
+
+  const plain = await buildMerkleTree(root);
+  const enriched = await buildMerkleTree(root, { semantic: true });
+  assert.equal(enriched.rootHash, plain.rootHash);
+  assert.match(enriched.policyHash, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(enriched.policyHash, plain.policyHash);
+  assert.equal(enriched.version, 1);
+  assert.match(enriched.semantic.rootHash, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(enriched.semantic.classifier.format, 'agentsam-filemeta');
+  assert.equal(enriched.semantic.classifier.version, 1);
+
+  const accounts = enriched.semantic.entries.find((entry) => entry.path === 'packages/identity/src/core/accounts.js');
+  assert.equal(accounts.mode, 420);
+  assert.equal(accounts.package, '@example/identity');
+  assert.equal(accounts.package_root, 'packages/identity');
+  assert.equal(accounts.package_kind, 'library');
+  assert.equal(accounts.system, 'identity');
+  assert.equal(accounts.category, 'accounts');
+  assert.equal(accounts.layer, 'core');
+  assert.equal(accounts.kind, 'source');
+  assert.equal(accounts.language, 'javascript');
+  assert.equal(accounts.role, 'business-logic');
+  assert.deepEqual(accounts.tags, ['authentication']);
+  assert.deepEqual(accounts.symbols, ['resolveAccount']);
+  assert.deepEqual(accounts.imports, ['../shared/helper.js']);
+  assert.equal(accounts.ast.indexed, true);
+
+  const changedClassifier = { ...enriched.semantic.classifier, version: 2 };
+  assert.notEqual(metadataRoot(enriched.semantic.entries, changedClassifier), enriched.semantic.rootHash);
+
+  await fs.chmod(path.join(root, 'packages/identity/src/core/accounts.js'), 0o755);
+  const permissionOnly = await buildMerkleTree(root, { semantic: true });
+  const permissionRecord = permissionOnly.semantic.entries.find((entry) => entry.path === 'packages/identity/src/core/accounts.js');
+  assert.equal(permissionOnly.rootHash, plain.rootHash);
+  assert.equal(permissionRecord.mode, 493);
+  assert.notEqual(permissionOnly.semantic.rootHash, enriched.semantic.rootHash);
+});
+
 test('symlinks hash their literal target, including cycles, without reading the target', { skip: process.platform === 'win32' }, async (t) => {
   const root = await fixture(t), outside = await fixture(t);
   await write(outside, 'secret.txt', 'not read');
@@ -78,10 +127,14 @@ test('default and custom snapshots exclude themselves and preserve baseline unti
   const root = await fixture(t);
   await write(root, 'file.txt', 'baseline');
   const initial = await buildMerkleTree(root);
-  const { snapshot, output } = await saveSnapshot(root);
+  const { snapshot, output } = await saveSnapshot(root, { semantic: true });
   assert.equal(initial.rootHash, snapshot.rootHash);
+  assert.match(snapshot.semantic.rootHash, /^sha256:[a-f0-9]{64}$/);
   assert.ok(diffTrees(snapshot, await buildMerkleTree(root, { policy: snapshot.policy })).equal);
-  assert.equal((await readSnapshot(output)).rootHash, snapshot.rootHash);
+  const reloaded = await readSnapshot(output);
+  assert.equal(reloaded.rootHash, snapshot.rootHash);
+  assert.equal(reloaded.policyHash, snapshot.policyHash);
+  assert.equal(reloaded.semantic.rootHash, snapshot.semantic.rootHash);
   await assert.rejects(saveSnapshot(root), /exists/);
   await write(root, 'file.txt', 'edited');
   assert.equal(diffTrees(snapshot, await buildMerkleTree(root, { policy: snapshot.policy })).stats.modified, 1);
@@ -142,3 +195,24 @@ test('CLI snapshot/verify/diff supports JSON, moved roots, and distinct mismatch
   assert.equal(piped.status, 0, piped.stderr);
   assert.ok(!piped.stdout.includes('\x1b'));
 });
+
+test('semantic index records execution domains, environment access, and resolved local imports as Merkle-bound evidence', async (t) => {
+  const root = await fixture(t);
+  await write(root, 'package.json', JSON.stringify({ name: 'boundary-fixture', version: '1.0.0' }));
+  await write(root, 'frontend/client.ts', "import { contract } from '../shared/contract.ts';\nexport const api = import.meta.env.VITE_API_URL + contract;\n");
+  await write(root, 'shared/contract.ts', "export const contract = 'v1';\n");
+  await write(root, 'backend/private.ts', "export const key = process.env.API_KEY;\n");
+  const tree = await buildMerkleTree(root, { semantic: true });
+  const client = tree.semantic.entries.find((entry) => entry.path === 'frontend/client.ts');
+  const shared = tree.semantic.entries.find((entry) => entry.path === 'shared/contract.ts');
+  const backend = tree.semantic.entries.find((entry) => entry.path === 'backend/private.ts');
+  assert.equal(client.execution_domain, 'browser');
+  assert.equal(shared.execution_domain, 'shared');
+  assert.equal(backend.execution_domain, 'server');
+  assert.deepEqual(client.env_accesses, [{ source: 'import.meta.env', name: 'VITE_API_URL' }]);
+  assert.deepEqual(client.resolved_imports, [{ specifier: '../shared/contract.ts', target: 'shared/contract.ts' }]);
+  assert.deepEqual(backend.env_accesses, [{ source: 'process.env', name: 'API_KEY' }]);
+  assert.equal(tree.semantic.stats.by_execution_domain.browser, 1);
+  assert.equal(tree.semantic.stats.by_execution_domain.server, 1);
+  assert.equal(tree.semantic.classifier.trust_boundary, 'execution-domain-v1');
+});

package/test/model-catalog.test.mjs

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { calculateModelCost, getModelRecord } from '../src/models/index.js';
+
+test('Astra catalog separates technical window, reasoning controls, service tiers, and economics', () => {
+  const model = getModelRecord('gpt-6-astra');
+  assert.ok(model);
+  assert.equal(model.context_window, 1_050_000);
+  assert.equal(model.max_output_tokens, 128_000);
+  assert.deepEqual(model.reasoning_efforts, ['low', 'medium', 'high', 'xhigh', 'max']);
+  assert.deepEqual(model.service_tiers, ['default', 'fast', 'flex']);
+  assert.equal(model.context_policy.target_input_tokens, 120_000);
+  assert.equal(model.context_policy.compact_at_tokens, 180_000);
+  assert.equal(model.context_policy.max_normal_input_tokens, 250_000);
+  assert.equal(model.context_policy.pricing_threshold_tokens, 272_000);
+  assert.equal(model.batch.interactive, false);
+});
+
+test('cost calculation applies the long-context threshold to the full request only after crossing it', () => {
+  const atBoundary = calculateModelCost('gpt-6-astra', { input_tokens: 272_000, output_tokens: 10_000 });
+  assert.equal(atBoundary.threshold_applied, null);
+  assert.equal(atBoundary.rates_per_million.input, 10);
+  assert.equal(atBoundary.rates_per_million.output, 50);
+
+  const crossed = calculateModelCost('gpt-6-astra', { input_tokens: 272_001, output_tokens: 10_000 });
+  assert.equal(crossed.threshold_applied.input_tokens_gt, 272_000);
+  assert.equal(crossed.rates_per_million.input, 20);
+  assert.equal(crossed.rates_per_million.output, 75);
+  assert.ok(crossed.total_usd > atBoundary.total_usd);
+});
+
+test('service tier and cache pricing stay explicit rather than hidden in prompts', () => {
+  const usage = { input_tokens: 100_000, cached_input_tokens: 80_000, cache_write_tokens: 10_000, output_tokens: 20_000 };
+  const standard = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'default' });
+  const fast = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'fast' });
+  const flex = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'flex' });
+  const batch = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'batch' });
+  assert.equal(fast.total_usd, standard.total_usd * 2);
+  assert.equal(flex.total_usd, standard.total_usd * 0.5);
+  assert.equal(batch.total_usd, standard.total_usd * 0.5);
+  assert.equal(standard.rates_per_million.cached_input, 1);
+  assert.equal(standard.rates_per_million.cache_write, 12.5);
+});

package/test/models.test.mjs

@@ -0,0 +1,51 @@
+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 { collectModelsStatus, renderModelsStatus } from '../src/commands/models.js';
+
+function response(body, status = 200) {
+  return { ok: status >= 200 && status < 300, status, async json() { return body; } };
+}
+
+function tempHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-model-home-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  return home;
+}
+
+test('model inventory reports configured API providers without exposing credentials', async t => {
+  const home = tempHome(t);
+  const status = await collectModelsStatus({
+    home,
+    discoverRemote: false,
+    env: {
+      OPENAI_API_KEY: 'secret-openai', GEMINI_API_KEY: '', XAI_API_KEY: 'secret-xai', ANTHROPIC_API_KEY: 'secret-anthropic',
+      OLLAMA_BASE_URL: 'http://127.0.0.1:11434', OLLAMA_MODEL: 'qwen:test', OLLAMA_EMBED_MODEL: 'embed:test',
+    },
+    fetchImpl: async () => response({ models: [{ name: 'qwen:test' }, { name: 'embed:test' }] }),
+  });
+  assert.equal(status.providers.find((row) => row.id === 'openai').configured, true);
+  assert.equal(status.providers.find((row) => row.id === 'gemini').configured, false);
+  assert.equal(status.providers.find((row) => row.id === 'grok').configured, true);
+  assert.equal(status.providers.find((row) => row.id === 'anthropic').configured, true);
+  assert.equal(status.local.online, true);
+  assert.deepEqual(status.local.models.map((row) => row.name), ['qwen:test', 'embed:test']);
+  const rendered = renderModelsStatus(status);
+  assert.match(rendered, /OpenAI/);
+  assert.match(rendered, /qwen:test/);
+  assert.doesNotMatch(rendered, /secret-openai|secret-xai|secret-anthropic/);
+});
+
+test('exact hosted model availability is verified against the provider inventory', async () => {
+  const status = await collectModelsStatus({
+    env: { OPENAI_API_KEY: 'secret-openai', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
+    fetchImpl: async () => response({ models: [] }),
+    providerFetchImpl: async () => response({ data: [{ id: 'gpt-6-astra' }, { id: 'some-other-model' }] }),
+  });
+  assert.equal(status.discovery.openai.ok, true);
+  assert.equal(status.discovery.openai.returnedModelCount, 2);
+  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['gpt-6-astra']);
+  assert.equal(status.catalogModels[0].availability, 'available');
+});

package/test/npm10-lock.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lockPath = path.join(root, 'apps/local-studio/package-lock.json');
+
+describe('local-studio npm 10 lockfile', () => {
+  it('pins lru-cache@11.5.2 so Cloudflare npm ci can resolve it', () => {
+    const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    assert.equal(lock.lockfileVersion, 3);
+    const pkgs = lock.packages || {};
+    const hits = Object.entries(pkgs).filter(([key, meta]) => key.includes('lru-cache') && meta.version === '11.5.2');
+    assert.ok(hits.length >= 1, 'Missing: lru-cache@11.5.2 from lock file');
+    const [, meta] = hits[0];
+    assert.match(meta.resolved || '', /lru-cache-11\.5\.2\.tgz/);
+    assert.ok(meta.integrity);
+  });
+
+  it('verify-npm10-lock script exits 0 against the current lock', () => {
+    const script = path.join(root, 'apps/local-studio/scripts/verify-npm10-lock.mjs');
+    const r = spawnSync(process.execPath, [script], { encoding: 'utf8' });
+    assert.equal(r.status, 0, r.stderr || r.stdout);
+    assert.match(r.stdout, /lru-cache@11\.5\.2/);
+  });
+});

package/test/ollama.test.mjs

@@ -0,0 +1,94 @@
+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 {
+  OLLAMA_DEFAULTS,
+  ollamaInstallPlan,
+  parseOllamaArgs,
+  probeOllama,
+  resolveOllamaConfig,
+  updateProjectOllamaConfig,
+  upsertOllamaEnvFile,
+} from '../src/commands/ollama.js';
+import { createProjectManifest } from '../src/lib/project-config.js';
+
+test('Ollama defaults are local-only and match the SDK local-dev contract', () => {
+  assert.deepEqual(OLLAMA_DEFAULTS, {
+    baseUrl: 'http://127.0.0.1:11434',
+    model: 'qwen2.5-coder',
+    embedModel: 'mxbai-embed-large',
+  });
+  assert.deepEqual(resolveOllamaConfig({}, {}), OLLAMA_DEFAULTS);
+});
+
+test('Ollama setup args require explicit install/pull/start opt-ins', () => {
+  assert.deepEqual(parseOllamaArgs(['setup']), {
+    command: 'setup',
+    cwd: process.cwd(),
+    envFile: '',
+    baseUrl: '',
+    model: '',
+    embedModel: '',
+    install: false,
+    start: false,
+    pull: false,
+    json: false,
+  });
+  const opted = parseOllamaArgs(['setup', '--install', '--start', '--pull', '--json']);
+  assert.equal(opted.install, true);
+  assert.equal(opted.start, true);
+  assert.equal(opted.pull, true);
+  assert.equal(opted.json, true);
+});
+
+test('setup env writer updates only canonical OLLAMA keys and preserves other config', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ollama-'));
+  const envFile = path.join(root, '.env');
+  fs.writeFileSync(envFile, 'EXISTING=value\nOLLAMA_MODEL=old\n');
+  upsertOllamaEnvFile(envFile, OLLAMA_DEFAULTS);
+  const text = fs.readFileSync(envFile, 'utf8');
+  assert.match(text, /^EXISTING=value$/m);
+  assert.match(text, /^OLLAMA_BASE_URL=http:\/\/127\.0\.0\.1:11434$/m);
+  assert.match(text, /^OLLAMA_MODEL=qwen2\.5-coder$/m);
+  assert.match(text, /^OLLAMA_EMBED_MODEL=mxbai-embed-large$/m);
+  assert.equal((text.match(/^OLLAMA_MODEL=/gm) || []).length, 1);
+});
+
+test('project config records only portable Ollama capability metadata', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ollama-config-'));
+  fs.mkdirSync(path.join(root, '.agentsam'));
+  fs.writeFileSync(path.join(root, '.agentsam', 'config.json'), `${JSON.stringify(createProjectManifest({ projectName: 'demo', repositoryId: 'local:demo' }), null, 2)}\n`);
+  const filename = updateProjectOllamaConfig(root, OLLAMA_DEFAULTS);
+  const config = JSON.parse(fs.readFileSync(filename, 'utf8'));
+  assert.equal(config.models.local.provider, 'ollama');
+  assert.equal(config.models.local.base_url_env, 'OLLAMA_BASE_URL');
+  assert.equal(config.models.local.model_env, 'OLLAMA_MODEL');
+  assert.equal(config.models.local.embed_model_env, 'OLLAMA_EMBED_MODEL');
+  assert.equal(JSON.stringify(config).includes('127.0.0.1'), false);
+  assert.equal(JSON.stringify(config).includes('qwen2.5-coder'), false);
+  assert.equal(JSON.stringify(config).includes('token'), false);
+});
+
+test('status probe recognizes configured chat and embedding models', async () => {
+  const fakeFetch = async () => new Response(JSON.stringify({ models: [
+    { name: 'qwen2.5-coder:latest' },
+    { name: 'mxbai-embed-large:latest' },
+  ] }), { status: 200, headers: { 'content-type': 'application/json' } });
+  const status = await probeOllama(OLLAMA_DEFAULTS, fakeFetch);
+  assert.equal(status.online, true);
+  assert.equal(status.chat_ready, true);
+  assert.equal(status.embed_ready, true);
+});
+
+test('automatic install plans use local package managers, never a remote shell script', () => {
+  assert.deepEqual(ollamaInstallPlan('darwin', { brew: true }), {
+    command: 'brew', args: ['install', 'ollama'], manager: 'homebrew',
+  });
+  assert.equal(ollamaInstallPlan('linux', { brew: false }), null);
+  assert.equal(ollamaInstallPlan('darwin', { brew: false }), null);
+  const win = ollamaInstallPlan('win32', { winget: true });
+  assert.equal(win.command, 'winget');
+  assert.equal(win.args.includes('Ollama.Ollama'), true);
+});

package/test/openai-responses.test.mjs

@@ -0,0 +1,95 @@
+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 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');
+});

package/test/project-config.test.mjs

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,52 @@
+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, 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, '');
+});

package/test/rehydrate.test.mjs

@@ -0,0 +1,25 @@
+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/);
+});