@inneranimalmedia/agentsam-sdk 1.0.1 → 1.1.1

package/DEVELOPMENT.md

@@ -0,0 +1,55 @@
+# Developing agentsam-sdk with Inner Animal Media
+
+## Local smoke test
+
+```bash
+cd agentsam-sdk
+npm test
+```
+
+## Link into a scaffolded project
+
+```bash
+cd agentsam-sdk && npm link
+cd /path/to/your-project && npm link @inneranimalmedia/agentsam-sdk
+npm run dev
+```
+
+## Link into inneranimalmedia (monorepo-style)
+
+From the platform repo:
+
+```bash
+cd inneranimalmedia
+npm link ../agentsam-sdk
+```
+
+Then in any Worker or script:
+
+```js
+import { AgentSam } from '@inneranimalmedia/agentsam-sdk';
+```
+
+## Non-interactive init (CI / smoke)
+
+```bash
+npx agentsam init \
+  --name my-agent \
+  --lane fullstack \
+  --provider cloudflare \
+  --agent orchestrator \
+  --yes
+```
+
+## Publish checklist
+
+1. `npm test` passes
+2. Bump version in `package.json`
+3. `npm publish --access public`
+4. Tag: `git tag v1.1.1 && git push origin v1.1.1`
+
+## Known gaps (roadmap)
+
+- `agentsam deploy`, `status`, `logs` — not implemented yet
+- CMS lane in README — CLI has 4 lanes today (Full Stack, Data, CRM, Creative)
+- Published API route may differ; stub mode works without `AGENTSAM_API_KEY`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Inner Animal Media
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# Agent Sam SDK
+
+> The AI agent layer for developers who need more than a chatbot.
+
+Agent Sam is a full-stack autonomous agent SDK built on Cloudflare Workers, D1, Supabase, Durable Objects, and MCP — designed to converse, plan, and execute real work across your entire stack. CMS websites, full-stack applications, data pipelines, creative workflows, terminal execution, deployments, and multi-step agentic pipelines — all through one unified agent interface.
+
+---
+
+## What is Agent Sam?
+
+Agent Sam is a platform operator AI. It sits on top of your infrastructure and can:
+
+- **Understand intent** — natural language in, real actions out
+- **Execute across surfaces** — terminal, database, browser, CAD, deploy, MCP tools
+- **Route intelligently** — local machine, cloud VM, or sandboxed environment based on context
+- **Gate high-risk actions** — approval flows before anything destructive runs
+- **Leave an audit trail** — every tool call, command run, and decision is logged
+
+It is not a wrapper around a chat API. It is a command fabric with a conversation interface.
+
+---
+
+## Quickstart
+
+\`\`\`bash
+npx @inneranimalmedia/agentsam-sdk init
+\`\`\`
+
+Non-interactive (CI / scripts):
+
+\`\`\`bash
+npx @inneranimalmedia/agentsam-sdk init \\
+  --name my-agent \\
+  --lane fullstack \\
+  --provider cloudflare \\
+  --agent orchestrator \\
+  --yes
+\`\`\`
+
+Scaffolded workers expose \`GET /health\` and \`POST /chat\` immediately (stub mode without an API key).
+
+See [DEVELOPMENT.md](./DEVELOPMENT.md) for linking the SDK into Inner Animal Media locally.
+
+---
+
+## Installation
+
+\`\`\`bash
+npm install @inneranimalmedia/agentsam-sdk
+\`\`\`
+
+---
+
+## Lanes
+
+| Lane | Best For |
+|------|----------|
+| **Full Stack** | End-to-end apps — agent chat, terminal, deploy, D1, R2, Durable Objects, KV |
+| **CMS** | Content-managed websites — pages, assets, themes, navigation, live edit |
+| **Data Solutions** | Database ops, migrations, queries, Supabase pgvector, Hyperdrive pipelines |
+| **Customer Management** | CRM, contacts, billing, client workflows, multi-tenant isolation |
+| **Creative & Design** | CAD, 3D, media generation, content pipelines |
+
+---
+
+## Agents
+
+| Agent | Role |
+|-------|------|
+| **Orchestrator** | General purpose — routes across all lanes and tools |
+| **CMS Agent** | Pages, sections, assets, themes, publishing workflows |
+| **Data Agent** | D1, Supabase, Hyperdrive, migrations, vector search |
+| **CRM Agent** | Customer records, contacts, billing, client isolation |
+| **Creative Agent** | Design commands, 3D generation, CAD, media pipelines |
+
+---
+
+## How It Works
+
+\`\`\`
+User Intent (chat or CLI)
+        ↓
+   Agent Sam — intent classification + command match
+        ↓
+   Tool Catalog (D1) — policy check + approval gate
+        ↓
+   Execution — terminal / D1 / Supabase / R2 / KV / DO / browser / deploy / MCP
+        ↓
+   Telemetry — every action logged, measured, improvable
+\`\`\`
+
+Capabilities are data-driven — new tools are added via D1, not Worker redeployments. The same tool catalog powers the dashboard, the CLI, and any MCP-connected client like Cursor or Claude Desktop.
+
+---
+
+## Infrastructure
+
+Agent Sam scaffolds and operates across the full Cloudflare + Supabase stack:
+
+| Layer | Technology | Role |
+|-------|------------|------|
+| **Compute** | Cloudflare Workers | Edge runtime, API, agent dispatch |
+| **Relational DB** | D1 (SQLite) | Tool catalog, sessions, telemetry, CMS, auth |
+| **Vector DB** | Supabase pgvector via Hyperdrive | RAG, semantic search, agent memory |
+| **Object Storage** | R2 | Assets, media, bundles, CMS content |
+| **Key-Value** | Workers KV | Cache, CMS drafts, feature flags |
+| **Stateful Sessions** | Durable Objects | Terminal sessions, collab, real-time state |
+| **Terminal** | ExecOS over cloudflared tunnel | Shell execution, deploy, git, wrangler |
+| **AI Router** | Anthropic + OpenAI | Adaptive Thompson sampling across models |
+| **Protocol** | MCP (Model Context Protocol) | External agent surface for Cursor, Claude, etc. |
+
+---
+
+## Execution Lanes
+
+Agent Sam routes work to the right environment automatically:
+
+| Lane | Environment | When |
+|------|-------------|------|
+| Local | Your machine | Fastest dev loop |
+| Cloud | Always-on VM via tunnel | Machine asleep or offsite |
+| Sandbox | Isolated workspace | Safe experiments, tenant isolation |
+
+---
+
+## What Gets Scaffolded
+
+Running \`agentsam init\` generates a production-ready project for your lane:
+
+**All lanes include:**
+- \`agentsam.config.js\` — project config, lane, provider, agent
+- \`wrangler.toml\` — Worker, D1, R2, KV, Durable Object bindings
+- \`.env.example\` — all required secrets pre-listed
+- \`src/index.js\` — Worker entry point wired to your agent
+- \`README.md\` — setup and deploy instructions
+
+**CMS lane adds:**
+- Page, section, asset, and theme schema migrations
+- CMS worker with live edit, draft/publish, and R2 asset pipeline
+
+**Data lane adds:**
+- D1 + Supabase Hyperdrive connection config
+- Vector embedding pipeline scaffold
+- Migration templates for core data models
+
+**Full Stack adds:**
+- Durable Object session scaffold
+- Auth tables and session management
+- Full agent chat + tool loop worker
+
+---
+
+## Multi-Tenant & Client Policy
+
+Agent Sam is built for isolation from the ground up:
+
+- Each user or client gets a scoped workspace
+- Terminal execution is path-isolated — no cross-tenant access
+- AI usage is policy-gated — BYOK, managed, or disabled per client
+- D1 and R2 are scoped per tenant at the binding level
+- Every action produces an audit trail
+
+---
+
+## Roadmap
+
+- [ ] \`agentsam deploy\` — push your project from CLI
+- [ ] \`agentsam status\` — live agent and infrastructure health
+- [ ] \`agentsam logs\` — tail tool call and command logs
+- [ ] \`agentsam kit\` — install pre-built capability kits
+- [ ] Kit marketplace — CMS, ecommerce, nonprofit, SaaS starters
+- [ ] BYOK AI key support per project
+
+---
+
+## Built By
+
+[Inner Animal Media](https://inneranimalmedia.com) — Agent Sam is the operator brain behind the Inner Animal Media platform. The SDK is how we share that infrastructure with other developers.
+
+---
+
+## License
+
+MIT

package/package.json

@@ -1,14 +1,33 @@
 {
   "name": "@inneranimalmedia/agentsam-sdk",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Agent Sam is a full-stack AI agent SDK for autonomous task execution — covering data management, creative workflows, design commands, and multi-step agentic pipelines.",
-  "main": "src/index.js",
   "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
   "bin": {
-    "agentsam": "src/cli.js"
+    "agentsam": "./src/cli.js"
   },
+  "files": [
+    "src",
+    "test",
+    "README.md",
+    "LICENSE",
+    "DEVELOPMENT.md"
+  ],
   "scripts": {
-    "test": "node src/index.js"
+    "test": "node test/smoke.mjs",
+    "smoke": "node test/smoke.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "repository": {
     "type": "git",

package/src/AgentSam.js

@@ -0,0 +1,67 @@
+import { json, notFound, readJson } from './lib/responses.js';
+import { createSession, getSession } from './lib/sessions.js';
+import { routeIntent } from './lib/router.js';
+import { getToolCatalog } from './lib/tools.js';
+
+export class AgentSam {
+  constructor(options = {}) {
+    this.env = options.env ?? {};
+    this.agent = options.agent ?? 'orchestrator';
+    this.lane = options.lane ?? 'fullstack';
+    this.project = options.project ?? 'agentsam-project';
+  }
+
+  async handle(request) {
+    const url = new URL(request.url);
+    const path = url.pathname.replace(/\/$/, '') || '/';
+
+    if (request.method === 'GET' && path === '/api/health') {
+      return json({ ok: true, service: 'AgentSam', agent: this.agent, lane: this.lane, status: 'online' });
+    }
+
+    if (request.method === 'GET' && path === '/api/agentsam/info') {
+      return json({
+        ok: true,
+        name: 'AgentSam SDK',
+        project: this.project,
+        agent: this.agent,
+        lane: this.lane,
+        capabilities: getToolCatalog(this.lane).map((tool) => tool.name),
+      });
+    }
+
+    if (request.method === 'POST' && path === '/api/agentsam/session') {
+      const body = await readJson(request);
+      const session = await createSession({ env: this.env, agent: this.agent, lane: this.lane, goal: body.goal });
+      return json({ ok: true, session });
+    }
+
+    if (request.method === 'GET' && path.startsWith('/api/agentsam/session/')) {
+      const sessionId = path.split('/').pop();
+      const session = await getSession({ env: this.env, sessionId });
+      if (!session) return json({ ok: false, error: 'session_not_found' }, 404);
+      return json({ ok: true, session });
+    }
+
+    if (request.method === 'POST' && path === '/api/agentsam/message') {
+      const body = await readJson(request);
+      const result = routeIntent({
+        message: body.message ?? body.goal ?? '',
+        agent: body.agent ?? this.agent,
+        lane: body.lane ?? this.lane,
+      });
+
+      return json({
+        ok: true,
+        session_id: body.session_id ?? null,
+        agent: result.agent,
+        lane: result.lane,
+        intent: result.intent,
+        next_steps: result.next_steps,
+        requires_approval: result.requires_approval,
+      });
+    }
+
+    return notFound();
+  }
+}

package/src/cli.js

@@ -1,16 +1,265 @@
 #!/usr/bin/env node
 
-const command = process.argv[2];
+import readline from 'readline';
+import pkg from '../package.json' with { type: 'json' };
+import { scaffoldProject } from './lib/scaffold.js';
 
-if (command === 'init') {
-  console.log('Initializing Agent Sam project...');
-} else {
+const VERSION = pkg.version;
+
+function createPrompt() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    ask: (q) => new Promise((resolve) => rl.question(q, resolve)),
+    close: () => rl.close(),
+  };
+}
+
+const LANES = {
+  '1': 'Full Stack',
+  '2': 'CMS',
+  '3': 'Data Solutions',
+  '4': 'Customer Management',
+  '5': 'Creative & Design',
+};
+
+const LANE_BY_SLUG = {
+  fullstack: 'Full Stack',
+  cms: 'CMS',
+  data: 'Data Solutions',
+  crm: 'Customer Management',
+  creative: 'Creative & Design',
+};
+
+const PROVIDERS = {
+  '1': 'Cloudflare Workers',
+  '2': 'GitHub + Cloudflare',
+  '3': 'Local / Self-hosted',
+};
+
+const PROVIDER_BY_SLUG = {
+  cloudflare: 'Cloudflare Workers',
+  github: 'GitHub + Cloudflare',
+  local: 'Local / Self-hosted',
+};
+
+const AGENTS = {
+  '1': 'orchestrator',
+  '2': 'cms',
+  '3': 'data',
+  '4': 'crm',
+  '5': 'creative',
+};
+
+function laneKeyFromLabel(label) {
+  const entry = Object.entries(LANES).find(([, v]) => v === label);
+  return entry?.[0] ?? '1';
+}
+
+function printHelp() {
   console.log(`
-Agent Sam SDK — CLI
+  Agent Sam SDK — CLI v${VERSION}
 
-Usage:
-  agentsam init        Initialize a new Agent Sam project
+  Usage:
+    agentsam init [options]     Scaffold a new Agent Sam project
+    agentsam --version          Print version
+    agentsam --help             Show this help
 
-Version: 1.0.0
+  Init options (non-interactive):
+    --name <name>               Project directory name
+    --lane <fullstack|cms|data|crm|creative>
+    --provider <cloudflare|github|local>
+    --agent <orchestrator|cms|data|crm|creative>
+    --cf-account <id>           Cloudflare account ID
+    --yes                       Skip confirmation prompt
   `);
 }
+
+function parseInitArgs(argv) {
+  const opts = {
+    projectName: '',
+    lane: '',
+    provider: '',
+    agent: '',
+    cfAccountId: '',
+    yes: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--yes' || arg === '-y') opts.yes = true;
+    else if (arg === '--name') opts.projectName = argv[++i] || '';
+    else if (arg === '--lane') {
+      const slug = argv[++i] || '';
+      opts.lane = LANE_BY_SLUG[slug] || slug;
+    } else if (arg === '--provider') {
+      const slug = argv[++i] || '';
+      opts.provider = PROVIDER_BY_SLUG[slug] || slug;
+    } else if (arg === '--agent') opts.agent = argv[++i] || '';
+    else if (arg === '--cf-account') opts.cfAccountId = argv[++i] || '';
+  }
+
+  return opts;
+}
+
+async function runInit(config) {
+  const {
+    projectName,
+    lane,
+    provider,
+    agent,
+    cfAccountId = '',
+    yes = false,
+    prompt = null,
+  } = config;
+
+  const safeDir = projectName.trim();
+  console.log(`
+  ┌─────────────────────────────────────┐
+  │  Agent Sam Project Config           │
+  ├─────────────────────────────────────┤
+  │  Project:   ${safeDir.padEnd(25)}│
+  │  Lane:      ${lane.padEnd(25)}│
+  │  Provider:  ${provider.padEnd(25)}│
+  │  Agent:     ${agent.padEnd(25)}│
+  │  CF Acct:   ${(cfAccountId || 'not set').padEnd(25)}│
+  └─────────────────────────────────────┘
+  `);
+
+  let confirm = 'y';
+  if (!yes && prompt) {
+    confirm = await prompt.ask('  Scaffold project? (y/n): ');
+  }
+
+  if (confirm.toLowerCase() === 'y') {
+    try {
+      const dir = scaffoldProject({
+        projectName: safeDir,
+        lane,
+        provider,
+        agent,
+        cfAccountId,
+        sdkVersion: VERSION,
+      });
+      console.log(`
+  ✓ Project created at ${dir}
+
+  Next steps:
+    cd ${dir.split('/').pop()}
+    cp .env.example .env
+    npm install
+    npm run smoke
+    npm run dev
+    `);
+    } catch (error) {
+      console.error(`\n  ✗ ${error.message}\n`);
+      process.exitCode = 1;
+    }
+  } else {
+    console.log('\n  Cancelled.\n');
+  }
+}
+
+async function initInteractive(partial = {}) {
+  const prompt = createPrompt();
+
+  console.log(`
+  ╔═══════════════════════════════════╗
+  ║       Agent Sam SDK — Init        ║
+  ╚═══════════════════════════════════╝
+  `);
+
+  const projectName = partial.projectName || (await prompt.ask('  Project name: '));
+
+  if (!partial.lane) {
+    console.log(`
+  Select a lane:
+    1) Full Stack
+    2) CMS
+    3) Data Solutions
+    4) Customer Management
+    5) Creative & Design
+  `);
+  }
+  const laneKey = partial.lane ? laneKeyFromLabel(partial.lane) : await prompt.ask('  Lane [1-5]: ');
+  const lane = partial.lane || LANES[laneKey] || 'Full Stack';
+
+  console.log(`
+  Select a provider:
+    1) Cloudflare Workers
+    2) GitHub + Cloudflare
+    3) Local / Self-hosted
+  `);
+  const providerKey = partial.provider
+    ? Object.entries(PROVIDERS).find(([, v]) => v === partial.provider)?.[0] || '1'
+    : await prompt.ask('  Provider [1-3]: ');
+  const provider = partial.provider || PROVIDERS[providerKey] || 'Cloudflare Workers';
+
+  if (!partial.agent) {
+    console.log(`
+  Select your default Agent Sam:
+    1) Orchestrator    — general purpose, routes to all lanes
+    2) CMS Agent       — pages, sections, assets, publishing workflows
+    3) Data Agent      — database ops, migrations, queries
+    4) CRM Agent       — customer management, contacts, billing
+    5) Creative Agent  — design, 3D, media, content
+  `);
+  }
+  const agentKey = partial.agent
+    ? Object.entries(AGENTS).find(([, v]) => v === partial.agent)?.[0] || '1'
+    : await prompt.ask('  Agent [1-5]: ');
+  const agent = partial.agent || AGENTS[agentKey] || 'orchestrator';
+
+  const cfAccountId =
+    partial.cfAccountId !== undefined && partial.cfAccountId !== ''
+      ? partial.cfAccountId
+      : await prompt.ask('  Cloudflare Account ID (enter to skip): ');
+
+  await runInit({
+    projectName,
+    lane,
+    provider,
+    agent,
+    cfAccountId,
+    yes: partial.yes,
+    prompt,
+  });
+
+  prompt.close();
+}
+
+async function initFromArgs(argv) {
+  const opts = parseInitArgs(argv);
+  if (!opts.projectName) {
+    console.error('\n  ✗ --name is required for non-interactive init.\n');
+    process.exit(1);
+  }
+  await runInit({
+    projectName: opts.projectName,
+    lane: opts.lane || 'Full Stack',
+    provider: opts.provider || 'Cloudflare Workers',
+    agent: opts.agent || 'orchestrator',
+    cfAccountId: opts.cfAccountId,
+    yes: true,
+    prompt: null,
+  });
+}
+
+const command = process.argv[2];
+const rest = process.argv.slice(3);
+
+if (command === '--version' || command === '-v') {
+  console.log(VERSION);
+} else if (command === '--help' || command === '-h' || !command) {
+  printHelp();
+} else if (command === 'init') {
+  const hasFlags = rest.some((a) => a.startsWith('--'));
+  if (hasFlags) {
+    await initFromArgs(rest);
+  } else {
+    await initInteractive({});
+  }
+} else {
+  console.error(`\n  Unknown command: ${command}\n`);
+  printHelp();
+  process.exit(1);
+}

package/src/index.js

@@ -1,5 +1,11 @@
-// @inneranimalmedia/agentsam-sdk
-// Agent Sam SDK — entry point
+// @inneranimalmedia/agentsam-sdk — public API
 
-export const version = '1.0.0';
-export const name = 'agentsam-sdk';
+import pkg from '../package.json' with { type: 'json' };
+
+export { AgentSam } from './AgentSam.js';
+export { routeIntent } from './lib/router.js';
+export { getToolCatalog } from './lib/tools.js';
+export { scaffoldProject } from './lib/scaffold.js';
+
+export const version = pkg.version;
+export const name = pkg.name;

package/src/lib/responses.js

@@ -0,0 +1,21 @@
+export function json(data, status = 200, headers = {}) {
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: {
+      'content-type': 'application/json; charset=utf-8',
+      ...headers,
+    },
+  });
+}
+
+export function notFound() {
+  return json({ ok: false, error: 'not_found' }, 404);
+}
+
+export async function readJson(request) {
+  try {
+    return await request.json();
+  } catch {
+    return {};
+  }
+}

package/src/lib/router.js

@@ -0,0 +1,51 @@
+export function routeIntent({ message = '', agent = 'orchestrator', lane = 'fullstack' }) {
+  const text = String(message).toLowerCase();
+
+  if (/delete|drop table|destroy|wipe|purge|production/.test(text)) {
+    return {
+      agent,
+      lane,
+      intent: 'high_risk_action',
+      requires_approval: true,
+      next_steps: ['Summarize intended change', 'Request explicit approval', 'Run only after approval'],
+    };
+  }
+
+  if (/page|cms|publish|section|hero|content/.test(text)) {
+    return {
+      agent: 'cms',
+      lane: 'cms',
+      intent: 'cms_build',
+      requires_approval: false,
+      next_steps: ['Create page outline', 'Attach visual assets', 'Prepare draft for preview'],
+    };
+  }
+
+  if (/database|sql|query|migration|schema|supabase|d1/.test(text)) {
+    return {
+      agent: 'data',
+      lane: 'data',
+      intent: 'data_task',
+      requires_approval: false,
+      next_steps: ['Inspect schema', 'Draft safe query or migration', 'Return reviewable plan'],
+    };
+  }
+
+  if (/design|3d|cad|media|video|image|creative/.test(text)) {
+    return {
+      agent: 'creative',
+      lane: 'creative',
+      intent: 'creative_task',
+      requires_approval: false,
+      next_steps: ['Create production brief', 'Identify assets needed', 'Prepare generation or build steps'],
+    };
+  }
+
+  return {
+    agent,
+    lane,
+    intent: 'general_build',
+    requires_approval: false,
+    next_steps: ['Understand goal', 'Plan the work', 'Route to the right specialist'],
+  };
+}

package/src/lib/scaffold.js

@@ -0,0 +1,260 @@
+import fs from 'fs';
+import path from 'path';
+
+const LANE_KEYS = {
+  'Full Stack': 'fullstack',
+  CMS: 'cms',
+  'Data Solutions': 'data',
+  'Customer Management': 'crm',
+  'Creative & Design': 'creative',
+};
+
+const AGENT_FOR_LANE = {
+  fullstack: 'orchestrator',
+  cms: 'cms',
+  data: 'data',
+  crm: 'crm',
+  creative: 'creative',
+};
+
+function write(file, content) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content.trimStart());
+}
+
+function slugify(value) {
+  return String(value || 'agentsam-project')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'agentsam-project';
+}
+
+function workerTemplate({ projectName, laneKey, agent }) {
+  return `
+import { AgentSam } from '@inneranimalmedia/agentsam-sdk';
+
+export default {
+  async fetch(request, env, ctx) {
+    const agent = new AgentSam({
+      env,
+      ctx,
+      project: '${projectName}',
+      lane: '${laneKey}',
+      agent: '${agent}',
+    });
+
+    return agent.handle(request);
+  },
+};
+`;
+}
+
+function migrationTemplate({ projectName, laneKey }) {
+  return `
+-- AgentSam core schema for ${projectName}
+CREATE TABLE IF NOT EXISTS agent_sessions (
+  id TEXT PRIMARY KEY,
+  agent TEXT NOT NULL,
+  lane TEXT NOT NULL,
+  goal TEXT,
+  status TEXT NOT NULL DEFAULT 'created',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS agent_messages (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  metadata_json TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (session_id) REFERENCES agent_sessions(id)
+);
+
+CREATE TABLE IF NOT EXISTS agent_tool_calls (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'queued',
+  input_json TEXT,
+  output_json TEXT,
+  requires_approval INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  completed_at TEXT,
+  FOREIGN KEY (session_id) REFERENCES agent_sessions(id)
+);
+
+${laneKey === 'cms' ? `
+CREATE TABLE IF NOT EXISTS cms_pages (
+  id TEXT PRIMARY KEY,
+  slug TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'draft',
+  hero_asset_key TEXT,
+  content_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS cms_assets (
+  id TEXT PRIMARY KEY,
+  r2_key TEXT NOT NULL UNIQUE,
+  title TEXT,
+  alt_text TEXT,
+  metadata_json TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+` : ''}
+`;
+}
+
+function readmeTemplate({ projectName, lane, provider, agent }) {
+  return `
+# ${projectName}
+
+Scaffolded with [@inneranimalmedia/agentsam-sdk](https://www.npmjs.com/package/@inneranimalmedia/agentsam-sdk).
+
+## Lane
+
+**${lane}** — ${agent} agent, ${provider}
+
+## Setup
+
+\`\`\`bash
+cp .env.example .env
+npm install
+\`\`\`
+
+## Dev
+
+\`\`\`bash
+npm run dev
+npm run smoke
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+npm run deploy
+\`\`\`
+
+## Endpoints
+
+- \`GET /api/health\`
+- \`GET /api/agentsam/info\`
+- \`POST /api/agentsam/session\`
+- \`POST /api/agentsam/message\`
+`;
+}
+
+export function scaffoldProject({
+  projectName,
+  lane,
+  provider,
+  agent,
+  cfAccountId,
+  sdkVersion = '1.1.1',
+}) {
+  const safeName = slugify(projectName);
+  const dir = path.resolve(process.cwd(), safeName);
+  const laneKey = LANE_KEYS[lane] ?? 'fullstack';
+  const selectedAgent = agent || AGENT_FOR_LANE[laneKey] || 'orchestrator';
+  const sdkRange = `^${sdkVersion.split('.').slice(0, 2).join('.')}.0`;
+
+  if (fs.existsSync(dir)) {
+    throw new Error(`Directory "${safeName}" already exists.`);
+  }
+
+  fs.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(`${dir}/src`, { recursive: true });
+  fs.mkdirSync(`${dir}/migrations`, { recursive: true });
+
+  write(`${dir}/agentsam.config.js`, `
+export default {
+  project: '${safeName}',
+  lane: '${laneKey}',
+  provider: '${provider}',
+  agent: '${selectedAgent}',
+  cloudflare: {
+    accountId: '${cfAccountId || ''}',
+  },
+  api: {
+    baseUrl: '/api/agentsam',
+  },
+};
+`);
+
+  write(`${dir}/.env.example`, `
+AGENTSAM_API_KEY=
+CLOUDFLARE_ACCOUNT_ID=${cfAccountId || ''}
+CLOUDFLARE_API_TOKEN=
+`);
+
+  write(`${dir}/.gitignore`, `
+node_modules/
+.env
+.dev.vars
+dist/
+.wrangler/
+`);
+
+  write(`${dir}/package.json`, `${JSON.stringify({
+    name: safeName,
+    version: '0.1.0',
+    type: 'module',
+    private: true,
+    scripts: {
+      dev: 'wrangler dev',
+      deploy: 'wrangler deploy',
+      smoke: 'node ./scripts/smoke.mjs',
+    },
+    dependencies: {
+      '@inneranimalmedia/agentsam-sdk': sdkRange,
+    },
+    devDependencies: {
+      wrangler: '^4.0.0',
+    },
+  }, null, 2)}\n`);
+
+  write(`${dir}/wrangler.toml`, `
+name = "${safeName}"
+main = "src/index.js"
+compatibility_date = "2026-06-27"
+
+[[d1_databases]]
+binding = "DB"
+database_name = "${safeName}-db"
+database_id = "REPLACE_WITH_D1_DATABASE_ID"
+
+[[kv_namespaces]]
+binding = "KV"
+id = "REPLACE_WITH_KV_NAMESPACE_ID"
+
+[[r2_buckets]]
+binding = "R2"
+bucket_name = "${safeName}"
+`);
+
+  write(`${dir}/migrations/0001_agentsam_core.sql`, migrationTemplate({ projectName: safeName, laneKey }));
+  write(`${dir}/src/index.js`, workerTemplate({ projectName: safeName, laneKey, agent: selectedAgent }));
+  write(`${dir}/README.md`, readmeTemplate({ projectName: safeName, lane, provider, agent: selectedAgent }));
+
+  write(`${dir}/scripts/smoke.mjs`, `
+import { AgentSam } from '@inneranimalmedia/agentsam-sdk';
+
+const app = new AgentSam({ project: '${safeName}', lane: '${laneKey}', agent: '${selectedAgent}' });
+const res = await app.handle(new Request('https://example.com/api/health'));
+const data = await res.json();
+
+if (!data.ok) {
+  console.error(data);
+  process.exit(1);
+}
+
+console.log('AgentSam smoke test passed:', data);
+`);
+
+  return dir;
+}

package/src/lib/sessions.js

@@ -0,0 +1,53 @@
+export async function createSession({ env, agent, lane, goal }) {
+  const now = new Date().toISOString();
+  const session = {
+    id: crypto.randomUUID(),
+    agent,
+    lane,
+    goal: goal ?? null,
+    status: 'created',
+    created_at: now,
+    updated_at: now,
+  };
+
+  if (env?.KV?.put) {
+    await env.KV.put(`agentsam:session:${session.id}`, JSON.stringify(session), { expirationTtl: 60 * 60 * 24 * 7 });
+  }
+
+  if (env?.DB?.prepare) {
+    await env.DB.prepare(
+      `CREATE TABLE IF NOT EXISTS agent_sessions (
+        id TEXT PRIMARY KEY,
+        agent TEXT NOT NULL,
+        lane TEXT NOT NULL,
+        goal TEXT,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`
+    ).run();
+
+    await env.DB.prepare(
+      `INSERT INTO agent_sessions (id, agent, lane, goal, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).bind(session.id, session.agent, session.lane, session.goal, session.status, session.created_at, session.updated_at).run();
+  }
+
+  return session;
+}
+
+export async function getSession({ env, sessionId }) {
+  if (!sessionId) return null;
+
+  if (env?.KV?.get) {
+    const raw = await env.KV.get(`agentsam:session:${sessionId}`);
+    if (raw) return JSON.parse(raw);
+  }
+
+  if (env?.DB?.prepare) {
+    const row = await env.DB.prepare('SELECT * FROM agent_sessions WHERE id = ?').bind(sessionId).first();
+    if (row) return row;
+  }
+
+  return null;
+}

package/src/lib/tools.js

@@ -0,0 +1,38 @@
+const CATALOG = {
+  fullstack: [
+    { name: 'plan', description: 'Break a goal into implementation steps.' },
+    { name: 'code', description: 'Generate or revise application code.' },
+    { name: 'deploy', description: 'Prepare deployment steps and checks.' },
+  ],
+  cms: [
+    { name: 'page', description: 'Create and revise pages.' },
+    { name: 'asset', description: 'Attach cover images and media.' },
+    { name: 'publish', description: 'Draft, preview, and publish content.' },
+  ],
+  data: [
+    { name: 'schema', description: 'Inspect and plan database schemas.' },
+    { name: 'query', description: 'Draft safe SQL queries.' },
+    { name: 'migration', description: 'Plan D1 or Postgres migrations.' },
+  ],
+  crm: [
+    { name: 'contact', description: 'Organize contacts and accounts.' },
+    { name: 'workflow', description: 'Coordinate customer workflows.' },
+  ],
+  creative: [
+    { name: 'brief', description: 'Turn creative intent into a production brief.' },
+    { name: 'asset', description: 'Plan media, 3D, and design assets.' },
+  ],
+};
+
+export function normalizeLane(lane = 'fullstack') {
+  return String(lane).toLowerCase().replace(/\s+/g, '').replace('&', '');
+}
+
+export function getToolCatalog(lane = 'fullstack') {
+  const key = normalizeLane(lane);
+  if (key.includes('cms')) return CATALOG.cms;
+  if (key.includes('data')) return CATALOG.data;
+  if (key.includes('customer') || key.includes('crm')) return CATALOG.crm;
+  if (key.includes('creative') || key.includes('design')) return CATALOG.creative;
+  return CATALOG.fullstack;
+}

package/src/schemas/config.js

@@ -0,0 +1,2 @@
+export const LANES = ['fullstack', 'cms', 'data', 'crm', 'creative'];
+export const AGENTS = ['orchestrator', 'cms', 'data', 'crm', 'creative'];

package/test/smoke.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { AgentSam, routeIntent, getToolCatalog } from '../src/index.js';
+import { scaffoldProject } from '../src/lib/scaffold.js';
+
+const app = new AgentSam({ project: 'smoke', lane: 'cms', agent: 'cms' });
+let res = await app.handle(new Request('https://example.com/api/health'));
+assert.equal(res.status, 200);
+assert.equal((await res.json()).ok, true);
+
+res = await app.handle(new Request('https://example.com/api/agentsam/info'));
+const info = await res.json();
+assert.equal(info.agent, 'cms');
+assert.ok(info.capabilities.includes('page'));
+
+res = await app.handle(new Request('https://example.com/api/agentsam/message', {
+  method: 'POST',
+  body: JSON.stringify({ message: 'create an analytics page in the cms' }),
+}));
+const message = await res.json();
+assert.equal(message.agent, 'cms');
+assert.equal(message.intent, 'cms_build');
+
+assert.equal(routeIntent({ message: 'drop table users' }).requires_approval, true);
+assert.ok(getToolCatalog('Data Solutions').some((tool) => tool.name === 'query'));
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-sdk-test-'));
+const cwd = process.cwd();
+process.chdir(tmp);
+const dir = scaffoldProject({ projectName: 'CMS Demo', lane: 'CMS', provider: 'Cloudflare Workers', agent: 'cms' });
+process.chdir(cwd);
+assert.ok(fs.existsSync(path.join(dir, 'src/index.js')));
+assert.ok(fs.readFileSync(path.join(dir, 'migrations/0001_agentsam_core.sql'), 'utf8').includes('cms_pages'));
+assert.ok(fs.readFileSync(path.join(dir, 'package.json'), 'utf8').includes('wrangler'));
+
+console.log('SDK smoke tests passed');