@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.1

package/test/fixtures/knowledge-rpc-worker.mjs

@@ -0,0 +1,16 @@
+process.once('message', payload => {
+  const generation = payload?.request?.generation_id || null;
+  const delay = generation === 'slow' ? 180 : 20;
+  setTimeout(() => {
+    if (generation === 'fail') {
+      process.send?.({ ok: false, error: 'fixture knowledge failure' });
+    } else {
+      process.send?.({ ok: true, result: {
+        operation: payload?.request?.operation || null,
+        repository_id: payload?.config?.repository_id || null,
+        generation_id: generation,
+      } });
+    }
+    setTimeout(() => process.exit(0), 5);
+  }, delay);
+});

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

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+
+const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
+
+function run(...args) {
+  return spawnSync(process.execPath, ['src/cli.js', ...args], { cwd: repoRoot, encoding: 'utf8' });
+}
+
+test('agentsam help is concise, topic-aware, and deterministic outside a TTY', () => {
+  const help = run('help');
+  assert.equal(help.status, 0, help.stderr);
+  assert.doesNotMatch(help.stderr, /Unknown command/);
+  assert.match(help.stdout, /Agent Sam/);
+  assert.match(help.stdout, /Type normally to work with Agent Sam/);
+  assert.match(help.stdout, /agentsam help <topic>/);
+  assert.match(help.stdout, /press \/ for the command picker/i);
+  assert.doesNotMatch(help.stdout, /Inspect options:/);
+
+  const topic = run('help', 'runtime');
+  assert.equal(topic.status, 0, topic.stderr);
+  assert.match(topic.stdout, /Runtime \/ terminal/);
+  assert.match(topic.stdout, /agentsam connections/);
+  assert.match(topic.stdout, /agentsam deploy/);
+
+  const all = run('help', '--all');
+  assert.equal(all.status, 0, all.stderr);
+  assert.match(all.stdout, /Build \/ inspect/);
+  assert.match(all.stdout, /Create \/ extend/);
+
+  const flag = run('--help');
+  assert.equal(flag.status, 0, flag.stderr);
+  assert.match(flag.stdout, /agentsam help <topic>/);
+  assert.doesNotMatch(flag.stdout, /Inspect options:/);
+});

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

@@ -0,0 +1,112 @@
+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/merkle-cli.test.mjs

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

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

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

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

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

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

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

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