@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/src/go/discover.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import { repositoryRoot, gitEvidence } from '../knowledge/config.js';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const SDK_ROOT = path.resolve(HERE, '../..');
+export const DEFAULT_PRODUCT = 'agentsam-go-worker';
+export const DEFAULT_PRODUCT_REL = path.join('apps', DEFAULT_PRODUCT);
+
+/**
+ * Locate AgentSam Go runtime source without inventing a second implementation.
+ * Prefers apps/agentsam-go-worker/runtime; otherwise any go.mod that declares agentsam-go-worker.
+ */
+export function discoverGoRuntime(cwd = process.cwd()) {
+  const root = repositoryRoot(cwd);
+  const candidates = [
+    path.join(root, DEFAULT_PRODUCT_REL, 'runtime'),
+    path.join(SDK_ROOT, DEFAULT_PRODUCT_REL, 'runtime'),
+    path.join(root, 'runtime'),
+    path.join(root, 'cmd', 'agentsam'),
+  ];
+
+  const found = [];
+  for (const runtimeRoot of candidates) {
+    const modPath = path.join(runtimeRoot, 'go.mod');
+    if (!fs.existsSync(modPath)) continue;
+    const mod = fs.readFileSync(modPath, 'utf8');
+    const moduleMatch = mod.match(/^module\s+(\S+)/m);
+    const serverMain = path.join(runtimeRoot, 'cmd', 'server', 'main.go');
+    const entry = fs.existsSync(serverMain)
+      ? serverMain
+      : findFirstGoMain(runtimeRoot);
+    found.push({
+      runtimeRoot,
+      module: moduleMatch?.[1] || null,
+      goMod: modPath,
+      entry,
+      productRoot: path.dirname(runtimeRoot),
+      packageManifest: path.join(path.dirname(runtimeRoot), 'agentsam.package.json'),
+    });
+  }
+
+  const preferred = found.find((row) => row.module?.includes('agentsam-go-worker')) || found[0] || null;
+  const goTool = probeGoToolchain();
+  const git = gitEvidence(root);
+
+  return {
+    schema: 'agentsam.go-discovery.v1',
+    repository_root: root,
+    sdk_root: SDK_ROOT,
+    go: goTool,
+    git,
+    runtime: preferred,
+    candidates: found,
+    product_exists: Boolean(preferred && fs.existsSync(preferred.packageManifest)),
+  };
+}
+
+function findFirstGoMain(dir) {
+  const stack = [dir];
+  while (stack.length) {
+    const cur = stack.pop();
+    let ents;
+    try { ents = fs.readdirSync(cur, { withFileTypes: true }); } catch { continue; }
+    for (const ent of ents) {
+      if (ent.name === 'vendor' || ent.name === '.git') continue;
+      const full = path.join(cur, ent.name);
+      if (ent.isDirectory()) stack.push(full);
+      else if (ent.name === 'main.go') return full;
+    }
+  }
+  return null;
+}
+
+export function probeGoToolchain() {
+  try {
+    const version = execFileSync('go', ['version'], { encoding: 'utf8' }).trim();
+    const env = execFileSync('go', ['env', 'GOROOT', 'GOVERSION'], { encoding: 'utf8' }).trim().split(/\r?\n/);
+    return { ok: true, version, goroot: env[0] || null, goversion: env[1] || null };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+export function resolveProductRoot(discovery, productName = DEFAULT_PRODUCT) {
+  if (discovery?.runtime?.productRoot && path.basename(discovery.runtime.productRoot) === productName) {
+    return discovery.runtime.productRoot;
+  }
+  const fromSdk = path.join(SDK_ROOT, 'apps', productName);
+  if (fs.existsSync(fromSdk)) return fromSdk;
+  const fromRepo = path.join(discovery.repository_root, 'apps', productName);
+  if (fs.existsSync(fromRepo)) return fromRepo;
+  return fromSdk;
+}

package/src/go/index.js

@@ -0,0 +1,13 @@
+export { discoverGoRuntime, resolveProductRoot, probeGoToolchain, DEFAULT_PRODUCT, SDK_ROOT } from './discover.js';
+export { ensureProductContract, readProductManifest, preflightToolchain } from './contract.js';
+export { buildGoProduct, runGoBuild, runGoTests, runGoVet } from './build.js';
+export { deployGoCloudflare, probeGoDeployment } from './cloudflare.js';
+export { verifyGoProduct } from './verify.js';
+export { applyGoProductRegistry, buildGoProductRegistrySql } from './registry.js';
+export {
+  writeGoBuildReceipt,
+  writeDeploymentReceipt,
+  writeProductRegistryLocal,
+  readLatestStatus,
+  buildProductRow,
+} from './receipts.js';

package/src/go/receipts.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function goStateDir(productRoot) {
+  const dir = path.join(productRoot, '.agentsam', 'go');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function writeGoBuildReceipt(productRoot, receipt) {
+  const dir = goStateDir(productRoot);
+  const file = path.join(dir, 'latest.build-receipt.json');
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
+
+export function writeDeploymentReceipt(productRoot, receipt) {
+  const dir = goStateDir(productRoot);
+  const file = path.join(dir, 'latest.deployment-receipt.json');
+  const payload = {
+    schema: 'agentsam.deployment-receipt.v1',
+    ...receipt,
+  };
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`);
+  return file;
+}
+
+export function writeProductRegistryLocal(productRoot, row) {
+  const dir = goStateDir(productRoot);
+  const file = path.join(dir, 'product.registry.json');
+  const payload = {
+    schema: 'agentsam.product-local-registry.v1',
+    registry: 'agentsam_products',
+    note: 'Local projection + optional remote D1 upsert into agentsam_products / asset_relationships.',
+    row,
+    written_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`);
+  return file;
+}
+
+export function readLatestStatus(productRoot) {
+  const dir = path.join(productRoot, '.agentsam', 'go');
+  const buildPath = path.join(dir, 'latest.build-receipt.json');
+  const deployPath = path.join(dir, 'latest.deployment-receipt.json');
+  const productPath = path.join(dir, 'product.registry.json');
+  return {
+    build: fs.existsSync(buildPath) ? JSON.parse(fs.readFileSync(buildPath, 'utf8')) : null,
+    deployment: fs.existsSync(deployPath) ? JSON.parse(fs.readFileSync(deployPath, 'utf8')) : null,
+    product: fs.existsSync(productPath) ? JSON.parse(fs.readFileSync(productPath, 'utf8')) : null,
+  };
+}
+
+export function buildProductRow({ product, repositoryId, commit, url, health }) {
+  return {
+    slug: product,
+    kind: 'service',
+    name: product,
+    status: health === 'healthy' ? 'deployed' : (health === 'pending' ? 'built' : 'degraded'),
+    repository_id: repositoryId || null,
+    metadata: {
+      runtime: 'go',
+      deployment: {
+        provider: 'cloudflare',
+        mode: 'worker-container',
+        url: url || null,
+        health: health || null,
+      },
+      source: { commit: commit || null },
+      relationships: [
+        { type: 'source_repository', target: repositoryId || null },
+        { type: 'runtime', target: 'go' },
+        { type: 'edge', target: 'cloudflare-worker' },
+      ],
+    },
+  };
+}

package/src/go/registry.js

@@ -0,0 +1,223 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { SDK_ROOT } from './discover.js';
+import { writeProductRegistryLocal } from './receipts.js';
+
+const DEFAULT_DB = 'inneranimalmedia-business';
+const DEFAULT_WRANGLER = 'apps/local-studio/backend/wrangler.jsonc';
+const DEFAULT_REPOSITORY_ID = 'github:samprimeaux/agentsam-sdk';
+
+function quote(value) {
+  if (value == null) return 'NULL';
+  if (typeof value === 'number') return String(value);
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+function json(value) {
+  return JSON.stringify(value);
+}
+
+export function buildGoProductRegistrySql({
+  product = 'agentsam-go-worker',
+  status = 'wired',
+  version = '0.1.0',
+  repositoryId = DEFAULT_REPOSITORY_ID,
+  canonicalPath = 'apps/agentsam-go-worker',
+  packageName = '@inneranimalmedia/agentsam-go-worker',
+  url = null,
+  commit = null,
+  health = null,
+  description = 'AgentSam Go runtime (Worker edge + native Cloudflare Container)',
+} = {}) {
+  const metadata = {
+    runtime: 'go',
+    origin: 'agentsam.go.cloudflare',
+    deployment: {
+      provider: 'cloudflare',
+      mode: 'worker-container',
+      url: url || null,
+      health: health || null,
+    },
+    source: { commit: commit || null },
+    capabilities: ['hash', 'inspect', 'runtime', 'capabilities'],
+    cli_commands: [
+      {
+        id: 'agentsam:go:cloudflare',
+        command: 'agentsam go --cloudflare agentsam-go-worker',
+        description: 'Discover, build, deploy, and verify the Go runtime product',
+      },
+    ],
+  };
+
+  const statements = [];
+  statements.push(
+    `INSERT INTO agentsam_products (
+  slug, name, kind, status, description, repository_id, canonical_path, package_name, version, tags, metadata, updated_at
+) VALUES (
+  ${quote(product)},
+  ${quote(product)},
+  'service',
+  ${quote(status)},
+  ${quote(description)},
+  ${quote(repositoryId)},
+  ${quote(canonicalPath)},
+  ${quote(packageName)},
+  ${quote(version)},
+  ${quote(json(['go', 'cloudflare', 'runtime']))},
+  ${quote(json(metadata))},
+  unixepoch()
+)
+ON CONFLICT(slug) DO UPDATE SET
+  name = excluded.name,
+  kind = excluded.kind,
+  status = excluded.status,
+  description = excluded.description,
+  repository_id = COALESCE(excluded.repository_id, agentsam_products.repository_id),
+  canonical_path = excluded.canonical_path,
+  package_name = excluded.package_name,
+  version = excluded.version,
+  tags = excluded.tags,
+  metadata = excluded.metadata,
+  updated_at = excluded.updated_at;`,
+  );
+
+  const relationships = [
+    {
+      target_type: 'code_repository',
+      target_id: repositoryId,
+      relationship_type: 'sourced_from',
+      metadata: { origin: 'agentsam.go.cloudflare' },
+    },
+    {
+      target_type: 'runtime',
+      target_id: 'go',
+      relationship_type: 'runs_on',
+      metadata: { origin: 'agentsam.go.cloudflare' },
+    },
+    {
+      target_type: 'cloudflare_worker',
+      target_id: product,
+      relationship_type: 'deployed_as',
+      metadata: { origin: 'agentsam.go.cloudflare', url: url || null },
+    },
+    {
+      target_type: 'cli_command',
+      target_id: 'agentsam:go:cloudflare',
+      relationship_type: 'exposes_command',
+      metadata: {
+        origin: 'agentsam.go.cloudflare',
+        command: 'agentsam go --cloudflare agentsam-go-worker',
+      },
+    },
+  ];
+
+  for (const rel of relationships) {
+    statements.push(
+      `INSERT INTO asset_relationships (source_type, source_id, target_type, target_id, relationship_type, metadata)
+SELECT 'agentsam_product', p.id, ${quote(rel.target_type)}, ${quote(rel.target_id)}, ${quote(rel.relationship_type)}, ${quote(json(rel.metadata))}
+FROM agentsam_products p WHERE p.slug = ${quote(product)}
+ON CONFLICT(source_type, source_id, target_type, target_id, relationship_type)
+DO UPDATE SET metadata = excluded.metadata;`,
+    );
+  }
+
+  return statements.join('\n');
+}
+
+export function applyGoProductRegistry({
+  productRoot,
+  product = 'agentsam-go-worker',
+  cwd = SDK_ROOT,
+  status = 'wired',
+  url = null,
+  commit = null,
+  health = null,
+  dryRun = false,
+  skipRemote = false,
+  spawn = spawnSync,
+  repositoryId = DEFAULT_REPOSITORY_ID,
+} = {}) {
+  const sql = buildGoProductRegistrySql({
+    product,
+    status,
+    url,
+    commit,
+    health,
+    repositoryId,
+  });
+
+  const localRow = {
+    slug: product,
+    kind: 'service',
+    name: product,
+    status,
+    repository_id: repositoryId,
+    canonical_path: 'apps/agentsam-go-worker',
+    package_name: '@inneranimalmedia/agentsam-go-worker',
+    metadata: {
+      runtime: 'go',
+      deployment: { provider: 'cloudflare', mode: 'worker-container', url, health },
+      source: { commit },
+    },
+  };
+  const localPath = productRoot ? writeProductRegistryLocal(productRoot, localRow) : null;
+
+  if (dryRun || skipRemote) {
+    return {
+      ok: true,
+      remote: false,
+      skipped: true,
+      reason: dryRun ? 'dry_run' : 'skip_remote',
+      sql,
+      localPath,
+      sql_sha256: createHash('sha256').update(sql).digest('hex'),
+    };
+  }
+
+  const wranglerConfig = path.resolve(cwd, DEFAULT_WRANGLER);
+  const tmpFile = path.join(os.tmpdir(), `agentsam-go-registry-${Date.now()}-${randomBytes(3).toString('hex')}.sql`);
+  fs.writeFileSync(tmpFile, `${sql}\n`, 'utf8');
+
+  try {
+    const args = ['d1', 'execute', DEFAULT_DB, '--remote', '--yes', `--file=${tmpFile}`];
+    if (fs.existsSync(wranglerConfig)) args.push('--config', wranglerConfig);
+
+    const wranglerJs = path.join(cwd, 'apps/agentsam-go-worker/node_modules/wrangler/bin/wrangler.js');
+    const localStudioWrangler = path.join(cwd, 'apps/local-studio/node_modules/wrangler/bin/wrangler.js');
+    const rootWrangler = path.join(cwd, 'node_modules/wrangler/bin/wrangler.js');
+    let command = 'npx';
+    let cmdArgs = ['--yes', 'wrangler', ...args];
+    for (const candidate of [wranglerJs, localStudioWrangler, rootWrangler]) {
+      if (fs.existsSync(candidate)) {
+        command = process.execPath;
+        cmdArgs = [candidate, ...args];
+        break;
+      }
+    }
+
+    const res = spawn(command, cmdArgs, {
+      cwd,
+      encoding: 'utf8',
+      env: { ...process.env },
+    });
+    if (res.status !== 0) {
+      const err = new Error('d1_registry_upsert_failed');
+      err.detail = `${res.stdout || ''}\n${res.stderr || ''}`.trim().slice(0, 2000);
+      throw err;
+    }
+
+    return {
+      ok: true,
+      remote: true,
+      database: DEFAULT_DB,
+      localPath,
+      sql_sha256: createHash('sha256').update(sql).digest('hex'),
+      stdout: (res.stdout || '').trim().slice(0, 500),
+    };
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+  }
+}

package/src/go/verify.js

@@ -0,0 +1,31 @@
+import { readLatestStatus } from './receipts.js';
+import { probeGoDeployment } from './cloudflare.js';
+import { runGoTests, runGoVet } from './build.js';
+
+export async function verifyGoProduct({
+  productRoot,
+  runtimeRoot,
+  url = null,
+  fetchImpl = globalThis.fetch,
+  skipLive = false,
+} = {}) {
+  const status = readLatestStatus(productRoot);
+  const tests = runtimeRoot ? runGoTests(runtimeRoot) : { ok: false, error: 'no_runtime' };
+  const vet = runtimeRoot ? runGoVet(runtimeRoot) : { ok: false, error: 'no_runtime' };
+  const liveUrl = url || status.deployment?.url || null;
+  let live = { skipped: true, ok: false };
+  if (!skipLive && liveUrl) {
+    live = await probeGoDeployment(liveUrl, { fetchImpl });
+  }
+
+  const ok = Boolean(tests.ok && vet.ok && (skipLive || !liveUrl || live.ok));
+  return {
+    schema: 'agentsam.go-verify.v1',
+    ok,
+    tests: { go_test: tests.ok, go_vet: vet.ok },
+    deployment: status.deployment,
+    build: status.build,
+    product: status.product,
+    live,
+  };
+}

package/src/index.js

@@ -5,6 +5,21 @@ import pkg from '../package.json' with { type: 'json' };
 export { AgentSam } from './AgentSam.js';
 export { routeIntent } from './lib/router.js';
 export { searchToolCards, toToolCard, hydrateToolSchemas } from './tools/index.js';
+export {
+  AGENTSAM_PLUGIN_SCHEMA_VERSION,
+  AGENTSAM_MCP_PLUGIN_MANIFEST,
+  CLOUDFLARE_PLUGIN_MANIFEST,
+  normalizePluginKey,
+  normalizePluginManifest,
+  installPlugin,
+  listPlugins,
+  listPluginTools,
+  recordPluginHealthCheck,
+  recordToolCall,
+  createPluginRuntime,
+  createPluginCapabilityAdapter,
+  executeAgentSamTool,
+} from './plugins/index.js';
 export { getToolCatalog } from './lib/tools.js';
 export { scaffoldProject } from './lib/scaffold.js';
 export {
@@ -38,6 +53,7 @@ export {
   getCapabilityManifest,
   listCapabilities,
   repositorySnapshot,
+  terminalExec,
 } from './capabilities/index.js';
 export { getPreset, listPresets, resolvePreset, getAddon, listAddons } from './presets/index.js';
 export {
@@ -77,6 +93,8 @@ export {
   listModelCatalog,
   getModelRecord,
   calculateModelCost,
+  normalizeModelPolicy,
+  loadModelPolicy,
 } from './models/index.js';
 export {
   AGENT_EVENT_TYPES,
@@ -94,7 +112,47 @@ export {
   extractOpenAIFunctionCalls,
 } from './providers/index.js';
 export {
+  AgentSamError,
   AgentSamDiagnosticError,
+  ERROR_SCHEMA_VERSION,
+  ERROR_CODE,
+  ERROR_REASON,
+  ERROR_SEVERITY,
+  ERROR_SOURCE_KIND,
+  ERROR_RESOLUTION_OWNER,
+  ERROR_DOMAIN,
+  REMEDIATION_ACTION,
+  createErrorEnvelope,
+  normalizeError,
+  asAgentSamError,
+  serializeError,
+  parseError,
+  fingerprintError,
+  shouldRetry,
+  retryDelayMs,
+  toHttpError,
+  fromHttpError,
+  renderError,
+  classifyFailure,
+  classifyProviderFailure,
+  classifyOpenAIFailure,
+  classifyAnthropicFailure,
+  classifyGoogleAIFailure,
+  classifyGeminiFailure,
+  classifyCursorFailure,
+  classifyGitHubFailure,
+  classifyCloudflareFailure,
+  classifyDockerFailure,
+  classifyGcpFailure,
+  classifyCadFailure,
+  classifyFreeCadFailure,
+  classifyOpenScadFailure,
+  classifyBlenderFailure,
+  classifyMeshyFailure,
+  classifyDeviceFailure,
+  classifyInternalFailure,
+  classifyProcessFailure,
+  classifyOAuthFailure,
   classifyOpenAIError,
   createOpenAIHttpError,
   createProcessDiagnosticError,
@@ -118,9 +176,50 @@ export {
   createCapabilityAdapter,
   buildAgentToolSurface,
   capabilityFunctionName,
+  runAgentSamModelTurn,
+  runAgentSamTurn,
   runResponsesAgent,
 } from './agent/index.js';
-export { listContextEvalFixtures, evaluateContextFixture } from './eval/index.js';
+export {
+  listContextEvalFixtures,
+  evaluateContextFixture,
+  startLiveEvalRun,
+  getLiveEvalStatus,
+  finishLiveEvalRun,
+} from './eval/index.js';
+export {
+  MCP_AUTHORITY_SCHEMA,
+  SERVER_CATALOG_CACHE_SCHEMA,
+  DEFAULT_SERVER_CATALOG_URL,
+  SEED_MCP_SERVER_CATALOG,
+  MCP_PRESETS,
+  readMcpServer,
+  writeMcpServer,
+  listMcpServers,
+  deleteMcpServer,
+  fetchMcpServerCatalog,
+  listKnownServers,
+  resolveServerPreset,
+  SUPPORTED_CLIENTS,
+  DEFAULT_CLIENT_REGISTRY_URL,
+  CLIENT_REGISTRY_CACHE_SCHEMA,
+  SEED_EXTERNAL_CLIENT_REGISTRY,
+  fetchExternalClientRegistry,
+  listRegisteredClients,
+  isClientRegistered,
+  getClientConfigPath,
+  detectInstalledClients,
+  syncServerToClient,
+  removeServerFromClient,
+  inspectClientAdapter,
+  pingMcpServer,
+  listMcpTools,
+  callMcpTool,
+  recordToolReceipt,
+  getSessionToolReceipts,
+  clearSessionToolReceipts,
+  summarizeToolReceipts,
+} from './mcp/index.js';
 
 export {
   createIdentityClient,

package/src/knowledge/config.js

@@ -31,31 +31,39 @@ export function validateConfig(input) {
     if (!object || typeof object !== 'object' || Array.isArray(object)) throw new Error(`${label} must be an object.`);
     for (const key of Object.keys(object)) if (!keys.includes(key)) throw new Error(`Unknown ${label} field: ${key}`);
   };
-  allowed(c, ['version', 'repository_id', 'workspace_id', 'scope', 'chunking', 'embedding', 'storage'], 'configuration');
+  allowed(c, ['version', 'repository_id', 'project_key', 'workspace_id', 'scope', 'chunking', 'embedding', 'storage', 'lane'], 'configuration');
   allowed(c.scope, ['name', 'include', 'exclude'], 'scope');
   allowed(c.chunking, ['max_chars'], 'chunking');
   allowed(c.embedding, ['provider', 'model', 'revision', 'dimensions', 'parameters'], 'embedding');
   allowed(c.storage, ['driver', 'connection_env'], 'storage');
-  if (c.version !== 1) throw new Error('Unsupported knowledge configuration version.');
+  if (c.lane != null) allowed(c.lane, ['id', 'backend', 'resource', 'binding', 'index', 'metric'], 'lane');
+  if (![1, 2].includes(c.version)) throw new Error('Unsupported knowledge configuration version.');
   if (typeof c.repository_id !== 'string' || !c.repository_id.trim()) throw new Error('repository_id is required.');
+  if (c.project_key != null && (typeof c.project_key !== 'string' || !c.project_key.trim())) throw new Error('project_key must be a non-empty string when present.');
   if (c.workspace_id != null && (typeof c.workspace_id !== 'string' || !c.workspace_id.trim())) throw new Error('workspace_id must be a non-empty string when present.');
   if (typeof c.scope?.name !== 'string' || !c.scope.name.trim() || !Array.isArray(c.scope.include) || !c.scope.include.length) throw new Error('A named scope with at least one include path is required.');
   c.scope.include = [...new Set(c.scope.include.map(relativeSelection))].sort();
   c.scope.exclude = [...new Set((c.scope.exclude || []).map(relativeSelection))].sort();
   if (!Number.isInteger(c.chunking?.max_chars) || c.chunking.max_chars < 256 || c.chunking.max_chars > 12000) throw new Error('chunking.max_chars must be 256..12000.');
   const e = c.embedding;
-  if (!e || ['provider', 'model', 'revision'].some(k => typeof e[k] !== 'string' || !e[k].trim()) || !Number.isInteger(e.dimensions) || e.dimensions < 1 || e.dimensions > 3072) throw new Error('Embedding provider, model, revision and dimensions (1..3072) are required.');
+  const disabledEmbedding = e?.provider === 'none' && e?.model === 'none' && e?.dimensions === 0;
+  if (!e || ['provider', 'model', 'revision'].some(k => typeof e[k] !== 'string' || !e[k].trim()) || !Number.isInteger(e.dimensions) || (!disabledEmbedding && (e.dimensions < 1 || e.dimensions > 3072))) throw new Error('Embedding provider, model, revision and dimensions (1..3072, or explicit none/0) are required.');
   if (!e.parameters || typeof e.parameters !== 'object' || Array.isArray(e.parameters)) throw new Error('Embedding parameters must be an object.');
   if (!['sqlite', 'postgres'].includes(c.storage?.driver)) throw new Error('storage.driver must be sqlite or postgres.');
   if (c.storage.driver === 'postgres' && !/^[A-Z_][A-Z0-9_]*$/.test(c.storage.connection_env || '')) throw new Error('Postgres requires a connection_env name, never a connection string in config.');
+  if (c.lane) {
+    if (typeof c.lane.id !== 'string' || !c.lane.id.trim() || !['local_exact', 'postgres_pgvector', 'supabase_pgvector', 'cloudflare_vectorize'].includes(c.lane.backend)) throw new Error('Knowledge lane requires an explicit supported backend.');
+    if (c.lane.backend === 'cloudflare_vectorize' && (!c.lane.binding || !c.lane.index)) throw new Error('Cloudflare Vectorize lanes require explicit binding and index.');
+  }
   return c;
 }
 export function defaultConfig({ include = ['.'], exclude = [], scope = 'default', target = 'local', dimensions = 768, repositoryId = '' } = {}) {
   if (!['local', 'production'].includes(target)) throw new Error('target must be local or production.');
-  return validateConfig({ version: 1, repository_id: String(repositoryId || '').trim() || randomUUID(),
+  return validateConfig({ version: 2, repository_id: String(repositoryId || '').trim() || randomUUID(), project_key: String(repositoryId || '').trim() || undefined,
     scope: { name: scope, include, exclude }, chunking: { max_chars: 4000 },
     embedding: { provider: 'gemini', model: 'gemini-embedding-2', revision: '1', dimensions, parameters: { task: 'code retrieval' } },
-    storage: target === 'local' ? { driver: 'sqlite' } : { driver: 'postgres', connection_env: 'AGENTSAM_DATABASE_URL' } });
+    storage: target === 'local' ? { driver: 'sqlite' } : { driver: 'postgres', connection_env: 'AGENTSAM_DATABASE_URL' },
+    lane: { id: `${scope}-default`, backend: target === 'local' ? 'local_exact' : 'postgres_pgvector', resource: null, binding: null, index: null, metric: 'cosine' } });
 }
 export function readConfig(root) { return validateConfig(JSON.parse(fs.readFileSync(path.join(root, CONFIG_PATH), 'utf8'))); }
 export function initRepository(root, options = {}) {