@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.1

package/test/local-studio-deploy.test.mjs

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import {
+  DEPLOY_INPUT_GLOBS,
+  loadOptionalCloudflareEnv,
+  resolveLocalStudioDeployable,
+  wranglerDeployCommand,
+  isLocalStudioCheckout,
+  runLocalStudioDeploy,
+} from '../src/lib/deploy/local-studio.js';
+import { productionDeployBlockedReason } from '../src/lib/deploy/git-guard.js';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+describe('local-studio deploy resolver', () => {
+  it('resolves apps/local-studio + backend/wrangler.jsonc from the repo', () => {
+    const target = resolveLocalStudioDeployable(root);
+    assert.equal(target.provider, 'cloudflare');
+    assert.equal(target.app, 'local-studio');
+    assert.equal(path.basename(path.dirname(target.wranglerConfig)), 'backend');
+    assert.deepEqual(target.wranglerArgs, ['deploy', '-c', 'backend/wrangler.jsonc']);
+    assert.equal(isLocalStudioCheckout(root), true);
+    const cmd = wranglerDeployCommand(target, { dryRun: true });
+    assert.equal(cmd.bin, 'npx');
+    assert.equal(cmd.cwd, target.appRoot);
+    assert.deepEqual(cmd.args, ['wrangler', 'deploy', '-c', 'backend/wrangler.jsonc', '--dry-run']);
+  });
+
+  it('fingerprints the cloudflare connector package', () => {
+    assert.equal(DEPLOY_INPUT_GLOBS.includes('packages/connectors/cloudflare'), true);
+    assert.equal(DEPLOY_INPUT_GLOBS.includes('apps/local-studio'), true);
+  });
+
+  it('treats missing .env.cloudflare as optional', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cf-env-'));
+    const loaded = loadOptionalCloudflareEnv(tmp);
+    assert.equal(loaded.loaded, false);
+    assert.deepEqual(loaded.vars, {});
+  });
+
+  it('plan does not invoke wrangler', async () => {
+    const result = await runLocalStudioDeploy({ cwd: root, planOnly: true, execute: false });
+    assert.equal(result.plan.provider, 'cloudflare');
+    assert.equal(result.plan.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
+    assert.equal(result.plan.genericRootDeploy, false);
+    assert.equal(result.receipt.plan, true);
+    assert.equal(result.receipt.promoted, false);
+    assert.equal(result.receipt.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
+    assert.equal(result.receipt.hostname, 'agentsam.inneranimalmedia.com');
+  });
+
+  it('blocks production deploys from feat branches', () => {
+    const reason = productionDeployBlockedReason({
+      ok: true,
+      branch: 'feat/cloudflare-connector-deploy-control',
+      detached: false,
+      head: 'aaa',
+      originMain: 'aaa',
+      dirty: false,
+      tmpCheckout: false,
+      repoRoot: root,
+    });
+    assert.match(reason, /feat\/cloudflare-connector-deploy-control/);
+  });
+
+  it('allows production only when HEAD is a clean origin/main', () => {
+    const reason = productionDeployBlockedReason({
+      ok: true,
+      branch: 'main',
+      detached: false,
+      head: 'abc',
+      originMain: 'abc',
+      dirty: false,
+      tmpCheckout: false,
+      repoRoot: root,
+    });
+    assert.equal(reason, null);
+  });
+});

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

@@ -1,37 +1,148 @@
 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; },
-  };
+  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 () => {
+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',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-      OLLAMA_MODEL: 'qwen:test',
-      OLLAMA_EMBED_MODEL: 'embed:test',
+      OPENAI_API_KEY: 'secret-openai', GEMINI_API_KEY: '', XAI_API_KEY: 'secret-xai', ANTHROPIC_API_KEY: 'secret-anthropic', CLOUDFLARE_API_TOKEN: 'secret-cf', ACCOUNT_ID: '33333333333333333333333333333333',
+      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.providers.find((row) => row.id === 'cloudflare').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/);
+  assert.doesNotMatch(rendered, /secret-openai|secret-xai|secret-anthropic|secret-cf/);
+});
+
+test('static/reference metadata never invents hosted model availability', 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: 'some-other-model' }] }),
+  });
+
+  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['some-other-model']);
+  const referenceOnly = status.catalogModels.find((row) => row.provider_model_id === 'gpt-6-astra');
+  assert.equal(referenceOnly?.availability, 'unverified');
+  assert.equal(referenceOnly?.availability_source, 'sdk_reference');
+});
+
+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', 'some-other-model']);
+  assert.equal(status.availableModels[0].availability_source, 'provider_api');
+  assert.equal(status.availableModels[0].context_window_source, 'sdk_reference');
+});
+
+
+
+
+test('Gemini and xAI discovery keep per-key limits from provider metadata', async () => {
+  const seen = [];
+  const status = await collectModelsStatus({
+    env: {
+      GEMINI_API_KEY: 'gem-key',
+      XAI_API_KEY: 'xai-key',
+      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
+    },
+    fetchImpl: async () => response({ models: [] }),
+    providerFetchImpl: async (url, options) => {
+      seen.push(url);
+      if (url.includes('generativelanguage.googleapis.com')) {
+        return response({ models: [{
+          name: 'models/gemini-test',
+          baseModelId: 'gemini-test',
+          displayName: 'Gemini Test',
+          inputTokenLimit: 123456,
+          outputTokenLimit: 8192,
+          supportedGenerationMethods: ['generateContent'],
+          thinking: true,
+        }] });
+      }
+      if (url.includes('api.x.ai')) {
+        return response({ data: [{
+          id: 'grok-test',
+          context_length: 256000,
+          prompt_text_token_price: 1000,
+          cached_prompt_text_token_price: 500,
+          completion_text_token_price: 4000,
+        }] });
+      }
+      throw new Error('unexpected URL ' + url);
+    },
+  });
+
+  const gemini = status.providerModels.gemini[0];
+  assert.equal(gemini.provider_model_id, 'gemini-test');
+  assert.equal(gemini.context_window, 123456);
+  assert.equal(gemini.context_window_source, 'provider_api');
+  assert.deepEqual(gemini.reasoning_efforts, ['auto', 'low', 'medium', 'high']);
+
+  const grok = status.providerModels.grok[0];
+  assert.equal(grok.provider_model_id, 'grok-test');
+  assert.equal(grok.context_window, 256000);
+  assert.equal(grok.pricing.input, 1);
+  assert.equal(grok.pricing.output, 4);
+  assert.equal(seen.some((url) => url.includes('generativelanguage.googleapis.com')), true);
+  assert.equal(seen.some((url) => url.includes('api.x.ai')), true);
+});
+
+
+test('Cloudflare discovery is scoped to the loaded account and surfaces text-generation models only', async t => {
+  const seen = [];
+  const home = tempHome(t);
+  const status = await collectModelsStatus({
+    home,
+    env: { CLOUDFLARE_API_TOKEN: 'secret-cf', ACCOUNT_ID: '44444444444444444444444444444444', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
+    fetchImpl: async () => response({ models: [] }),
+    providerFetchImpl: async (url, options) => {
+      seen.push({ url, auth: options.headers.authorization });
+      return response({ success: true, result: [
+        { name: '@cf/qwen/code', task: { name: 'Text Generation' }, description: 'coding' },
+        { name: '@cf/baai/embed', task: { name: 'Text Embeddings' }, description: 'embeddings' },
+      ] });
+    },
+  });
+  assert.equal(seen.length, 1);
+  assert.match(seen[0].url, /accounts\/44444444444444444444444444444444\/ai\/models\/search$/);
+  assert.equal(status.discovery.cloudflare.ok, true);
+  assert.equal(status.discovery.cloudflare.returnedModelCount, 1);
+  assert.deepEqual(status.providerModels.cloudflare.map((row) => row.provider_model_id), ['@cf/qwen/code']);
+  assert.equal(status.providerModels.cloudflare[0].availability_source, 'provider_api');
+  assert.equal(status.providerModels.cloudflare[0].context_window_source, 'unknown');
+  const rendered = renderModelsStatus(status);
+  assert.match(rendered, /@cf\/qwen\/code/);
+  assert.doesNotMatch(rendered, /@cf\/baai\/embed/);
+  assert.doesNotMatch(rendered, /secret-cf/);
 });

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

@@ -8,6 +8,7 @@ import {
   ollamaInstallPlan,
   parseOllamaArgs,
   probeOllama,
+  probeOllamaModel,
   resolveOllamaConfig,
   updateProjectOllamaConfig,
   upsertOllamaEnvFile,
@@ -82,6 +83,26 @@ test('status probe recognizes configured chat and embedding models', async () =>
   assert.equal(status.embed_ready, true);
 });
 
+test('local model metadata is accepted only after Ollama itself verifies the model', async () => {
+  let seenBody = null;
+  const fakeFetch = async (url, init) => {
+    assert.match(url, /\/api\/show$/);
+    seenBody = JSON.parse(init.body);
+    return new Response(JSON.stringify({
+      model_info: { 'qwen2.context_length': 32768 },
+      capabilities: ['completion', 'tools'],
+      details: { family: 'qwen2' },
+    }), { status: 200, headers: { 'content-type': 'application/json' } });
+  };
+
+  const result = await probeOllamaModel('qwen2.5-coder', OLLAMA_DEFAULTS, fakeFetch);
+  assert.equal(seenBody.model, 'qwen2.5-coder');
+  assert.equal(result.ok, true);
+  assert.equal(result.context_window, 32768);
+  assert.equal(result.context_window_source, 'local_runtime');
+  assert.deepEqual(result.capabilities, ['completion', 'tools']);
+});
+
 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',

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/portable-context.test.mjs

@@ -8,7 +8,7 @@ import { join } from 'node:path';
 import {
   normalizeGitRemote,
   resolveGitContext,
-} from '../src/lib/git-context.js';
+} from '../packages/agentsam-repository/src/git-context.js';
 import {
   buildBridgeHeaders,
   createBridgeClient,

package/test/provider-credentials.test.mjs

@@ -0,0 +1,96 @@
+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, /ACCOUNT_ID=""/);
+  assert.match(source, /CLOUDFLARE_API_TOKEN=""/);
+});
+
+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 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 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, /ACCOUNT_ID="11111111111111111111111111111111"/);
+  assert.match(source, /CLOUDFLARE_API_TOKEN="keep-me"/);
+
+  ensureProviderEnvProfile('cloudflare', { home, accountId: '22222222222222222222222222222222' });
+  source = fs.readFileSync(profile, 'utf8');
+  assert.match(source, /ACCOUNT_ID="11111111111111111111111111111111"/);
+  assert.doesNotMatch(source, /22222222222222222222222222222222/);
+});

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/);
+});

package/test/release-hygiene.test.mjs

@@ -6,15 +6,23 @@ import test from 'node:test';
 const root = path.resolve(import.meta.dirname, '..');
 const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
 
-test('2.5 release metadata and public terminal vocabulary are aligned', () => {
+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.equal(pkg.version, '2.5.0');
-  assert.match(manifest, /target_version: "2\.5\.0"/);
-  assert.match(manifest, /state: release_candidate/);
-  assert.match(manifest, /current_latest: "2\.4\.1"/);
+  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/);
 });