@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.1

package/src/lib/cli-preferences.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { getProjectName, tryReadProjectConfig } from './project-config.js';
 
-export const CLI_PREFERENCES_SCHEMA = 'agentsam-cli-preferences-v2';
-export const LEGACY_CLI_PREFERENCES_SCHEMA = 'agentsam-cli-preferences-v1';
+export const CLI_PREFERENCES_SCHEMA = 'agentsam-cli-preferences-v3';
+export const LEGACY_CLI_PREFERENCES_SCHEMAS = new Set(['agentsam-cli-preferences-v1', 'agentsam-cli-preferences-v2']);
 
 function readJson(filename) {
   try { return JSON.parse(fs.readFileSync(filename, 'utf8')); }
@@ -43,16 +43,43 @@ export function detectCliProject(startDir = process.cwd()) {
 
 export function cliPreferencesPath(root) { return path.join(path.resolve(root), '.agentsam', 'cli.json'); }
 
+function safeModelSnapshot(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const provider = String(value.provider || '').trim();
+  const providerModelId = String(value.provider_model_id || '').trim();
+  if (!provider || !providerModelId) return null;
+  return {
+    model_key: String(value.model_key || `${provider}:${providerModelId}`),
+    provider,
+    provider_model_id: providerModelId,
+    label: String(value.label || providerModelId),
+    availability: value.availability === 'available' ? 'available' : 'unverified',
+    availability_source: String(value.availability_source || ''),
+    context_window: Number.isFinite(Number(value.context_window)) && Number(value.context_window) > 0 ? Number(value.context_window) : null,
+    context_window_source: String(value.context_window_source || 'unknown'),
+    max_output_tokens: Number.isFinite(Number(value.max_output_tokens)) && Number(value.max_output_tokens) > 0 ? Number(value.max_output_tokens) : null,
+    max_output_tokens_source: String(value.max_output_tokens_source || 'unknown'),
+    reasoning_efforts: Array.isArray(value.reasoning_efforts) && value.reasoning_efforts.length ? value.reasoning_efforts.map(String) : ['auto'],
+    service_tiers: Array.isArray(value.service_tiers) && value.service_tiers.length ? value.service_tiers.map(String) : ['default'],
+    capabilities: value.capabilities && typeof value.capabilities === 'object' ? { ...value.capabilities } : {},
+    pricing: value.pricing && typeof value.pricing === 'object' ? { ...value.pricing } : null,
+    context_policy: value.context_policy && typeof value.context_policy === 'object' ? { ...value.context_policy } : null,
+    source: value.source && typeof value.source === 'object' ? { ...value.source } : null,
+  };
+}
+
 function normalizePreferences(value = {}) {
+  const modelSnapshot = safeModelSnapshot(value.modelSnapshot);
   return {
     schemaVersion: CLI_PREFERENCES_SCHEMA,
     trustedDirectory: value.trustedDirectory === true,
     runtime: value.runtime || 'local',
     terminal: value.terminal || '',
     modelPreference: value.modelPreference || 'auto',
+    modelSnapshot,
     reasoningEffort: value.reasoningEffort || 'auto',
     serviceTier: value.serviceTier || 'default',
-    modelAuthority: 'preference-only',
+    modelAuthority: modelSnapshot?.availability === 'available' ? 'provider-verified' : 'preference-only',
     updatedAt: value.updatedAt || null,
   };
 }
@@ -60,7 +87,7 @@ function normalizePreferences(value = {}) {
 export function readCliPreferences(root) {
   const value = readJson(cliPreferencesPath(root));
   if (!value) return null;
-  if (value.schemaVersion !== CLI_PREFERENCES_SCHEMA && value.schemaVersion !== LEGACY_CLI_PREFERENCES_SCHEMA) return null;
+  if (value.schemaVersion !== CLI_PREFERENCES_SCHEMA && !LEGACY_CLI_PREFERENCES_SCHEMAS.has(value.schemaVersion)) return null;
   return normalizePreferences(value);
 }
 

package/src/lib/deploy-receipt/index.js

@@ -2,8 +2,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { buildMerkleTree, diffTrees, readSnapshot, validateSnapshot } from '../merkle/index.js';
-import { normalizePolicy } from '../merkle/policy.js';
+import { buildMerkleTree, diffTrees, readSnapshot, validateSnapshot } from '../../../packages/agentsam-repository/src/merkle/index.js';
+import { normalizePolicy } from '../../../packages/agentsam-repository/src/merkle/policy.js';
 
 export const DEFAULT_DEPLOY_EXCLUDES = Object.freeze([
   '.agentsam/deploy-merkle',

package/src/lib/knowledge-docker.js

@@ -7,12 +7,15 @@ import { CONFIG_PATH, defaultConfig, readConfig } from '../knowledge/config.js';
 
 const sdkRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 const runtimeFiles = () => {
-  const files = ['services/knowledge/package.json', 'services/knowledge/package-lock.json', 'src/lib/merkle/hash.js'];
+  const files = ['services/knowledge/package.json', 'services/knowledge/package-lock.json', 'packages/agentsam-repository/src/merkle/hash.js', 'src/errors/contract.js'];
   const walk = dir => { for (const entry of fs.readdirSync(path.join(sdkRoot, dir), { withFileTypes: true })) {
     const file = `${dir}/${entry.name}`;
-    if (entry.isDirectory()) walk(file); else if (entry.isFile() && /\.(js|sql)$/.test(entry.name)) files.push(file);
+    if (entry.isDirectory()) walk(file);
+    else if (entry.isFile() && (/\.(js|sql)$/.test(entry.name) || file === 'src/rpc/generated/package.json')) files.push(file);
   } };
-  walk('src/knowledge'); return files.sort();
+  walk('src/knowledge');
+  walk('src/rpc/generated');
+  return files.sort();
 };
 
 export function generateKnowledgeDocker(opts = {}) {

package/src/lib/local-sessions.js

@@ -52,17 +52,37 @@ function normalizeUsage(value = {}) {
   };
 }
 
+function normalizeCostBreakdown(value = {}) {
+  return {
+    input: Number(value.input || 0),
+    cached_input: Number(value.cached_input || 0),
+    cache_write: Number(value.cache_write || 0),
+    output: Number(value.output || 0),
+  };
+}
+
+export function localSessionElapsedMs(session = {}, at = Date.now()) {
+  const accumulated = Math.max(0, Number(session.active_elapsed_ms || 0));
+  const startedAt = Date.parse(clean(session.active_started_at));
+  if (clean(session.status) !== 'active' || !Number.isFinite(startedAt)) return accumulated;
+  return accumulated + Math.max(0, Number(at) - startedAt);
+}
+
 export function normalizeLocalSession(value = {}) {
   const createdAt = clean(value.created_at) || now();
+  const status = clean(value.status) || 'active';
+  const updatedAt = clean(value.updated_at) || createdAt;
   return {
     schema_version: LOCAL_SESSION_SCHEMA,
     id: validateSessionId(value.id || createLocalSessionId()),
-    status: clean(value.status) || 'active',
+    status,
     cwd: path.resolve(clean(value.cwd) || process.cwd()),
     title: clean(value.title) || sessionTitleFromInput(value.last_input),
     last_input: clean(value.last_input) || null,
     created_at: createdAt,
-    updated_at: clean(value.updated_at) || createdAt,
+    updated_at: updatedAt,
+    active_elapsed_ms: Math.max(0, Number(value.active_elapsed_ms || 0)),
+    active_started_at: clean(value.active_started_at) || (status === 'active' ? updatedAt : null),
     model_key: clean(value.model_key) || null,
     provider_model_id: clean(value.provider_model_id) || null,
     reasoning_effort: clean(value.reasoning_effort) || null,
@@ -72,6 +92,7 @@ export function normalizeLocalSession(value = {}) {
     usage_snapshot: value.usage_snapshot && typeof value.usage_snapshot === 'object' ? structuredClone(value.usage_snapshot) : null,
     cumulative_usage: normalizeUsage(value.cumulative_usage || {}),
     total_cost_usd: Number(value.total_cost_usd || 0),
+    cost_breakdown_usd: normalizeCostBreakdown(value.cost_breakdown_usd || {}),
     approved_projected_call_cost_usd: Number(value.approved_projected_call_cost_usd || 0),
     last_error: value.last_error && typeof value.last_error === 'object' ? structuredClone(value.last_error) : null,
   };

package/src/lib/local-status.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { tryResolveGitContext } from './git-context.js';
+import { tryResolveGitContext } from '../../packages/agentsam-repository/src/git-context.js';
 import { inspectLocalSqlite } from '../local/sqlite.js';
 import { getCreatedWithVersion, getDefaultProfile, getDeployTarget, getLocalDatabasePath, getProjectName, getProjectPreset, getRepositoryId, tryReadProjectConfig } from './project-config.js';
 

package/src/lib/project-config.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { tryResolveGitContext } from './git-context.js';
+import { tryResolveGitContext } from '../../packages/agentsam-repository/src/git-context.js';
 
 export const PROJECT_CONFIG_PATH = '.agentsam/config.json';
 export const PROJECT_CONFIG_SCHEMA_VERSION = 2;

package/src/lib/provider-credentials.js

@@ -7,10 +7,16 @@ const PROVIDER_CREDENTIALS = Object.freeze({
   gemini: Object.freeze({ env: 'GEMINI_API_KEY', files: ['gemini.env'] }),
   anthropic: Object.freeze({ env: 'ANTHROPIC_API_KEY', files: ['anthropic.env'] }),
   grok: Object.freeze({ env: 'XAI_API_KEY', files: ['grok.env', 'xai.env'] }),
-  cloudflare: Object.freeze({ env: 'CLOUDFLARE_API_TOKEN', files: ['cloudflare.env'] }),
+  cloudflare: Object.freeze({ env: 'CLOUDFLARE_API_TOKEN', files: ['cloudflare.env'], accountEnv: ['ACCOUNT_ID', 'CLOUDFLARE_ACCOUNT_ID'] }),
 });
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
+function normalizeCloudflareAccountId(value) {
+  const id = clean(value);
+  if (!id) return '';
+  if (!/^[a-f0-9]{32}$/i.test(id)) throw new Error('invalid_cloudflare_account_id');
+  return id;
+}
 
 function homeDirectory(options = {}) {
   return path.resolve(clean(options.home) || clean(options.env?.HOME) || clean(options.env?.USERPROFILE) || os.homedir());
@@ -36,6 +42,96 @@ function secureFile(filename) {
   return { ok: true, mode: stat.mode & 0o777 };
 }
 
+function firstEnvValue(source, names = []) {
+  for (const name of names) {
+    const value = clean(parseEnvValue(source, name));
+    if (value) return value;
+  }
+  return '';
+}
+
+function firstRuntimeValue(env, names = []) {
+  for (const name of names) {
+    const value = clean(env?.[name]);
+    if (value) return value;
+  }
+  return '';
+}
+
+export function agentEnvDirectory(options = {}) {
+  return path.join(homeDirectory(options), '.agentsam', 'env.d');
+}
+
+export function agentEnvLoaderPath(options = {}) {
+  return path.join(homeDirectory(options), '.agentsam', 'load-agent-env.sh');
+}
+
+export function ensureAgentEnvLoader(options = {}) {
+  const filename = agentEnvLoaderPath(options);
+  fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
+  const source = `# AgentSam provider environment loader. Source this file; do not execute it.
+_agentsam_profile=\"\${1:-}\"
+case \"\$_agentsam_profile\" in
+  openai|anthropic|gemini|grok|cloudflare) ;;
+  *) echo \"usage: source ~/.agentsam/load-agent-env.sh <openai|anthropic|gemini|grok|cloudflare>\" >&2; return 2 2>/dev/null || exit 2 ;;
+esac
+_agentsam_file=\"\${HOME}/.agentsam/env.d/\${_agentsam_profile}.env\"
+if [ ! -f \"\$_agentsam_file\" ]; then
+  echo \"AgentSam provider profile not found: \$_agentsam_file\" >&2
+  return 1 2>/dev/null || exit 1
+fi
+set -a
+. \"\$_agentsam_file\"
+set +a
+if [ \"\$_agentsam_profile\" = cloudflare ]; then
+  if [ -z \"\${ACCOUNT_ID:-}\" ] && [ -n \"\${CLOUDFLARE_ACCOUNT_ID:-}\" ]; then export ACCOUNT_ID=\"\$CLOUDFLARE_ACCOUNT_ID\"; fi
+  if [ -z \"\${CLOUDFLARE_ACCOUNT_ID:-}\" ] && [ -n \"\${ACCOUNT_ID:-}\" ]; then export CLOUDFLARE_ACCOUNT_ID=\"\$ACCOUNT_ID\"; fi
+fi
+unset _agentsam_file _agentsam_profile
+`;
+  fs.writeFileSync(filename, source, { mode: 0o700 });
+  if (process.platform !== 'win32') fs.chmodSync(filename, 0o700);
+  return filename;
+}
+
+function profileTemplate(provider, options = {}) {
+  if (provider === 'cloudflare') {
+    const accountId = normalizeCloudflareAccountId(options.accountId);
+    return `# AgentSam Cloudflare profile\n# ACCOUNT_ID is your Cloudflare account identifier; it is not a secret.\nexport ACCOUNT_ID=\"${accountId}\"\nexport CLOUDFLARE_API_TOKEN=\"\"\n`;
+  }
+  const spec = PROVIDER_CREDENTIALS[provider];
+  if (!spec) throw new Error(`unsupported_provider:${provider}`);
+  return `# AgentSam ${provider} provider profile\nexport ${spec.env}=\"\"\n`;
+}
+
+export function ensureProviderEnvProfile(provider, options = {}) {
+  const spec = providerCredentialSpec(provider);
+  if (!spec) throw new Error(`unsupported_provider:${clean(provider).toLowerCase()}`);
+  const dir = agentEnvDirectory(options);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') fs.chmodSync(dir, 0o700);
+  const filename = path.join(dir, spec.files[0]);
+  let created = false;
+  if (!fs.existsSync(filename)) {
+    fs.writeFileSync(filename, profileTemplate(spec.provider, options), { mode: 0o600 });
+    created = true;
+  } else if (spec.provider === 'cloudflare' && clean(options.accountId)) {
+    const source = fs.readFileSync(filename, 'utf8');
+    const current = firstEnvValue(source, spec.accountEnv || []);
+    if (!current) {
+      const accountId = normalizeCloudflareAccountId(options.accountId);
+      const line = `export ACCOUNT_ID=\"${accountId}\"`;
+      const next = /^(?:export\s+)?ACCOUNT_ID=.*$/m.test(source)
+        ? source.replace(/^(?:export\s+)?ACCOUNT_ID=.*$/m, line)
+        : `${line}\n${source}`;
+      fs.writeFileSync(filename, next, { mode: 0o600 });
+    }
+  }
+  if (process.platform !== 'win32') fs.chmodSync(filename, 0o600);
+  const loader = ensureAgentEnvLoader(options);
+  return Object.freeze({ provider: spec.provider, file: filename, loader, created, source_command: `source ~/.agentsam/load-agent-env.sh ${spec.provider}` });
+}
+
 export function providerCredentialSpec(provider) {
   const id = clean(provider).toLowerCase();
   const spec = PROVIDER_CREDENTIALS[id];
@@ -46,18 +142,21 @@ export function resolveProviderCredential(provider, options = {}) {
   const spec = providerCredentialSpec(provider);
   if (!spec) return Object.freeze({ provider: clean(provider).toLowerCase(), configured: false, source: null, error: 'unsupported_provider', value: '' });
   const env = options.env || process.env;
+  const accountIdFromEnv = firstRuntimeValue(env, spec.accountEnv || []);
   const fromEnv = clean(env?.[spec.env]);
-  if (fromEnv) return Object.freeze({ provider: spec.provider, configured: true, source: 'environment', env: spec.env, file: null, error: null, value: fromEnv });
+  if (fromEnv) return Object.freeze({ provider: spec.provider, configured: true, source: 'environment', env: spec.env, file: null, error: null, value: fromEnv, account_id: accountIdFromEnv || null });
 
-  const dir = path.join(homeDirectory({ ...options, env }), '.agentsam', 'env.d');
+  const dir = agentEnvDirectory({ ...options, env });
   for (const basename of spec.files) {
     const filename = path.join(dir, basename);
     if (!fs.existsSync(filename)) continue;
     try {
       const safety = secureFile(filename);
       if (!safety.ok) return Object.freeze({ provider: spec.provider, configured: false, source: 'agentsam_env_file', env: spec.env, file: filename, error: safety.error, value: '' });
-      const value = clean(parseEnvValue(fs.readFileSync(filename, 'utf8'), spec.env));
-      if (value) return Object.freeze({ provider: spec.provider, configured: true, source: 'agentsam_env_file', env: spec.env, file: filename, error: null, value });
+      const source = fs.readFileSync(filename, 'utf8');
+      const value = clean(parseEnvValue(source, spec.env));
+      const accountId = accountIdFromEnv || firstEnvValue(source, spec.accountEnv || []);
+      if (value) return Object.freeze({ provider: spec.provider, configured: true, source: 'agentsam_env_file', env: spec.env, file: filename, error: null, value, account_id: accountId || null });
       return Object.freeze({ provider: spec.provider, configured: false, source: 'agentsam_env_file', env: spec.env, file: filename, error: 'credential_variable_missing', value: '' });
     } catch (error) {
       return Object.freeze({ provider: spec.provider, configured: false, source: 'agentsam_env_file', env: spec.env, file: filename, error: error?.message || String(error), value: '' });
@@ -75,6 +174,7 @@ export function describeProviderCredential(provider, options = {}) {
     env: resolved.env || null,
     file: resolved.file || null,
     error: resolved.error || null,
+    account_id: resolved.account_id || null,
   });
 }
 

package/src/lib/slash-commands.js

@@ -11,10 +11,11 @@ export const SLASH_COMMANDS = [
   { cmd: '/context', description: 'Show model context economics; add repo for Git bridge context', lane: 'context' },
   { cmd: '/status', description: 'Local project, DB, Git, and PTY health', lane: 'local' },
   { cmd: '/models', description: 'Probe providers and provider-verified known models', lane: 'model' },
-  { cmd: '/login', description: 'Authenticate IAM and save the machine-local Agent Sam session', lane: 'identity' },
-  { cmd: '/logout', description: 'Remove the local IAM session without deleting provider keys', lane: 'identity' },
-  { cmd: '/whoami', description: 'Show authenticated IAM identity and safe credential status', lane: 'identity' },
+  { cmd: '/login', description: 'Sign in to Inner Animal Media and save the machine-local Agent Sam session', lane: 'identity' },
+  { cmd: '/logout', description: 'Sign out locally without deleting provider credentials', lane: 'identity' },
+  { cmd: '/whoami', description: 'Show authenticated account identity and safe credential status', lane: 'identity' },
   { cmd: '/session', description: 'Show current session usage, cost, and resume receipt', lane: 'observability' },
+  { cmd: '/usage', description: 'Show token usage, spend breakdown, and resume command', lane: 'observability' },
   { cmd: '/cf', description: 'Cloudflare native reads, Wrangler status, and CPU profile analysis', lane: 'cloudflare' },
   { cmd: '/settings', description: 'Choose project, runtime, terminal, and model policy' },
   { cmd: '/pwd', description: 'Print working directory', lane: 'terminal' },

package/src/local/migrations.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DEFAULT_MIGRATIONS_DIR = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  '..',
+  'migrations',
+  'runtime',
+);
+
+function migrationFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && /^\d+.*\.sql$/i.test(entry.name))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function ensureLedger(db) {
+  db.exec(`
+CREATE TABLE IF NOT EXISTS agentsam_schema_migrations (
+  id TEXT PRIMARY KEY,
+  applied_at_unix INTEGER NOT NULL DEFAULT (unixepoch()),
+  checksum TEXT
+);
+`);
+}
+
+function checksumSource(source) {
+  let hash = 2166136261;
+  for (let i = 0; i < source.length; i += 1) {
+    hash ^= source.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return 'fnv1a32:' + (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+export async function listAppliedMigrations(db) {
+  ensureLedger(db);
+  const result = await db.prepare(
+    'SELECT id, applied_at_unix, checksum FROM agentsam_schema_migrations ORDER BY id'
+  ).all();
+  return result.results || [];
+}
+
+export async function applyRuntimeMigrations(db, options = {}) {
+  const dir = path.resolve(options.migrationsDir || DEFAULT_MIGRATIONS_DIR);
+  ensureLedger(db);
+  const appliedRows = await listAppliedMigrations(db);
+  const applied = new Map(appliedRows.map((row) => [String(row.id), row]));
+  const results = [];
+
+  for (const filename of migrationFiles(dir)) {
+    const id = filename.replace(/\.sql$/i, '');
+    const source = fs.readFileSync(path.join(dir, filename), 'utf8');
+    const checksum = checksumSource(source);
+    const previous = applied.get(id);
+
+    if (previous) {
+      if (previous.checksum && previous.checksum !== checksum) {
+        throw new Error('migration_checksum_mismatch:' + id);
+      }
+      results.push({ id, filename, status: 'already_applied', checksum });
+      continue;
+    }
+
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      db.exec(source);
+      await db.prepare(
+        'INSERT INTO agentsam_schema_migrations (id, checksum) VALUES (?, ?)'
+      ).bind(id, checksum).run();
+      db.exec('COMMIT');
+      results.push({ id, filename, status: 'applied', checksum });
+    } catch (error) {
+      try { db.exec('ROLLBACK'); } catch {}
+      throw new Error('migration_failed:' + id + ':' + (error?.message || error));
+    }
+  }
+
+  return Object.freeze({
+    migrationsDir: dir,
+    total: results.length,
+    applied: results.filter((row) => row.status === 'applied').length,
+    results: Object.freeze(results),
+  });
+}
+
+export function runtimeMigrationsDirectory() {
+  return DEFAULT_MIGRATIONS_DIR;
+}

package/src/local/runtime-store.js

@@ -0,0 +1,141 @@
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { createLocalSqliteDatabase } from './sqlite.js';
+import { applyRuntimeMigrations } from './migrations.js';
+
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function hash(value) { return createHash('sha256').update(String(value || '')).digest('hex'); }
+
+export function runtimeDatabasePath(cwd = process.cwd()) {
+  return path.join(path.resolve(cwd), '.agentsam', 'data', 'agentsam.sqlite');
+}
+
+async function withStore(cwd, fn) {
+  const db = await createLocalSqliteDatabase(runtimeDatabasePath(cwd));
+  try {
+    await applyRuntimeMigrations(db);
+    return await fn(db);
+  } finally {
+    db.close();
+  }
+}
+
+export function createRuntimeRunId() {
+  return `arun_${randomUUID()}`;
+}
+
+export async function startRuntimeRun(value = {}) {
+  const id = clean(value.id) || createRuntimeRunId();
+  await withStore(value.cwd, async (db) => {
+    await db.prepare(`
+      INSERT INTO agentsam_agent_run (
+        id, account_id, source_client, surface, mode, model_key,
+        reasoning_effort, requested_service_tier, status, started_at_unix, updated_at_unix
+      ) VALUES (?, ?, 'agentsam-cli', 'cli', ?, ?, ?, ?, 'running', unixepoch(), unixepoch())
+    `).bind(
+      id,
+      clean(value.account_id) || null,
+      clean(value.mode) || 'agent',
+      clean(value.model_key) || null,
+      clean(value.reasoning_effort) || null,
+      clean(value.service_tier) || null,
+    ).run();
+  });
+  return id;
+}
+
+export async function finishRuntimeRun(value = {}) {
+  if (!clean(value.id)) return;
+  await withStore(value.cwd, async (db) => {
+    const usage = value.usage || {};
+    await db.prepare(`
+      UPDATE agentsam_agent_run
+      SET status = ?,
+          actual_service_tier = COALESCE(?, actual_service_tier),
+          input_tokens = ?,
+          cached_input_tokens = ?,
+          output_tokens = ?,
+          reasoning_tokens = ?,
+          cost_usd = ?,
+          error_code = ?,
+          error_message = ?,
+          completed_at_unix = unixepoch(),
+          updated_at_unix = unixepoch(),
+          latency_ms = ?
+      WHERE id = ?
+    `).bind(
+      clean(value.status) || 'completed',
+      clean(value.actual_service_tier) || null,
+      Number(usage.input_tokens || 0),
+      Number(usage.cached_input_tokens || 0),
+      Number(usage.output_tokens || 0),
+      Number(usage.reasoning_tokens || 0),
+      Math.max(0, Number(value.cost_usd || 0)),
+      clean(value.error_code) || null,
+      clean(value.error_message) || null,
+      Number.isFinite(Number(value.latency_ms)) ? Math.max(0, Math.round(Number(value.latency_ms))) : null,
+      value.id,
+    ).run();
+  });
+}
+
+export async function recordRuntimeCompaction(value = {}) {
+  if (!clean(value.agent_run_id)) return null;
+  const id = clean(value.id) || `cmp_${randomUUID()}`;
+  const summary = clean(value.summary_text);
+  const before = Math.max(0, Math.round(Number(value.tokens_before || 0)));
+  const after = Math.max(0, Math.round(Number(value.tokens_after || 0)));
+  const sourceHash = hash(summary || JSON.stringify(value.metadata || {}));
+
+  await withStore(value.cwd, async (db) => {
+    await db.prepare(`
+      INSERT INTO agentsam_compaction_events (
+        id, account_id, agent_run_id, compaction_type, compaction_scope,
+        compaction_strategy, source_kind, content_hash, provider, model_key,
+        tokens_before, tokens_after, status, summary_text, summary_json,
+        metrics_json, metadata_json, source_stored
+      ) VALUES (?, ?, ?, 'context_summary', 'agent_run', 'summarize', ?, ?, ?, ?, ?, ?, 'completed', ?, ?, ?, ?, ?)
+    `).bind(
+      id,
+      clean(value.account_id) || null,
+      value.agent_run_id,
+      clean(value.source_kind) || 'api',
+      sourceHash,
+      clean(value.provider),
+      clean(value.model_key),
+      before,
+      after,
+      summary,
+      JSON.stringify({ summary }),
+      JSON.stringify({ tokens_before: before, tokens_after: after, tokens_saved: before - after }),
+      JSON.stringify(value.metadata || {}),
+      clean(value.source_stored) || 'local:agentsam_compaction_events',
+    ).run();
+
+    if (summary) {
+      const digestId = `ctx_${randomUUID()}`;
+      const digestHash = hash(`${value.agent_run_id}:${id}:${summary}`);
+      await db.prepare(`
+        INSERT INTO agentsam_context_digest (
+          id, account_id, digest_type, agent_run_id, session_id,
+          source_hash, digest_hash, raw_size_bytes, reduced_size_bytes,
+          token_count, digest_text, generation_model, compaction_event_id
+        ) VALUES (?, ?, 'session', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).bind(
+        digestId,
+        clean(value.account_id) || null,
+        value.agent_run_id,
+        clean(value.session_id) || null,
+        sourceHash,
+        digestHash,
+        Number(value.raw_size_bytes || 0) || null,
+        Buffer.byteLength(summary, 'utf8'),
+        after || Math.ceil(summary.length / 4),
+        summary,
+        clean(value.model_key) || null,
+        id,
+      ).run();
+    }
+  });
+  return id;
+}

package/src/local/sqlite.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { applyRuntimeMigrations } from './migrations.js';
 
 async function loadSqlite() {
   try {
@@ -77,6 +78,7 @@ export async function initializeLocalSqlite({
   const db = await createLocalSqliteDatabase(resolvedDb);
   try {
     db.exec(schema);
+    await applyRuntimeMigrations(db);
   } finally {
     db.close();
   }