@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/test/integration/plugins-cloudflare.integration.test.mjs

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  AGENTSAM_MCP_PLUGIN_MANIFEST,
+  INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST,
+} from '../../src/plugins/index.js';
+
+test('Cloudflare OAuth installations have distinct client and callback contracts', () => {
+  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.plugin_key, 'agentsam-mcp');
+  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.auth_type, 'oauth');
+  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.oauth_connect_url, '/api/connections/cloudflare/start');
+  assert.equal(
+    AGENTSAM_MCP_PLUGIN_MANIFEST.config.callback_url,
+    'https://agentsam.inneranimalmedia.com/api/connections/cloudflare/callback',
+  );
+  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.config.token_auth_method, 'none_pkce');
+
+  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.plugin_key, 'inneranimalmedia-cf-oauth');
+  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.auth_type, 'oauth_via_iam');
+  assert.equal(
+    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.oauth_connect_url,
+    'https://inneranimalmedia.com/api/oauth/cloudflare/start',
+  );
+  assert.equal(
+    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.config.callback_url,
+    'https://inneranimalmedia.com/api/oauth/cloudflare/callback',
+  );
+});

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

@@ -29,7 +29,7 @@ test('Cloudflare env init backfills exactly one Wrangler account without printin
     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_ACCOUNT_ID="11111111111111111111111111111111"/);
   assert.match(profile, /CLOUDFLARE_API_TOKEN=""/);
   assert.match(output, /account  detected\/configured/);
   assert.doesNotMatch(output, /CLOUDFLARE_API_TOKEN=.*[^ ]/);

package/test/integration/runtime-migrations.test.mjs

@@ -6,13 +6,17 @@ import test from 'node:test';
 import { createLocalSqliteDatabase } from '../../src/local/sqlite.js';
 import { applyRuntimeMigrations } from '../../src/local/migrations.js';
 
+const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
+
 test('portable runtime migration installs AgentSam CLI state tables idempotently', async (t) => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runtime-migration-'));
   t.after(() => fs.rmSync(root, { recursive: true, force: true }));
   const db = await createLocalSqliteDatabase(path.join(root, 'agentsam.sqlite'));
   try {
     const first = await applyRuntimeMigrations(db);
-    assert.equal(first.applied, 1);
+    const migrationCount = fs.readdirSync(path.join(repoRoot, 'migrations', 'runtime'))
+      .filter((name) => /^\d+.*\.sql$/i.test(name)).length;
+    assert.equal(first.applied, migrationCount);
 
     const tables = await db.prepare(
       "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'agentsam_%' ORDER BY name"
@@ -25,6 +29,7 @@ test('portable runtime migration installs AgentSam CLI state tables idempotently
       'agentsam_context_digest',
       'agentsam_cron_runs',
       'agentsam_plans',
+      'agentsam_project_sessions',
       'agentsam_schema_migrations',
       'agentsam_todo',
     ]) assert.equal(names.has(name), true, name);

package/test/integration/runtime-status.integration.test.mjs

@@ -0,0 +1,211 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import test from 'node:test';
+import {
+  collectCloudflareDeploymentStatus,
+  readCloudflareDeploymentContract,
+  parseWranglerToml,
+  resolveProjectD1Database,
+} from '../../src/cloudflare/runtime-status.js';
+import { collectRuntimeStatus } from '../../src/commands/runtime-status.js';
+import { readProjectConfig } from '../../src/lib/project-config.js';
+import { runStatus } from '../../src/commands/status.js';
+import { renderRuntimeStatus } from '../../src/ui/ansi.js';
+
+const root = path.resolve(new URL('../..', import.meta.url).pathname);
+
+test('checked-in Cloudflare deployment contract resolves the real Worker and portable bindings', () => {
+  const contract = readCloudflareDeploymentContract(root, readProjectConfig(root));
+  assert.equal(contract.worker_name, 'agentsam-sdk');
+  assert.equal(contract.config, 'apps/local-studio/backend/wrangler.jsonc');
+  assert.deepEqual(contract.bindings.map((row) => row.name), [
+    'AGENTSAM_WAI', 'ASSETS', 'DB', 'EXECOS', 'HYPERDRIVE', 'IAM_CLIENT_ID',
+    'IAM_OAUTH_ISSUER', 'PTY_SERVICE', 'WEBSITE_ASSETS',
+  ]);
+});
+
+test('Cloudflare runtime status compares the active deployed version to the checked-in binding contract', async () => {
+  const projectConfig = readProjectConfig(root);
+  const contract = readCloudflareDeploymentContract(root, projectConfig);
+  const liveBindings = contract.bindings.map((row) => ({ name: row.name, type: row.type }));
+  liveBindings.push({ name: 'OPENAI_API_KEY', type: 'secret_text' });
+  const calls = [];
+  const result = await collectCloudflareDeploymentStatus({
+    root,
+    projectConfig,
+    runWrangler: async (command, input) => {
+      calls.push({ command, input });
+      if (command === 'whoami') return { data: { loggedIn: true } };
+      if (command === 'deployments.list') return { data: [{ id: 'dep_1', created_on: '2026-09-18T12:00:00Z', versions: [{ version_id: 'ver_1', percentage: 100 }] }] };
+      if (command === 'versions.list') return { data: [{ id: 'ver_1', metadata: { created_on: '2026-09-18T12:00:00Z' } }] };
+      if (command === 'versions.view') return { data: { id: 'ver_1', number: 37, metadata: { created_on: '2026-09-18T12:00:00Z', source: 'wrangler' }, resources: { bindings: liveBindings } } };
+      throw new Error(`unexpected:${command}`);
+    },
+    fetchImpl: async () => ({ ok: true, status: 200, async json() { return { ok: true, app: 'agentsam-sdk' }; } }),
+  });
+  assert.equal(result.connected, true);
+  assert.equal(result.bindings.match, true);
+  assert.equal(result.version.number, 37);
+  assert.equal(result.health.ok, true);
+  assert.equal(calls.find((row) => row.command === 'versions.view').input.version_id, 'ver_1');
+});
+
+test('unified status is ready only when account, model, terminal, deployment and health are real', async () => {
+  const local = {
+    root, project: 'agentsam-sdk', configured: true, git: { branch: 'main', revision: 'abc123', dirty: false },
+    pty: { online: false, url: 'http://127.0.0.1:3099/health' }, api: { online: false }, db: { ready: true, tables: [] },
+  };
+  const status = await collectRuntimeStatus({
+    cwd: root,
+    collectLocal: async () => local,
+    collectIdentity: async () => ({ authenticated: true, active_auth: { kind: 'browser_oauth' }, identity: { account_id: 'acct_1' }, api_key: {} }),
+    collectModels: async () => ({ providers: [{ id: 'openai', configured: true }], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
+    collectTerminal: async () => ({ connected: true, instances: [{ id: 'inst_1' }], connections: [{ id: 'conn_1', active: true, default: true, health: 'online' }], error: null }),
+    collectCloudflare: async () => ({ configured: true, connected: true, worker_name: 'agentsam-sdk', bindings: { match: true, live: [] }, health: { ok: true, status: 200 } }),
+  });
+  assert.equal(status.ready, true);
+  assert.equal(status.local_ready, true);
+  assert.equal(status.state_storage.actor_runtime, 'none');
+  assert.deepEqual(status.checks, { account: true, models: true, terminal: true, cloudflare: true });
+  assert.equal(status.model_summary.verified_provider_models, 1);
+});
+
+test('fresh local project can start before SQLite has been initialized', async () => {
+  const status = await collectRuntimeStatus({
+    cwd: root,
+    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: false, git: null, pty: { online: false }, api: {}, db: { exists: false, ready: false } }),
+    collectIdentity: async () => ({ authenticated: false, active_auth: {}, api_key: {} }),
+    collectModels: async () => ({ providers: [], providerModels: {}, local: { online: false, models: [] } }),
+    collectCloudflare: async () => ({ configured: false, bindings: { live: [] } }),
+  });
+  assert.equal(status.local_ready, true);
+  assert.equal(status.state_storage.migrated, false);
+  assert.equal(status.state_storage.runtime, 'sqlite');
+});
+
+test('unified status consumes the CLI-authorized terminal inventory returned by IAM context', async () => {
+  let legacyTerminalCalls = 0;
+  const status = await collectRuntimeStatus({
+    cwd: root,
+    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: true, git: null, pty: { online: false }, api: {}, db: {} }),
+    collectIdentity: async () => ({
+      authenticated: true,
+      active_auth: { kind: 'browser_oauth' },
+      api_key: {},
+      terminal: {
+        available: true,
+        instances: [{ id: 'inst_1', kind: 'local_device' }],
+        connections: [{ id: 'conn_1', instance_id: 'inst_1', is_active: true, is_default: true, health_status: 'online' }],
+      },
+    }),
+    collectModels: async () => ({ providers: [], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
+    collectTerminal: async () => { legacyTerminalCalls += 1; return { connected: false, instances: [], connections: [] }; },
+    collectCloudflare: async () => ({ configured: false }),
+  });
+  assert.equal(legacyTerminalCalls, 0);
+  assert.equal(status.terminal.active_connection_count, 1);
+  assert.equal(status.checks.terminal, true);
+});
+
+test('status command supports machine-readable injected runtime status', async () => {
+  const expected = { schema_version: 'agentsam-runtime-status-v1', ready: true };
+  let output = '';
+  const result = await runStatus(['--json'], { collectRuntime: async () => expected, write(value) { output += value; } });
+  assert.equal(result, expected);
+  const parsed = JSON.parse(output);
+  assert.equal(parsed.schema_version, expected.schema_version);
+  assert.equal(parsed.ready, expected.ready);
+  assert.ok(parsed.next?.actions?.length > 0);
+  assert.ok(parsed.next?.headline);
+});
+
+test('renderRuntimeStatus explicitly displays DB and other resource bindings', () => {
+  const status = {
+    local: { project: 'agentsam-sdk', root: '/path/to/project' },
+    ready: true,
+    local_ready: true,
+    checks: { account: true, models: true, terminal: true, cloudflare: true },
+    cloudflare: {
+      configured: true,
+      worker_name: 'agentsam-sdk',
+      version: { number: 43 },
+      bindings: {
+        match: true,
+        live: [
+          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
+          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
+          { name: 'AGENTSAM_WAI', type: 'ai' },
+          { name: 'IAM_CLIENT_ID', type: 'plain_text' },
+          { name: 'OPENAI_API_KEY', type: 'secret_text' },
+        ],
+        declared: [
+          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
+          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
+          { name: 'AGENTSAM_WAI', type: 'ai' },
+        ],
+        resources: [
+          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
+          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
+          { name: 'AGENTSAM_WAI', type: 'ai' },
+        ],
+        runtime_variables: [{ name: 'IAM_CLIENT_ID', type: 'plain_text' }],
+        runtime_secrets: [{ name: 'OPENAI_API_KEY', type: 'secret_text' }],
+        missing: [],
+      },
+      health: { ok: true, status: 200 },
+    },
+  };
+
+  const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+  const rendered = stripAnsi(renderRuntimeStatus(status));
+  assert.match(rendered, /bindings\s+.*5 live/);
+  assert.match(rendered, /• DB · d1 \(inneranimalmedia-business\)/);
+  assert.match(rendered, /• WEBSITE_ASSETS · r2 \(agentsam-os-blueprint-content\)/);
+  assert.match(rendered, /• AGENTSAM_WAI · ai/);
+  assert.match(rendered, /1 vars · 1 secrets/);
+});
+
+test('parseWranglerToml parses worker name, d1 databases, r2, hyperdrive, and vars', () => {
+  const sample = `
+name = "my-sample-worker"
+main = "src/index.js"
+
+[vars]
+ENVIRONMENT = "production"
+PORT = 8080
+
+[[d1_databases]]
+binding = "DB"
+database_name = "sample-production-db"
+database_id = "d1-uuid-123"
+
+[[r2_buckets]]
+binding = "UPLOADS"
+bucket_name = "sample-bucket"
+
+[[hyperdrive]]
+binding = "HYPERDRIVE"
+id = "hd-uuid-456"
+
+[ai]
+binding = "AI"
+`;
+
+  const parsed = parseWranglerToml(sample);
+  assert.equal(parsed.name, 'my-sample-worker');
+  assert.equal(parsed.vars.ENVIRONMENT, 'production');
+  assert.equal(parsed.vars.PORT, 8080);
+  assert.equal(parsed.d1_databases.length, 1);
+  assert.equal(parsed.d1_databases[0].binding, 'DB');
+  assert.equal(parsed.d1_databases[0].database_name, 'sample-production-db');
+  assert.equal(parsed.r2_buckets.length, 1);
+  assert.equal(parsed.r2_buckets[0].binding, 'UPLOADS');
+  assert.equal(parsed.hyperdrive.length, 1);
+  assert.equal(parsed.hyperdrive[0].binding, 'HYPERDRIVE');
+  assert.equal(parsed.ai.binding, 'AI');
+});
+
+test('resolveProjectD1Database discovers project DB binding from checked-in config', () => {
+  const resolved = resolveProjectD1Database(root);
+  assert.equal(resolved, 'inneranimalmedia-business');
+});

package/test/integration/scaffold-cloudflare.test.mjs

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { detectCloudflareAccounts } from '../../src/commands/env.js';
+import { resolveCloudflareAccountId } from '../../src/lib/scaffold/resolve-cloudflare-account.js';
+import { workerApiTemplates } from '../../src/lib/scaffold/templates/worker-api/index.js';
+
+test('Cloudflare account detection accepts Wrangler JSON without exposing credentials', () => {
+  const result = detectCloudflareAccounts({
+    env: {},
+    spawnSyncImpl: () => ({ status: 0, stdout: JSON.stringify({ accounts: [{ id: 'a'.repeat(32), name: 'Example' }] }) }),
+  });
+  assert.deepEqual(result.accounts, [{ id: 'a'.repeat(32), name: 'Example' }]);
+  assert.equal(result.source, 'wrangler');
+});
+
+test('scaffold reuses a single detected Cloudflare account without prompting', async () => {
+  const notes = [];
+  const id = await resolveCloudflareAccountId({
+    detectAccounts: () => ({ accounts: [{ id: 'a'.repeat(32), name: 'Example' }] }),
+    text: () => { throw new Error('unexpected text prompt'); },
+    select: () => { throw new Error('unexpected selection prompt'); },
+    isCancel: () => false,
+    cancel: () => {},
+    note: (message) => notes.push(message),
+    pc: { cyan: (value) => value },
+  });
+  assert.equal(id, 'a'.repeat(32));
+  assert.match(notes[0], /Detected Cloudflare account: Example/);
+});
+
+test('worker API scaffold emits the selected database contract', () => {
+  const input = { projectName: 'example', routes: ['health', 'users', 'content'], cfAccountId: 'a'.repeat(32) };
+  const d1 = workerApiTemplates({ ...input, dbKind: 'd1' });
+  const hyperdrive = workerApiTemplates({ ...input, dbKind: 'hyperdrive' });
+
+  assert.match(d1['wrangler.toml'], /\[\[d1_databases\]\]/);
+  assert.doesNotMatch(d1['wrangler.toml'], /\[\[hyperdrive\]\]/);
+  assert.match(d1['src/routes/users.js'], /env\.DB\.prepare/);
+  assert.match(d1['migrations/001_init.sql'], /unixepoch\(\)/);
+
+  assert.match(hyperdrive['wrangler.toml'], /\[\[hyperdrive\]\]/);
+  assert.doesNotMatch(hyperdrive['wrangler.toml'], /\[\[d1_databases\]\]/);
+  assert.match(hyperdrive['src/routes/users.js'], /env\.HYPERDRIVE\.connectionString/);
+  assert.match(hyperdrive['migrations/001_init.sql'], /TIMESTAMPTZ/);
+  assert.match(hyperdrive['package.json'], /"postgres"/);
+});

package/test/integration/storage-architecture.test.mjs

@@ -0,0 +1,154 @@
+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';
+import { dispatchShellLine } from '../../src/commands/shell.js';
+import { createLocalSession, listLocalSessions, loadLocalSession, saveLocalSession } from '../../src/lib/local-sessions.js';
+import { createLocalSqliteDatabaseSync } from '../../src/local/sqlite.js';
+import { applyRuntimeMigrationsSync } from '../../src/local/migrations.js';
+import { finishRuntimeRun, pruneExpiredRuntimeState, runtimeDatabasePath, startRuntimeRun } from '../../src/local/runtime-store.js';
+
+const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
+
+function fixture(t) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-storage-'));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  const home = path.join(base, 'home');
+  const projectA = path.join(base, 'project-a');
+  const projectB = path.join(base, 'project-b');
+  for (const root of [projectA, projectB]) {
+    fs.mkdirSync(path.join(root, '.agentsam'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.agentsam', 'config.json'), '{"schema_version":2}\n');
+  }
+  fs.mkdirSync(home);
+  return { base, home, projectA, projectB };
+}
+
+test('S1: a local shell boots and migrates SQLite without cloud configuration', (t) => {
+  const { home, projectA } = fixture(t);
+  const env = { ...process.env, HOME: home };
+  for (const key of ['CLOUDFLARE_API_TOKEN', 'AGENTSAM_API_KEY', 'SUPABASE_URL', 'DATABASE_URL']) delete env[key];
+  const result = spawnSync(process.execPath, [path.join(repoRoot, 'src/cli.js'), 'shell'], {
+    cwd: projectA, env, input: '/exit\n', encoding: 'utf8', timeout: 10_000,
+  });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Interactive shell ready/);
+  assert.equal(fs.existsSync(runtimeDatabasePath(projectA)), true);
+  assert.equal(fs.existsSync(path.join(home, '.agentsam', 'sessions')), false);
+});
+
+test('S2-S4: cwd and model changes preserve project state; repository switch selects a new authority', async (t) => {
+  const { home, projectA, projectB } = fixture(t);
+  const child = path.join(projectA, 'src', 'agent');
+  fs.mkdirSync(child, { recursive: true });
+  assert.equal(runtimeDatabasePath(child), runtimeDatabasePath(projectA));
+
+  const session = createLocalSession({ cwd: child, title: 'Project A' }, { home });
+  const changedModel = saveLocalSession({ ...session, model_key: 'gemini:example' }, { home });
+  assert.equal(changedModel.id, session.id);
+  assert.equal(changedModel.project_root, projectA);
+  assert.equal(loadLocalSession(session.id, { home, cwd: projectA }).model_key, 'gemini:example');
+  assert.equal(loadLocalSession(session.id, { home, cwd: projectB }), null);
+
+  const runId = await startRuntimeRun({ projectRoot: projectA, model_key: 'test:model' });
+  let output = '';
+  const state = { cwd: child, projectRoot: projectA, home, session: changedModel, interactive: false, write(value) { output += value; } };
+  await dispatchShellLine('/logs', state);
+  assert.match(output, new RegExp(runId));
+  await dispatchShellLine(`/cd ${projectB}`, state);
+  assert.equal(state.cwd, projectB);
+  assert.equal(state.projectRoot, projectB);
+  assert.notEqual(state.session.id, session.id);
+  assert.equal(listLocalSessions({ home, cwd: projectA })[0].id, session.id);
+  assert.equal(listLocalSessions({ home, cwd: projectB })[0].id, state.session.id);
+  assert.equal(fs.existsSync(path.join(child, '.agentsam', 'data', 'agentsam.sqlite')), false);
+});
+
+test('S5: expiry cleanup removes transient digests and retains completed run receipts', async (t) => {
+  const { projectA } = fixture(t);
+  const runId = await startRuntimeRun({ cwd: projectA, model_key: 'test:model' });
+  await finishRuntimeRun({ cwd: projectA, id: runId, status: 'completed' });
+  const db = createLocalSqliteDatabaseSync(runtimeDatabasePath(projectA));
+  db.prepare(`INSERT INTO agentsam_context_digest
+    (id, digest_type, agent_run_id, source_hash, digest_hash, digest_text, expires_at_unix)
+    VALUES (?, 'session', ?, 'source', 'digest', 'expired', 1)`).run('ctx_expired', runId);
+  db.prepare('INSERT INTO agentsam_compaction_events (id, agent_run_id, expires_at_epoch) VALUES (?, ?, 1)').run('cmp_expired', runId);
+  db.close();
+
+  const pruned = await pruneExpiredRuntimeState({ cwd: projectA, nowUnix: 2 });
+  assert.deepEqual(pruned, { digests: 1, compactions: 1, approvals_expired: 0 });
+  const verified = createLocalSqliteDatabaseSync(runtimeDatabasePath(projectA));
+  assert.equal(verified.prepare('SELECT status FROM agentsam_agent_run WHERE id = ?').get(runId).status, 'completed');
+  assert.equal(verified.prepare('SELECT COUNT(*) AS n FROM agentsam_context_digest').get().n, 0);
+  verified.close();
+});
+
+test('S6-S7: connected Worker bindings do not move sessions or store credential values', (t) => {
+  const { home, projectA } = fixture(t);
+  const workerConfig = fs.readFileSync(path.join(repoRoot, 'apps/local-studio/backend/wrangler.jsonc'), 'utf8');
+  for (const binding of ['"d1_databases"', '"hyperdrive"', '"r2_buckets"', '"services"']) assert.match(workerConfig, new RegExp(binding));
+  assert.doesNotMatch(workerConfig, /"durable_objects"/);
+
+  const secret = 'storage_secret_do_not_persist_123';
+  const session = createLocalSession({
+    cwd: projectA, title: 'Safe project session', last_input: secret,
+    provider_state: { provider: 'openai', previous_response_id: 'resp_safe', api_key: secret, messages: [{ content: secret }] },
+    usage_snapshot: { current_context: { input_tokens: 20 }, credential: secret },
+    last_error: { code: 'failed', message: secret },
+  }, { home });
+  assert.equal(session.storage.runtime, 'sqlite');
+  assert.equal(session.storage.remote, null);
+  assert.equal(session.storage.capabilities.remote_shared_state, false);
+  assert.equal(session.storage.capabilities.distributed_actor_semantics, false);
+  assert.equal(session.last_input, null);
+  assert.equal(session.provider_state.api_key, undefined);
+  assert.doesNotMatch(fs.readFileSync(runtimeDatabasePath(projectA), 'utf8'), new RegExp(secret));
+  assert.equal(fs.statSync(runtimeDatabasePath(projectA)).mode & 0o777, 0o600);
+});
+
+test('S8: canonical migrations upgrade an older runtime database for project sessions', (t) => {
+  const { base, home, projectA } = fixture(t);
+  const oldMigrations = path.join(base, 'old-migrations');
+  fs.mkdirSync(oldMigrations);
+  fs.copyFileSync(path.join(repoRoot, 'migrations/runtime/0001_cli_runtime.sql'), path.join(oldMigrations, '0001_cli_runtime.sql'));
+  const db = createLocalSqliteDatabaseSync(runtimeDatabasePath(projectA));
+  assert.equal(applyRuntimeMigrationsSync(db, { migrationsDir: oldMigrations }).applied, 1);
+  assert.equal(db.prepare("SELECT name FROM sqlite_master WHERE name = 'agentsam_project_sessions'").get(), undefined);
+  db.close();
+
+  createLocalSession({ cwd: projectA }, { home });
+  const upgraded = createLocalSqliteDatabaseSync(runtimeDatabasePath(projectA));
+  const migrationCount = fs.readdirSync(path.join(repoRoot, 'migrations', 'runtime'))
+    .filter((name) => /^\d+.*\.sql$/i.test(name)).length;
+  assert.equal(upgraded.prepare("SELECT COUNT(*) AS n FROM agentsam_schema_migrations").get().n, migrationCount);
+  assert.ok(upgraded.prepare("SELECT name FROM sqlite_master WHERE name = 'agentsam_project_sessions'").get());
+  upgraded.close();
+});
+
+test('legacy home-level JSON sessions import only into their matching project SQLite', (t) => {
+  const { home, projectA, projectB } = fixture(t);
+  const id = 'asess_00000000-0000-4000-8000-000000000099';
+  const legacyDir = path.join(home, '.agentsam', 'sessions');
+  fs.mkdirSync(legacyDir, { recursive: true });
+  const filename = path.join(legacyDir, `${id}.json`);
+  fs.writeFileSync(filename, JSON.stringify({
+    schema_version: 'agentsam-local-session-v1', id, cwd: projectA,
+    title: 'Prior work', provider_state: { provider: 'openai', api_key: 'legacy_secret' },
+  }));
+  assert.equal(loadLocalSession(id, { home, cwd: projectB }), null);
+  assert.equal(fs.existsSync(runtimeDatabasePath(projectB)), false);
+  const imported = loadLocalSession(id, { home, cwd: projectA });
+  assert.equal(imported.project_root, projectA);
+  assert.equal(imported.provider_state.api_key, undefined);
+  assert.equal(fs.existsSync(filename), true);
+  assert.doesNotMatch(fs.readFileSync(runtimeDatabasePath(projectA), 'utf8'), /legacy_secret/);
+});
+
+test('S9: default runtime has no Durable Object binding or dependency', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  assert.equal(Object.keys(pkg.dependencies || {}).some((name) => /durable.?object/i.test(name)), false);
+  const shell = fs.readFileSync(path.join(repoRoot, 'src/commands/shell.js'), 'utf8');
+  assert.doesNotMatch(shell, /\bDurableObject\b|\bdurable_objects\b|\bidFromName\s*\(/);
+});

package/test/integration/store-discovery.test.mjs

@@ -0,0 +1,44 @@
+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 { discoverProjectStores, selectKnowledgeStore } from '../../src/knowledge/store-discovery.js';
+import { initRepository, readConfig } from '../../src/knowledge/config.js';
+import { dispatchShellLine } from '../../src/commands/shell.js';
+
+test('store discovery reads JSONC bindings without leaking credentials or selecting application storage', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-store-discovery-'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"stores"}');
+  fs.writeFileSync(path.join(root, 'wrangler.jsonc'), `{
+    // Existing application authority
+    "vars": {"PASSWORD":"do-not-emit"},
+    "d1_databases": [{"binding":"DB","database_name":"existing-app"}],
+    "hyperdrive": [{"binding":"HYPERDRIVE","id":"existing-pool"}],
+    "env": {"preview":{"d1_databases":[{"binding":"DB","database_name":"preview-app"}]}}
+  }`);
+  const result = await discoverProjectStores(root, { DATABASE_URL: 'postgres://secret:password@private/db' });
+  assert.equal(result.candidates.find(c => c.driver === 'd1').name, 'existing-app');
+  assert.equal(result.candidates.find(c => c.environment === 'preview').name, 'preview-app');
+  assert.ok(result.candidates.filter(c => c.role === 'application').every(c => c.selectable === false));
+  assert.equal(result.candidates.find(c => c.driver === 'postgres').connection_env, 'DATABASE_URL');
+  assert.doesNotMatch(JSON.stringify(result), /password|secret|do-not-emit/);
+  assert.equal(fs.existsSync(path.join(root, '.agentsam')), false);
+  let output = '';
+  await dispatchShellLine('/db sources', { cwd: root, write: s => { output += s; }, interactive: false });
+  assert.match(output, /existing-app/);
+});
+
+test('knowledge selection edits existing portable config without overwriting scope or moving runtime data', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-store-selection-'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"stores"}');
+  initRepository(root, { repositoryId: 'repo:test', include: ['src'] });
+  selectKnowledgeStore(root, 'postgres', 'MY_DATABASE_URL');
+  assert.deepEqual(readConfig(root).scope.include, ['src']);
+  assert.equal(readConfig(root).storage.connection_env, 'MY_DATABASE_URL');
+  assert.equal(fs.existsSync(path.join(root, '.agentsam/data/agentsam.sqlite')), false);
+  assert.throws(() => selectKnowledgeStore(root, 'postgres', 'postgres://password@host/db'), /connection_env/);
+  assert.throws(() => selectKnowledgeStore(root, 'd1'), /adapter_unavailable/);
+  selectKnowledgeStore(root, 'sqlite');
+  assert.deepEqual(readConfig(root).storage, { driver: 'sqlite' });
+});

package/test/integration/terminal-exec.integration.test.mjs

@@ -0,0 +1,86 @@
+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 { terminalExec } from '../../src/capabilities/terminal-exec.js';
+import { createCapabilityAdapter } from '../../src/agent/capability-adapter.js';
+import { toolApprovalKey } from '../../src/lib/execution-approvals.js';
+
+function root(t) {
+  const value = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-terminal-exec-'));
+  t.after(() => fs.rmSync(value, { recursive: true, force: true }));
+  return value;
+}
+
+test('terminal.exec runs a real argv process inside the runtime-owned project', async t => {
+  const cwd = root(t);
+  fs.mkdirSync(path.join(cwd, 'src'));
+  const seen = [];
+  const result = await terminalExec({
+    cwd,
+    relative_cwd: 'src',
+    command: 'node',
+    args: ['--version'],
+  }, {
+    env: { PATH: process.env.PATH, OPENAI_API_KEY: 'must-not-reach-child' },
+    run: async (command, args, options) => {
+      seen.push({ command, args, options });
+      return { code: 0, signal: null, stdout: 'v24.0.0\n', stderr: '' };
+    },
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.cwd, path.join(cwd, 'src'));
+  assert.equal(seen[0].options.env.OPENAI_API_KEY, undefined);
+  assert.equal(seen[0].options.env.PATH, process.env.PATH);
+});
+
+test('terminal.exec expands a leading ~ in argv and cwd override (spawn never invokes a shell)', async t => {
+  const home = os.homedir();
+  const seen = [];
+  const result = await terminalExec({
+    cwd: process.cwd(),
+    command: 'git',
+    args: ['-C', '~/agentsam-sdk', 'status'],
+  }, {
+    env: { PATH: process.env.PATH },
+    run: async (command, args, options) => {
+      seen.push({ command, args, options });
+      return { code: 0, signal: null, stdout: '', stderr: '' };
+    },
+  });
+  assert.equal(result.ok, true);
+  assert.equal(seen[0].args[1], path.join(home, 'agentsam-sdk'));
+  assert.equal(seen[0].args[1].startsWith('~'), false);
+});
+
+test('terminal.exec leaves non-leading tildes and bare relative args untouched', async t => {
+  const seen = [];
+  await terminalExec({
+    cwd: process.cwd(),
+    command: 'echo',
+    args: ['user~name', 'plain-arg'],
+  }, {
+    env: { PATH: process.env.PATH },
+    run: async (command, args, options) => {
+      seen.push({ command, args, options });
+      return { code: 0, signal: null, stdout: '', stderr: '' };
+    },
+  });
+  assert.deepEqual(seen[0].args, ['user~name', 'plain-arg']);
+});
+
+test('terminal.exec rejects shell strings and working-directory escape', async t => {
+  const cwd = root(t);
+  await assert.rejects(terminalExec({ cwd, command: 'git status', args: [] }), /pathless_executable/);
+  await assert.rejects(terminalExec({ cwd, relative_cwd: '..', command: 'git', args: ['status'] }), /outside_project/);
+});
+
+test('terminal.exec is model-callable and approvals are command-specific', () => {
+  const adapter = createCapabilityAdapter();
+  const descriptor = adapter.toolDescriptors().find((row) => row.name === 'terminal.exec');
+  assert.ok(descriptor);
+  assert.equal(descriptor.risk, 'write');
+  assert.equal(toolApprovalKey('terminal.exec', { command: 'git' }), 'terminal.exec:git');
+  assert.equal(toolApprovalKey('terminal.exec', { command: 'npm' }), 'terminal.exec:npm');
+});