struere 0.3.10 → 0.4.0

package/dist/cli/index.js

@@ -8,8 +8,7 @@ import { program } from "commander";
 import { Command as Command2 } from "commander";
 import chalk2 from "chalk";
 import ora2 from "ora";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4, basename } from "path";
+import { basename } from "path";
 
 // src/cli/utils/credentials.ts
 import { homedir } from "os";
@@ -62,110 +61,6 @@ import ora from "ora";
 
 // src/cli/utils/convex.ts
 var CONVEX_URL = process.env.STRUERE_CONVEX_URL || "https://rapid-wildebeest-172.convex.cloud";
-async function syncToConvex(agentId, config) {
-  const credentials = loadCredentials();
-  const apiKey = getApiKey();
-  const token = apiKey || credentials?.token;
-  if (!token) {
-    return { success: false, error: "Not authenticated" };
-  }
-  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      path: "agents:syncDevelopment",
-      args: {
-        agentId,
-        config
-      }
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    return { success: false, error };
-  }
-  const result = await response.json();
-  return { success: result.success ?? true };
-}
-async function deployToProduction(agentId) {
-  const credentials = loadCredentials();
-  const apiKey = getApiKey();
-  const token = apiKey || credentials?.token;
-  if (!token) {
-    return { success: false, error: "Not authenticated" };
-  }
-  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      path: "agents:deploy",
-      args: { agentId }
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    return { success: false, error };
-  }
-  const result = await response.json();
-  return { success: result.success ?? true, configId: result.configId };
-}
-async function listAgents() {
-  const credentials = loadCredentials();
-  const apiKey = getApiKey();
-  const token = apiKey || credentials?.token;
-  if (!token) {
-    return { agents: [], error: "Not authenticated" };
-  }
-  const response = await fetch(`${CONVEX_URL}/api/query`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      path: "agents:list",
-      args: {}
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    return { agents: [], error };
-  }
-  const result = await response.json();
-  const agents = Array.isArray(result) ? result : result?.value || [];
-  return { agents };
-}
-async function createAgent(data) {
-  const credentials = loadCredentials();
-  const apiKey = getApiKey();
-  const token = apiKey || credentials?.token;
-  if (!token) {
-    return { error: "Not authenticated" };
-  }
-  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      path: "agents:create",
-      args: data
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    return { error };
-  }
-  const agentId = await response.json();
-  return { agentId };
-}
 async function getUserInfo(token) {
   const ensureResponse = await fetch(`${CONVEX_URL}/api/mutation`, {
     method: "POST",
@@ -237,73 +132,6 @@ async function getUserInfo(token) {
     }
   };
 }
-function extractConfig(agent) {
-  const BUILTIN_TOOLS = [
-    "entity.create",
-    "entity.get",
-    "entity.query",
-    "entity.update",
-    "entity.delete",
-    "entity.link",
-    "entity.unlink",
-    "event.emit",
-    "event.query",
-    "job.enqueue",
-    "job.status"
-  ];
-  let systemPrompt;
-  if (typeof agent.systemPrompt === "function") {
-    const result = agent.systemPrompt();
-    if (result instanceof Promise) {
-      throw new Error("Async system prompts must be resolved before syncing");
-    }
-    systemPrompt = result;
-  } else {
-    systemPrompt = agent.systemPrompt;
-  }
-  const tools = (agent.tools || []).map((tool) => {
-    const isBuiltin = BUILTIN_TOOLS.includes(tool.name);
-    let handlerCode;
-    if (!isBuiltin && tool.handler) {
-      handlerCode = extractHandlerCode(tool.handler);
-    }
-    return {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters || { type: "object", properties: {} },
-      handlerCode,
-      isBuiltin
-    };
-  });
-  return {
-    name: agent.name,
-    version: agent.version || "0.0.1",
-    systemPrompt,
-    model: {
-      provider: agent.model?.provider || "anthropic",
-      name: agent.model?.name || "claude-sonnet-4-20250514",
-      temperature: agent.model?.temperature,
-      maxTokens: agent.model?.maxTokens
-    },
-    tools
-  };
-}
-function extractHandlerCode(handler) {
-  const code = handler.toString();
-  const arrowMatch = code.match(/(?:async\s*)?\([^)]*\)\s*=>\s*\{?([\s\S]*)\}?$/);
-  if (arrowMatch) {
-    let body = arrowMatch[1].trim();
-    if (body.startsWith("{") && body.endsWith("}")) {
-      body = body.slice(1, -1).trim();
-    }
-    return body;
-  }
-  const funcMatch = code.match(/(?:async\s*)?function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/);
-  if (funcMatch) {
-    return funcMatch[1].trim();
-  }
-  return code;
-}
 async function getRecentExecutions(limit = 100) {
   const credentials = loadCredentials();
   const apiKey = getApiKey();
@@ -393,6 +221,81 @@ async function runTestConversation(agentId, message, threadId) {
     threadId: result.threadId
   };
 }
+async function syncOrganization(payload) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "sync:syncOrganization",
+      args: payload
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { success: false, error };
+  }
+  const result = await response.json();
+  return result;
+}
+async function getSyncState() {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "sync:getSyncState",
+      args: {}
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { error };
+  }
+  const result = await response.json();
+  return { state: result.value };
+}
+async function deployAllAgents() {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "sync:deployAllAgents",
+      args: {}
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { success: false, error };
+  }
+  const result = await response.json();
+  return result;
+}
 
 // src/cli/commands/login.ts
 var AUTH_CALLBACK_PORT = 9876;
@@ -579,40 +482,50 @@ function loadProject(cwd) {
     return null;
   }
 }
-function saveProject(cwd, project) {
+function loadProjectV2(cwd) {
   const projectPath = join2(cwd, PROJECT_FILE);
-  writeFileSync2(projectPath, JSON.stringify(project, null, 2) + `
-`);
+  if (!existsSync2(projectPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync2(projectPath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (parsed.version === "2.0") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
 function hasProject(cwd) {
   return existsSync2(join2(cwd, PROJECT_FILE));
 }
+function getProjectVersion(cwd) {
+  const projectPath = join2(cwd, PROJECT_FILE);
+  if (!existsSync2(projectPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync2(projectPath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (parsed.version === "2.0") {
+      return "2.0";
+    }
+    if (parsed.agentId) {
+      return "1.0";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 // src/cli/utils/scaffold.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync3, appendFileSync } from "fs";
 import { join as join3, dirname } from "path";
 
 // src/cli/templates/index.ts
-function getPackageJson(name) {
-  return JSON.stringify({
-    name,
-    version: "0.1.0",
-    type: "module",
-    scripts: {
-      dev: "struere dev",
-      build: "struere build",
-      test: "struere test",
-      deploy: "struere deploy"
-    },
-    dependencies: {
-      struere: "^0.3.0"
-    },
-    devDependencies: {
-      "bun-types": "^1.0.0",
-      typescript: "^5.3.0"
-    }
-  }, null, 2);
-}
 function getTsConfig() {
   return JSON.stringify({
     compilerOptions: {
@@ -649,36 +562,106 @@ export default defineConfig({
 })
 `;
 }
-function getAgentTs(name) {
-  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  return `import { defineAgent } from 'struere'
-import { tools } from './tools'
-
-export default defineAgent({
-  name: '${name}',
-  version: '0.1.0',
-  description: '${displayName} Agent',
-  model: {
-    provider: 'anthropic',
-    name: 'claude-sonnet-4-20250514',
-    temperature: 0.7,
-    maxTokens: 4096,
-  },
-  systemPrompt: \`You are ${displayName}, a helpful AI assistant.
+function getEnvExample() {
+  return `# Anthropic API Key (default provider)
+ANTHROPIC_API_KEY=your_api_key_here
 
-Current time: {{datetime}}
+# Optional: OpenAI API Key (if using OpenAI models)
+# OPENAI_API_KEY=your_openai_api_key
 
-Your capabilities:
-- Answer questions accurately and helpfully
-- Use available tools when appropriate
-- Maintain conversation context
+# Optional: Google AI API Key (if using Gemini models)
+# GOOGLE_GENERATIVE_AI_API_KEY=your_google_api_key
 
-Always be concise, accurate, and helpful.\`,
-  tools,
+# Optional: Custom Convex URL
+# STRUERE_CONVEX_URL=https://struere.convex.cloud
+`;
+}
+function getGitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+.env.*.local
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+*.log
+logs/
+.vercel/
+`;
+}
+function getEntityTypeTs(name, slug) {
+  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return `import { defineEntityType } from 'struere'
+
+export default defineEntityType({
+  name: "${displayName}",
+  slug: "${slug}",
+  schema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Name" },
+      email: { type: "string", format: "email", description: "Email address" },
+      status: { type: "string", enum: ["active", "inactive"], description: "Status" },
+    },
+    required: ["name"],
+  },
+  searchFields: ["name", "email"],
+})
+`;
+}
+function getRoleTs(name) {
+  return `import { defineRole } from 'struere'
+
+export default defineRole({
+  name: "${name}",
+  description: "${name.charAt(0).toUpperCase() + name.slice(1)} role",
+  policies: [
+    { resource: "*", actions: ["list", "read"], effect: "allow", priority: 50 },
+  ],
+  scopeRules: [],
+  fieldMasks: [],
+})
+`;
+}
+function getAgentTsV2(name, slug) {
+  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return `import { defineAgent } from 'struere'
+
+export default defineAgent({
+  name: "${displayName}",
+  slug: "${slug}",
+  version: "0.1.0",
+  description: "${displayName} Agent",
+  model: {
+    provider: "anthropic",
+    name: "claude-sonnet-4-20250514",
+    temperature: 0.7,
+    maxTokens: 4096,
+  },
+  systemPrompt: \`You are ${displayName}, a helpful AI assistant.
+
+Current time: {{datetime}}
+
+Your capabilities:
+- Answer questions accurately and helpfully
+- Use available tools when appropriate
+- Maintain conversation context
+
+Always be concise, accurate, and helpful.\`,
+  tools: ["entity.query", "entity.get", "event.emit"],
 })
 `;
 }
-function getToolsTs() {
+function getIndexTs(type) {
+  return `// Export all ${type} from this directory
+// Example: export { default as myAgent } from './my-agent'
+`;
+}
+function getToolsIndexTs() {
   return `import { defineTools } from 'struere'
 
 export const tools = defineTools([
@@ -704,225 +687,137 @@ export const tools = defineTools([
       }
     },
   },
-  {
-    name: 'calculate',
-    description: 'Perform a mathematical calculation',
-    parameters: {
-      type: 'object',
-      properties: {
-        expression: {
-          type: 'string',
-          description: 'Mathematical expression to evaluate (e.g., "2 + 2")',
-        },
-      },
-      required: ['expression'],
-    },
-    handler: async (params) => {
-      const expression = params.expression as string
-      const sanitized = expression.replace(/[^0-9+*/().\\s-]/g, '')
-      try {
-        const result = new Function(\`return \${sanitized}\`)()
-        return { expression, result }
-      } catch {
-        return { expression, error: 'Invalid expression' }
-      }
-    },
-  },
 ])
-`;
-}
-function getBasicTestYaml() {
-  return `name: Basic conversation test
-description: Verify the agent responds correctly to basic queries
-
-conversation:
-  - role: user
-    content: Hello, what can you do?
-  - role: assistant
-    assertions:
-      - type: contains
-        value: help
-
-  - role: user
-    content: What time is it?
-  - role: assistant
-    assertions:
-      - type: toolCalled
-        value: get_current_time
-`;
-}
-function getEnvExample() {
-  return `# Anthropic API Key (default provider)
-ANTHROPIC_API_KEY=your_api_key_here
-
-# Optional: OpenAI API Key (if using OpenAI models)
-# OPENAI_API_KEY=your_openai_api_key
 
-# Optional: Google AI API Key (if using Gemini models)
-# GOOGLE_GENERATIVE_AI_API_KEY=your_google_api_key
-
-# Optional: Custom Convex URL
-# STRUERE_CONVEX_URL=https://struere.convex.cloud
+export default tools
 `;
 }
-function getGitignore() {
-  return `node_modules/
-dist/
-.env
-.env.local
-.env.*.local
-.idea/
-.vscode/
-*.swp
-*.swo
-.DS_Store
-Thumbs.db
-*.log
-logs/
-.vercel/
-`;
-}
-function getStruereJson(agentId, team, slug, name) {
+function getStruereJsonV2(orgId, orgSlug, orgName) {
   return JSON.stringify({
-    agentId,
-    team,
-    agent: {
-      slug,
-      name
+    version: "2.0",
+    organization: {
+      id: orgId,
+      slug: orgSlug,
+      name: orgName
     }
   }, null, 2);
 }
-function getEnvLocal(deploymentUrl) {
-  return `STRUERE_DEPLOYMENT_URL=${deploymentUrl}
-`;
+function getPackageJsonV2(name) {
+  return JSON.stringify({
+    name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "struere dev",
+      build: "struere build",
+      deploy: "struere deploy",
+      status: "struere status"
+    },
+    dependencies: {
+      struere: "^0.4.0"
+    },
+    devDependencies: {
+      "bun-types": "^1.0.0",
+      typescript: "^5.3.0"
+    }
+  }, null, 2);
 }
-function getClaudeMD(name) {
-  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  return `# ${displayName} Agent
+function getClaudeMDV2(orgName) {
+  return `# ${orgName} - Struere Project
 
-This is a Struere AI agent project. Struere is a framework for building production AI agents with built-in data management, event tracking, and job scheduling.
+This is a Struere organization project. Struere is a framework for building production AI agents with built-in data management, RBAC permissions, and job scheduling.
 
 ## Project Structure
 
 \`\`\`
-src/
-\u251C\u2500\u2500 agent.ts      # Agent definition (system prompt, model, tools)
-\u251C\u2500\u2500 tools.ts      # Custom tool definitions
-\u2514\u2500\u2500 workflows/    # Multi-step workflow definitions
-tests/
-\u2514\u2500\u2500 *.test.yaml   # YAML-based conversation tests
-struere.json      # Project configuration (agentId, team, slug)
-struere.config.ts # Framework settings (port, CORS, logging)
-\`\`\`
-
-## Agent Definition
+agents/              # Agent definitions
+\u251C\u2500\u2500 scheduler.ts     # Example agent
+\u2514\u2500\u2500 index.ts         # Re-exports all agents
 
-Define your agent in \`src/agent.ts\`:
+entity-types/        # Entity type schemas
+\u251C\u2500\u2500 teacher.ts       # Example entity type
+\u2514\u2500\u2500 index.ts         # Re-exports all entity types
 
-\`\`\`typescript
-import { defineAgent } from 'struere'
-import { tools } from './tools'
+roles/               # Role + permission definitions
+\u251C\u2500\u2500 admin.ts         # Example role with policies
+\u2514\u2500\u2500 index.ts         # Re-exports all roles
 
-export default defineAgent({
-  name: 'my-agent',
-  version: '0.1.0',
-  description: 'My AI Agent',
-  model: {
-    provider: 'anthropic',
-    name: 'claude-sonnet-4-20250514',
-    temperature: 0.7,
-    maxTokens: 4096,
-  },
-  systemPrompt: \\\`You are a helpful assistant.
+tools/               # Shared custom tools
+\u2514\u2500\u2500 index.ts         # Custom tool definitions
 
-Current time: {{datetime}}
-Customer: {{entity.get({"id": "{{thread.metadata.customerId}}"})}}\\\`,
-  tools,
-})
+struere.json         # Organization configuration
+struere.config.ts    # Framework settings
 \`\`\`
 
-## System Prompt Templates
-
-System prompts support dynamic \`{{...}}\` templates that are resolved at runtime before the LLM call.
-
-### Available Variables
-
-| Variable | Description |
-|----------|-------------|
-| \`{{organizationId}}\` | Current organization ID |
-| \`{{userId}}\` | Current user ID |
-| \`{{threadId}}\` | Conversation thread ID |
-| \`{{agentId}}\` | Agent ID |
-| \`{{agent.name}}\` | Agent name |
-| \`{{agent.slug}}\` | Agent slug |
-| \`{{thread.metadata.X}}\` | Thread metadata field X |
-| \`{{message}}\` | Current user message |
-| \`{{timestamp}}\` | Unix timestamp (ms) |
-| \`{{datetime}}\` | ISO 8601 datetime |
-
-### Function Calls
-
-Call any agent tool directly in the system prompt:
-
-\`\`\`
-{{entity.get({"id": "ent_123"})}}
-{{entity.query({"type": "customer", "limit": 5})}}
-{{event.query({"entityId": "ent_123", "limit": 10})}}
-\`\`\`
+## CLI Commands
 
-### Nested Templates
+| Command | Description |
+|---------|-------------|
+| \`struere dev\` | Watch and sync all resources to Convex |
+| \`struere deploy\` | Deploy all agents to production |
+| \`struere add <type> <name>\` | Scaffold new agent/entity-type/role |
+| \`struere status\` | Compare local vs remote state |
 
-Variables can be used inside function arguments:
+## Defining Resources
 
-\`\`\`
-{{entity.get({"id": "{{thread.metadata.customerId}}"})}}
-\`\`\`
+### Agents (\`agents/*.ts\`)
 
-### Error Handling
+\`\`\`typescript
+import { defineAgent } from 'struere'
 
-Failed templates are replaced with inline errors:
-\`\`\`
-[TEMPLATE_ERROR: variableName not found]
-[TEMPLATE_ERROR: toolName - error message]
+export default defineAgent({
+  name: "Scheduler",
+  slug: "scheduler",
+  version: "0.1.0",
+  systemPrompt: "You are a scheduling assistant...",
+  model: { provider: "anthropic", name: "claude-sonnet-4-20250514" },
+  tools: ["entity.create", "entity.query", "event.emit"],
+})
 \`\`\`
 
-## Custom Tools
-
-Define tools in \`src/tools.ts\`:
+### Entity Types (\`entity-types/*.ts\`)
 
 \`\`\`typescript
-import { defineTools } from 'struere'
-
-export const tools = defineTools([
-  {
-    name: 'search_products',
-    description: 'Search the product catalog',
-    parameters: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Search query' },
-        limit: { type: 'number', description: 'Max results' },
-      },
-      required: ['query'],
-    },
-    handler: async (params) => {
-      const results = await searchProducts(params.query, params.limit ?? 10)
-      return { products: results }
+import { defineEntityType } from 'struere'
+
+export default defineEntityType({
+  name: "Teacher",
+  slug: "teacher",
+  schema: {
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      email: { type: "string", format: "email" },
+      hourlyRate: { type: "number" },
     },
+    required: ["name", "email"],
   },
-])
+  searchFields: ["name", "email"],
+})
 \`\`\`
 
-Custom tool handlers are executed in a sandboxed Cloudflare Worker environment. They can make HTTP requests to allowlisted domains:
-- api.openai.com, api.anthropic.com, api.stripe.com
-- api.sendgrid.com, api.twilio.com, hooks.slack.com
-- discord.com, api.github.com
-
-## Built-in Tools
+### Roles (\`roles/*.ts\`)
 
-Agents have access to these built-in tools for data management:
+\`\`\`typescript
+import { defineRole } from 'struere'
+
+export default defineRole({
+  name: "teacher",
+  description: "Tutors who conduct sessions",
+  policies: [
+    { resource: "session", actions: ["list", "read", "update"], effect: "allow", priority: 50 },
+    { resource: "payment", actions: ["*"], effect: "deny", priority: 100 },
+  ],
+  scopeRules: [
+    { entityType: "session", field: "data.teacherId", operator: "eq", value: "actor.userId" },
+  ],
+  fieldMasks: [
+    { entityType: "session", fieldPath: "data.paymentId", maskType: "hide" },
+  ],
+})
+\`\`\`
 
-### Entity Tools
+## Built-in Tools
 
 | Tool | Description |
 |------|-------------|
@@ -933,159 +828,18 @@ Agents have access to these built-in tools for data management:
 | \`entity.delete\` | Soft-delete entity |
 | \`entity.link\` | Create entity relation |
 | \`entity.unlink\` | Remove entity relation |
-
-Example entity operations:
-\`\`\`json
-// entity.create
-{ "type": "customer", "data": { "name": "John", "email": "john@example.com" } }
-
-// entity.query
-{ "type": "customer", "filters": { "status": "active" }, "limit": 10 }
-
-// entity.update
-{ "id": "ent_123", "data": { "status": "vip" } }
-\`\`\`
-
-### Event Tools
-
-| Tool | Description |
-|------|-------------|
-| \`event.emit\` | Emit a custom event |
-| \`event.query\` | Query event history |
-
-Example event operations:
-\`\`\`json
-// event.emit
-{ "entityId": "ent_123", "eventType": "order.placed", "payload": { "amount": 99.99 } }
-
-// event.query
-{ "entityId": "ent_123", "eventType": "order.*", "limit": 20 }
-\`\`\`
-
-### Job Tools
-
-| Tool | Description |
-|------|-------------|
-| \`job.enqueue\` | Schedule a background job |
+| \`event.emit\` | Emit custom event |
+| \`event.query\` | Query events |
+| \`job.enqueue\` | Schedule background job |
 | \`job.status\` | Get job status |
 
-Example job operations:
-\`\`\`json
-// job.enqueue
-{ "jobType": "send_email", "payload": { "to": "user@example.com" }, "scheduledFor": 1706745600000 }
-
-// job.status
-{ "id": "job_abc123" }
-\`\`\`
-
-## Testing
-
-Write YAML-based conversation tests in \`tests/\`:
-
-\`\`\`yaml
-name: Order flow test
-description: Test the complete order flow
-
-conversation:
-  - role: user
-    content: I want to order a pizza
-  - role: assistant
-    assertions:
-      - type: contains
-        value: size
-      - type: toolCalled
-        value: get_menu
-
-  - role: user
-    content: Large pepperoni please
-  - role: assistant
-    assertions:
-      - type: toolCalled
-        value: entity.create
-\`\`\`
-
-### Assertion Types
-
-| Type | Description |
-|------|-------------|
-| \`contains\` | Response contains substring |
-| \`matches\` | Response matches regex |
-| \`toolCalled\` | Specific tool was called |
-| \`noToolCalled\` | No tools were called |
-
-Run tests with:
-\`\`\`bash
-bun run test
-\`\`\`
-
-## CLI Commands
-
-| Command | Description |
-|---------|-------------|
-| \`struere dev\` | Start development mode (live sync to Convex) |
-| \`struere build\` | Validate agent configuration |
-| \`struere deploy\` | Deploy agent to production |
-| \`struere test\` | Run YAML conversation tests |
-| \`struere logs\` | View recent execution logs |
-| \`struere state\` | Inspect conversation thread state |
-
-## Thread Metadata
-
-Set thread metadata when creating conversations to provide context:
-
-\`\`\`typescript
-// Via API
-POST /v1/chat
-{
-  "agentId": "agent_123",
-  "message": "Hello",
-  "metadata": {
-    "customerId": "ent_customer_456",
-    "channel": "web",
-    "language": "en"
-  }
-}
-\`\`\`
-
-Access in system prompt:
-\`\`\`
-Customer: {{entity.get({"id": "{{thread.metadata.customerId}}"})}}
-Channel: {{thread.metadata.channel}}
-\`\`\`
-
 ## Development Workflow
 
-1. **Edit agent configuration** in \`src/agent.ts\`
-2. **Run \`bun run dev\`** to sync changes to Convex
-3. **Test via API** or dashboard chat interface
-4. **Write tests** in \`tests/*.test.yaml\`
-5. **Deploy** with \`bun run deploy\`
-
-## API Endpoints
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| \`/v1/chat\` | POST | Chat by agent ID |
-| \`/v1/agents/:slug/chat\` | POST | Chat by agent slug |
-
-Authentication: Bearer token (API key from dashboard)
-
-\`\`\`bash
-curl -X POST https://your-deployment.convex.cloud/v1/chat \\
-  -H "Authorization: Bearer sk_live_..." \\
-  -H "Content-Type: application/json" \\
-  -d '{"agentId": "...", "message": "Hello"}'
-\`\`\`
-
-## Best Practices
-
-1. **System Prompts**: Use templates for dynamic data instead of hardcoding
-2. **Tools**: Keep tool handlers focused and stateless
-3. **Entities**: Model your domain data as entity types
-4. **Events**: Emit events for audit trails and analytics
-5. **Jobs**: Use jobs for async operations (emails, notifications)
-6. **Testing**: Write tests for critical conversation flows
-7. **Thread Metadata**: Use metadata for user-specific personalization
+1. Run \`struere dev\` to start watching for changes
+2. Edit agents, entity types, or roles
+3. Changes are automatically synced to Convex
+4. Test via API or dashboard
+5. Run \`struere deploy\` when ready for production
 `;
 }
 
@@ -1101,33 +855,35 @@ function writeFile(cwd, relativePath, content) {
   ensureDir(fullPath);
   writeFileSync3(fullPath, content);
 }
-function writeProjectConfig(cwd, options) {
-  const result = {
-    createdFiles: [],
-    updatedFiles: []
-  };
-  writeFile(cwd, "struere.json", getStruereJson(options.agentId, options.team, options.agentSlug, options.agentName));
-  result.createdFiles.push("struere.json");
-  writeFile(cwd, ".env.local", getEnvLocal(options.deploymentUrl));
-  result.createdFiles.push(".env.local");
-  updateGitignore(cwd, result);
-  return result;
-}
-function scaffoldAgentFiles(cwd, projectName) {
+function scaffoldProjectV2(cwd, options) {
   const result = {
     createdFiles: [],
     updatedFiles: []
   };
+  const directories = [
+    "agents",
+    "entity-types",
+    "roles",
+    "tools"
+  ];
+  for (const dir of directories) {
+    const dirPath = join3(cwd, dir);
+    if (!existsSync3(dirPath)) {
+      mkdirSync2(dirPath, { recursive: true });
+    }
+  }
   const files = {
-    "package.json": getPackageJson(projectName),
+    "struere.json": getStruereJsonV2(options.orgId, options.orgSlug, options.orgName),
+    "package.json": getPackageJsonV2(options.projectName),
     "tsconfig.json": getTsConfig(),
     "struere.config.ts": getStruereConfig(),
-    "src/agent.ts": getAgentTs(projectName),
-    "src/tools.ts": getToolsTs(),
-    "src/workflows/.gitkeep": "",
-    "tests/basic.test.yaml": getBasicTestYaml(),
     ".env.example": getEnvExample(),
-    "CLAUDE.md": getClaudeMD(projectName)
+    ".gitignore": getGitignore(),
+    "CLAUDE.md": getClaudeMDV2(options.orgName),
+    "agents/index.ts": getIndexTs("agents"),
+    "entity-types/index.ts": getIndexTs("entity-types"),
+    "roles/index.ts": getIndexTs("roles"),
+    "tools/index.ts": getToolsIndexTs()
   };
   for (const [relativePath, content] of Object.entries(files)) {
     const fullPath = join3(cwd, relativePath);
@@ -1137,57 +893,85 @@ function scaffoldAgentFiles(cwd, projectName) {
     writeFile(cwd, relativePath, content);
     result.createdFiles.push(relativePath);
   }
-  updateGitignore(cwd, result);
   return result;
 }
-function updateGitignore(cwd, result) {
-  const gitignorePath = join3(cwd, ".gitignore");
-  const linesToAdd = [".env.local"];
-  if (existsSync3(gitignorePath)) {
-    const content = readFileSync3(gitignorePath, "utf-8");
-    const lines = content.split(`
-`);
-    const missingLines = linesToAdd.filter((line) => !lines.some((l) => l.trim() === line));
-    if (missingLines.length > 0) {
-      const toAppend = `
-` + missingLines.join(`
-`) + `
-`;
-      appendFileSync(gitignorePath, toAppend);
-      result.updatedFiles.push(".gitignore");
-    }
-  } else {
-    writeFile(cwd, ".gitignore", getGitignore());
-    result.createdFiles.push(".gitignore");
+function scaffoldAgent(cwd, name, slug) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  const agentsDir = join3(cwd, "agents");
+  if (!existsSync3(agentsDir)) {
+    mkdirSync2(agentsDir, { recursive: true });
   }
+  const fileName = `${slug}.ts`;
+  const filePath = join3(agentsDir, fileName);
+  if (existsSync3(filePath)) {
+    return result;
+  }
+  writeFileSync3(filePath, getAgentTsV2(name, slug));
+  result.createdFiles.push(`agents/${fileName}`);
+  return result;
 }
-function hasAgentFiles(cwd) {
-  return existsSync3(join3(cwd, "src", "agent.ts"));
+function scaffoldEntityType(cwd, name, slug) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  const entityTypesDir = join3(cwd, "entity-types");
+  if (!existsSync3(entityTypesDir)) {
+    mkdirSync2(entityTypesDir, { recursive: true });
+  }
+  const fileName = `${slug}.ts`;
+  const filePath = join3(entityTypesDir, fileName);
+  if (existsSync3(filePath)) {
+    return result;
+  }
+  writeFileSync3(filePath, getEntityTypeTs(name, slug));
+  result.createdFiles.push(`entity-types/${fileName}`);
+  return result;
+}
+function scaffoldRole(cwd, name) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  const rolesDir = join3(cwd, "roles");
+  if (!existsSync3(rolesDir)) {
+    mkdirSync2(rolesDir, { recursive: true });
+  }
+  const fileName = `${name}.ts`;
+  const filePath = join3(rolesDir, fileName);
+  if (existsSync3(filePath)) {
+    return result;
+  }
+  writeFileSync3(filePath, getRoleTs(name));
+  result.createdFiles.push(`roles/${fileName}`);
+  return result;
 }
 
 // src/cli/commands/init.ts
-var initCommand = new Command2("init").description("Initialize a new Struere project").argument("[project-name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").action(async (projectNameArg, options) => {
+var initCommand = new Command2("init").description("Initialize a new Struere organization project").argument("[project-name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").action(async (projectNameArg, options) => {
   const cwd = process.cwd();
   const spinner = ora2();
   console.log();
   console.log(chalk2.bold("Struere CLI"));
   console.log();
   if (hasProject(cwd)) {
-    const existingProject = loadProject(cwd);
-    if (existingProject) {
-      console.log(chalk2.yellow("This project is already initialized."));
+    const version = getProjectVersion(cwd);
+    if (version === "2.0") {
+      console.log(chalk2.yellow("This project is already initialized (v2.0)."));
       console.log();
-      console.log(chalk2.gray("  Agent:"), chalk2.cyan(existingProject.agent.name));
-      console.log(chalk2.gray("  ID:"), chalk2.gray(existingProject.agentId));
-      console.log(chalk2.gray("  Team:"), chalk2.cyan(existingProject.team));
+      console.log(chalk2.gray("Run"), chalk2.cyan("struere dev"), chalk2.gray("to start development"));
       console.log();
-      const shouldRelink = await promptYesNo("Would you like to relink to a different agent?");
-      if (!shouldRelink) {
-        console.log();
-        console.log(chalk2.gray("Run"), chalk2.cyan("struere dev"), chalk2.gray("to start development"));
-        console.log();
-        return;
-      }
+      return;
+    } else if (version === "1.0") {
+      console.log(chalk2.yellow("This is a v1 agent-centric project."));
+      console.log(chalk2.yellow("The new CLI uses an organization-centric structure."));
+      console.log();
+      console.log(chalk2.gray("Please create a new project directory for the v2 structure."));
+      console.log();
+      return;
     }
   }
   let credentials = loadCredentials();
@@ -1199,105 +983,39 @@ var initCommand = new Command2("init").description("Initialize a new Struere pro
       console.log(chalk2.red("Authentication failed"));
       process.exit(1);
     }
-  } else {
-    console.log(chalk2.green("\u2713"), "Logged in as", chalk2.cyan(credentials.user.name || credentials.user.email));
-    console.log();
-  }
-  let projectName = projectNameArg;
-  if (!projectName) {
-    projectName = await deriveProjectName(cwd);
-    if (!options.yes) {
-      const confirmed = await promptText("Agent name:", projectName);
-      projectName = confirmed || projectName;
-    }
-  }
-  projectName = slugify(projectName);
-  spinner.start("Fetching agents");
-  const { agents: existingAgents, error: listError } = await listAgents();
-  if (listError) {
-    spinner.fail("Failed to fetch agents");
-    console.log();
-    console.log(chalk2.gray("Run"), chalk2.cyan("struere login"), chalk2.gray("to re-authenticate"));
-    process.exit(1);
-  }
-  const agents = existingAgents.map((a) => ({ id: a._id, name: a.name, slug: a.slug }));
-  spinner.succeed(`Found ${agents.length} existing agent(s)`);
-  let selectedAgent = null;
-  let deploymentUrl = "";
-  if (agents.length > 0 && !options.yes) {
-    console.log();
-    const choice = await promptChoice("Create new agent or link existing?", [
-      { value: "new", label: "Create new agent" },
-      ...agents.map((a) => ({ value: a.id, label: `${a.name} (${a.slug})` }))
-    ]);
-    if (choice !== "new") {
-      selectedAgent = agents.find((a) => a.id === choice) || null;
-    }
-  }
-  if (!selectedAgent) {
-    const displayName2 = projectName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-    spinner.start("Creating agent");
-    const { agentId, error: createError } = await createAgent({
-      name: displayName2,
-      slug: projectName,
-      description: `${displayName2} Agent`
-    });
-    if (createError || !agentId) {
-      spinner.fail("Failed to create agent");
-      console.log();
-      console.log(chalk2.red("Error:"), createError || "Unknown error");
-      process.exit(1);
-    }
-    selectedAgent = { id: agentId, name: displayName2, slug: projectName };
-    deploymentUrl = `https://${projectName}-dev.struere.dev`;
-    spinner.succeed(`Created agent "${projectName}"`);
-  } else {
-    deploymentUrl = `https://${selectedAgent.slug}-dev.struere.dev`;
-    console.log();
-    console.log(chalk2.green("\u2713"), `Linked to "${selectedAgent.name}"`);
-  }
-  saveProject(cwd, {
-    agentId: selectedAgent.id,
-    team: credentials.organization.slug,
-    agent: {
-      slug: selectedAgent.slug,
-      name: selectedAgent.name
-    }
-  });
-  console.log(chalk2.green("\u2713"), "Created struere.json");
-  const configResult = writeProjectConfig(cwd, {
-    projectName,
-    agentId: selectedAgent.id,
-    team: credentials.organization.slug,
-    agentSlug: selectedAgent.slug,
-    agentName: selectedAgent.name,
-    deploymentUrl
-  });
-  for (const file of configResult.createdFiles) {
-    if (file !== "struere.json") {
-      console.log(chalk2.green("\u2713"), `Created ${file}`);
-    }
-  }
-  for (const file of configResult.updatedFiles) {
-    console.log(chalk2.green("\u2713"), `Updated ${file}`);
+  } else {
+    console.log(chalk2.green("\u2713"), "Logged in as", chalk2.cyan(credentials.user.name || credentials.user.email));
+    console.log(chalk2.gray("  Organization:"), chalk2.cyan(credentials.organization.name));
+    console.log();
   }
-  if (!hasAgentFiles(cwd)) {
-    let shouldScaffold = options.yes;
-    if (!options.yes) {
+  if (!options.yes) {
+    const confirmed = await promptYesNo(`Initialize project for organization "${credentials.organization.name}"?`);
+    if (!confirmed) {
       console.log();
-      shouldScaffold = await promptYesNo("Scaffold starter files?");
+      console.log(chalk2.gray("Cancelled"));
+      return;
     }
-    if (shouldScaffold) {
-      const scaffoldResult = scaffoldAgentFiles(cwd, projectName);
-      console.log();
-      for (const file of scaffoldResult.createdFiles) {
-        console.log(chalk2.green("\u2713"), `Created ${file}`);
-      }
-      for (const file of scaffoldResult.updatedFiles) {
-        console.log(chalk2.green("\u2713"), `Updated ${file}`);
-      }
+  }
+  let projectName = projectNameArg;
+  if (!projectName) {
+    projectName = slugify(basename(cwd));
+    if (!options.yes) {
+      const confirmed = await promptText("Project name:", projectName);
+      projectName = confirmed || projectName;
     }
   }
+  projectName = slugify(projectName);
+  spinner.start("Creating project structure");
+  const scaffoldResult = scaffoldProjectV2(cwd, {
+    projectName,
+    orgId: credentials.organization.id,
+    orgSlug: credentials.organization.slug,
+    orgName: credentials.organization.name
+  });
+  spinner.succeed("Project structure created");
+  for (const file of scaffoldResult.createdFiles) {
+    console.log(chalk2.green("\u2713"), `Created ${file}`);
+  }
   console.log();
   spinner.start("Installing dependencies");
   const installResult = Bun.spawnSync(["bun", "install"], {
@@ -1311,46 +1029,20 @@ var initCommand = new Command2("init").description("Initialize a new Struere pro
     spinner.warn("Could not install dependencies automatically");
     console.log(chalk2.gray("  Run"), chalk2.cyan("bun install"), chalk2.gray("manually"));
   }
-  spinner.start("Syncing initial config to Convex");
-  const displayName = projectName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  const defaultConfig = {
-    name: displayName,
-    version: "0.1.0",
-    systemPrompt: `You are ${displayName}, a helpful AI assistant. You help users with their questions and tasks.`,
-    model: {
-      provider: "anthropic",
-      name: "claude-sonnet-4-20250514",
-      temperature: 0.7,
-      maxTokens: 4096
-    },
-    tools: []
-  };
-  const syncResult = await syncToConvex(selectedAgent.id, defaultConfig);
-  if (syncResult.success) {
-    spinner.succeed("Initial config synced");
-  } else {
-    spinner.warn("Could not sync initial config");
-    console.log(chalk2.gray("  Run"), chalk2.cyan("struere dev"), chalk2.gray("to sync manually"));
-  }
   console.log();
   console.log(chalk2.green("Success!"), "Project initialized");
   console.log();
+  console.log(chalk2.gray("Project structure:"));
+  console.log(chalk2.gray("  agents/       "), chalk2.cyan("Agent definitions"));
+  console.log(chalk2.gray("  entity-types/ "), chalk2.cyan("Entity type schemas"));
+  console.log(chalk2.gray("  roles/        "), chalk2.cyan("Role + permission definitions"));
+  console.log(chalk2.gray("  tools/        "), chalk2.cyan("Shared custom tools"));
+  console.log();
   console.log(chalk2.gray("Next steps:"));
-  console.log(chalk2.gray("  $"), chalk2.cyan("struere dev"));
+  console.log(chalk2.gray("  1."), chalk2.cyan("struere add agent my-agent"), chalk2.gray("- Create an agent"));
+  console.log(chalk2.gray("  2."), chalk2.cyan("struere dev"), chalk2.gray("- Start development"));
   console.log();
 });
-async function deriveProjectName(cwd) {
-  const packageJsonPath = join4(cwd, "package.json");
-  if (existsSync4(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
-      if (pkg.name && typeof pkg.name === "string") {
-        return slugify(pkg.name);
-      }
-    } catch {}
-  }
-  return slugify(basename(cwd));
-}
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -1365,22 +1057,6 @@ async function promptText(message, defaultValue) {
   const answer = await readLine();
   return answer || defaultValue;
 }
-async function promptChoice(message, choices) {
-  console.log(chalk2.gray(message));
-  console.log();
-  for (let i = 0;i < choices.length; i++) {
-    const prefix = i === 0 ? chalk2.cyan("\u276F") : chalk2.gray(" ");
-    console.log(`${prefix} ${i + 1}. ${choices[i].label}`);
-  }
-  console.log();
-  process.stdout.write(chalk2.gray("Enter choice (1-" + choices.length + "): "));
-  const answer = await readLine();
-  const num = parseInt(answer, 10);
-  if (num >= 1 && num <= choices.length) {
-    return choices[num - 1].value;
-  }
-  return choices[0].value;
-}
 function readLine() {
   return new Promise((resolve) => {
     let buffer = "";
@@ -1407,112 +1083,275 @@ import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
 import ora3 from "ora";
 import chokidar from "chokidar";
-import { join as join7, basename as basename2 } from "path";
+import { join as join5 } from "path";
 import { existsSync as existsSync5, writeFileSync as writeFileSync4 } from "fs";
 
-// src/cli/utils/config.ts
-import { join as join5 } from "path";
-var defaultConfig = {
-  port: 3000,
-  host: "localhost",
-  cors: {
-    origins: ["http://localhost:3000"],
-    credentials: true
-  },
-  logging: {
-    level: "info",
-    format: "pretty"
-  },
-  auth: {
-    type: "none"
+// src/cli/utils/loader.ts
+import { existsSync as existsSync4, readdirSync } from "fs";
+import { join as join4 } from "path";
+async function loadAllResources(cwd) {
+  const agents = await loadAllAgents(join4(cwd, "agents"));
+  const entityTypes = await loadAllEntityTypes(join4(cwd, "entity-types"));
+  const roles = await loadAllRoles(join4(cwd, "roles"));
+  const customTools = await loadCustomTools(join4(cwd, "tools"));
+  return { agents, entityTypes, roles, customTools };
+}
+async function loadAllAgents(dir) {
+  if (!existsSync4(dir)) {
+    return [];
+  }
+  const indexPath = join4(dir, "index.ts");
+  if (existsSync4(indexPath)) {
+    return loadFromIndex(indexPath);
+  }
+  return loadFromDirectory(dir);
+}
+async function loadAllEntityTypes(dir) {
+  if (!existsSync4(dir)) {
+    return [];
+  }
+  const indexPath = join4(dir, "index.ts");
+  if (existsSync4(indexPath)) {
+    return loadFromIndex(indexPath);
+  }
+  return loadFromDirectory(dir);
+}
+async function loadAllRoles(dir) {
+  if (!existsSync4(dir)) {
+    return [];
+  }
+  const indexPath = join4(dir, "index.ts");
+  if (existsSync4(indexPath)) {
+    return loadFromIndex(indexPath);
+  }
+  return loadFromDirectory(dir);
+}
+async function loadCustomTools(dir) {
+  if (!existsSync4(dir)) {
+    return [];
+  }
+  const indexPath = join4(dir, "index.ts");
+  if (!existsSync4(indexPath)) {
+    return [];
   }
-};
-async function loadConfig(cwd) {
-  const configPath = join5(cwd, "struere.config.ts");
   try {
-    const module = await import(configPath);
-    const config = module.default || module;
-    return {
-      ...defaultConfig,
-      ...config,
-      cors: {
-        ...defaultConfig.cors,
-        ...config.cors
-      },
-      logging: {
-        ...defaultConfig.logging,
-        ...config.logging
-      },
-      auth: {
-        ...defaultConfig.auth,
-        ...config.auth
-      }
-    };
+    const module = await import(indexPath);
+    if (Array.isArray(module.default)) {
+      return module.default;
+    }
+    if (module.tools && Array.isArray(module.tools)) {
+      return module.tools;
+    }
+    return [];
   } catch {
-    return defaultConfig;
+    return [];
   }
 }
-
-// src/cli/utils/agent.ts
-import { join as join6 } from "path";
-async function loadAgent(cwd) {
-  const agentPath = join6(cwd, "src/agent.ts");
+async function loadFromIndex(indexPath) {
   try {
-    const module = await import(`${agentPath}?t=${Date.now()}`);
-    const agent = module.default || module;
-    if (!agent.name) {
-      throw new Error("Agent must have a name");
+    const module = await import(indexPath);
+    if (Array.isArray(module.default)) {
+      return module.default;
     }
-    if (!agent.version) {
-      throw new Error("Agent must have a version");
-    }
-    if (!agent.systemPrompt) {
-      throw new Error("Agent must have a systemPrompt");
+    const items = [];
+    for (const key of Object.keys(module)) {
+      if (key === "default")
+        continue;
+      const value = module[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        items.push(value);
+      }
     }
-    return agent;
+    return items;
   } catch (error) {
-    if (error instanceof Error && error.message.includes("Cannot find module")) {
-      throw new Error(`Agent not found at ${agentPath}`);
+    throw new Error(`Failed to load index at ${indexPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function loadFromDirectory(dir) {
+  const files = readdirSync(dir).filter((f) => f.endsWith(".ts") && f !== "index.ts" && !f.endsWith(".d.ts"));
+  const items = [];
+  for (const file of files) {
+    const filePath = join4(dir, file);
+    try {
+      const module = await import(filePath);
+      if (module.default) {
+        items.push(module.default);
+      }
+    } catch (error) {
+      throw new Error(`Failed to load ${file}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    throw error;
   }
+  return items;
+}
+function getResourceDirectories(cwd) {
+  return {
+    agents: join4(cwd, "agents"),
+    entityTypes: join4(cwd, "entity-types"),
+    roles: join4(cwd, "roles"),
+    tools: join4(cwd, "tools")
+  };
+}
+
+// src/cli/utils/extractor.ts
+var BUILTIN_TOOLS = [
+  "entity.create",
+  "entity.get",
+  "entity.query",
+  "entity.update",
+  "entity.delete",
+  "entity.link",
+  "entity.unlink",
+  "event.emit",
+  "event.query",
+  "job.enqueue",
+  "job.status"
+];
+function extractSyncPayload(resources) {
+  const customToolsMap = new Map;
+  for (const tool of resources.customTools) {
+    customToolsMap.set(tool.name, tool);
+  }
+  const agents = resources.agents.map((agent) => extractAgentPayload(agent, customToolsMap));
+  const entityTypes = resources.entityTypes.map((et) => ({
+    name: et.name,
+    slug: et.slug,
+    schema: et.schema,
+    searchFields: et.searchFields,
+    displayConfig: et.displayConfig
+  }));
+  const roles = resources.roles.map((role) => ({
+    name: role.name,
+    description: role.description,
+    policies: role.policies.map((p) => ({
+      resource: p.resource,
+      actions: p.actions,
+      effect: p.effect,
+      priority: p.priority
+    })),
+    scopeRules: role.scopeRules?.map((sr) => ({
+      entityType: sr.entityType,
+      field: sr.field,
+      operator: sr.operator,
+      value: sr.value
+    })),
+    fieldMasks: role.fieldMasks?.map((fm) => ({
+      entityType: fm.entityType,
+      fieldPath: fm.fieldPath,
+      maskType: fm.maskType,
+      maskConfig: fm.maskConfig
+    }))
+  }));
+  return { agents, entityTypes, roles };
+}
+function extractAgentPayload(agent, customToolsMap) {
+  let systemPrompt;
+  if (typeof agent.systemPrompt === "function") {
+    const result = agent.systemPrompt();
+    if (result instanceof Promise) {
+      throw new Error("Async system prompts must be resolved before syncing");
+    }
+    systemPrompt = result;
+  } else {
+    systemPrompt = agent.systemPrompt;
+  }
+  const tools = (agent.tools || []).map((toolName) => {
+    const isBuiltin = BUILTIN_TOOLS.includes(toolName);
+    if (isBuiltin) {
+      return {
+        name: toolName,
+        description: getBuiltinToolDescription(toolName),
+        parameters: { type: "object", properties: {} },
+        isBuiltin: true
+      };
+    }
+    const customTool = customToolsMap.get(toolName);
+    if (!customTool) {
+      throw new Error(`Tool "${toolName}" not found in custom tools`);
+    }
+    return {
+      name: customTool.name,
+      description: customTool.description,
+      parameters: customTool.parameters || { type: "object", properties: {} },
+      handlerCode: extractHandlerCode(customTool.handler),
+      isBuiltin: false
+    };
+  });
+  return {
+    name: agent.name,
+    slug: agent.slug,
+    version: agent.version,
+    description: agent.description,
+    systemPrompt,
+    model: {
+      provider: agent.model?.provider || "anthropic",
+      name: agent.model?.name || "claude-sonnet-4-20250514",
+      temperature: agent.model?.temperature,
+      maxTokens: agent.model?.maxTokens
+    },
+    tools
+  };
+}
+function getBuiltinToolDescription(name) {
+  const descriptions = {
+    "entity.create": "Create a new entity",
+    "entity.get": "Get an entity by ID",
+    "entity.query": "Query entities by type and filters",
+    "entity.update": "Update an entity",
+    "entity.delete": "Delete an entity",
+    "entity.link": "Link two entities",
+    "entity.unlink": "Unlink two entities",
+    "event.emit": "Emit an event",
+    "event.query": "Query events",
+    "job.enqueue": "Schedule a background job",
+    "job.status": "Get job status"
+  };
+  return descriptions[name] || name;
+}
+function extractHandlerCode(handler) {
+  const code = handler.toString();
+  const arrowMatch = code.match(/(?:async\s*)?\([^)]*\)\s*=>\s*\{?([\s\S]*)\}?$/);
+  if (arrowMatch) {
+    let body = arrowMatch[1].trim();
+    if (body.startsWith("{") && body.endsWith("}")) {
+      body = body.slice(1, -1).trim();
+    }
+    return body;
+  }
+  const funcMatch = code.match(/(?:async\s*)?function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/);
+  if (funcMatch) {
+    return funcMatch[1].trim();
+  }
+  return code;
 }
 
 // src/cli/commands/dev.ts
-var devCommand = new Command3("dev").description("Sync agent to development environment").action(async () => {
+var devCommand = new Command3("dev").description("Sync all resources to development environment").action(async () => {
   const spinner = ora3();
   const cwd = process.cwd();
   console.log();
   console.log(chalk3.bold("Struere Dev"));
   console.log();
-  let project = loadProject(cwd);
   if (!hasProject(cwd)) {
     console.log(chalk3.yellow("No struere.json found"));
     console.log();
-    const setupResult = await interactiveSetup(cwd);
-    if (!setupResult) {
-      process.exit(0);
-    }
-    project = setupResult;
+    console.log(chalk3.gray("Run"), chalk3.cyan("struere init"), chalk3.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
   }
-  project = loadProject(cwd);
+  const version = getProjectVersion(cwd);
+  if (version === "1.0") {
+    console.log(chalk3.yellow("This is a v1 agent-centric project."));
+    console.log(chalk3.yellow("Please migrate to v2 structure or use an older CLI version."));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProjectV2(cwd);
   if (!project) {
     console.log(chalk3.red("Failed to load struere.json"));
     process.exit(1);
   }
-  console.log(chalk3.gray("Agent:"), chalk3.cyan(project.agent.name));
+  console.log(chalk3.gray("Organization:"), chalk3.cyan(project.organization.name));
   console.log();
-  spinner.start("Loading configuration");
-  await loadConfig(cwd);
-  spinner.succeed("Configuration loaded");
-  spinner.start("Loading agent");
-  let agent = await loadAgent(cwd);
-  spinner.succeed(`Agent "${agent.name}" loaded`);
-  const claudeMdPath = join7(cwd, "CLAUDE.md");
-  if (!existsSync5(claudeMdPath)) {
-    writeFileSync4(claudeMdPath, getClaudeMD(project.agent.slug));
-    console.log(chalk3.green("\u2713"), "Created CLAUDE.md");
-  }
   let credentials = loadCredentials();
   const apiKey = getApiKey();
   if (!credentials && !apiKey) {
@@ -1524,11 +1363,20 @@ var devCommand = new Command3("dev").description("Sync agent to development envi
       process.exit(1);
     }
   }
-  spinner.start("Syncing to Convex");
+  const claudeMdPath = join5(cwd, "CLAUDE.md");
+  if (!existsSync5(claudeMdPath)) {
+    writeFileSync4(claudeMdPath, getClaudeMDV2(project.organization.name));
+    console.log(chalk3.green("\u2713"), "Created CLAUDE.md");
+  }
+  const isAuthError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("Unauthenticated") || message.includes("OIDC") || message.includes("token") || message.includes("expired");
+  };
   const performSync = async () => {
     try {
-      const config = extractConfig(agent);
-      const result = await syncToConvex(project.agentId, config);
+      const resources = await loadAllResources(cwd);
+      const payload = extractSyncPayload(resources);
+      const result = await syncOrganization(payload);
       if (!result.success) {
         throw new Error(result.error || "Sync failed");
       }
@@ -1537,10 +1385,16 @@ var devCommand = new Command3("dev").description("Sync agent to development envi
       throw error;
     }
   };
-  const isAuthError = (error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("Unauthenticated") || message.includes("OIDC") || message.includes("token") || message.includes("expired");
-  };
+  spinner.start("Loading resources");
+  try {
+    const resources = await loadAllResources(cwd);
+    spinner.succeed(`Loaded ${resources.agents.length} agents, ${resources.entityTypes.length} entity types, ${resources.roles.length} roles`);
+  } catch (error) {
+    spinner.fail("Failed to load resources");
+    console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  spinner.start("Syncing to Convex");
   try {
     await performSync();
     spinner.succeed("Synced to development");
@@ -1570,13 +1424,18 @@ var devCommand = new Command3("dev").description("Sync agent to development envi
       process.exit(1);
     }
   }
-  const devUrl = `https://${project.agent.slug}-dev.struere.dev`;
-  console.log();
-  console.log(chalk3.green("Development URL:"), chalk3.cyan(devUrl));
   console.log();
   console.log(chalk3.gray("Watching for changes... Press Ctrl+C to stop"));
   console.log();
-  const watcher = chokidar.watch([join7(cwd, "src"), join7(cwd, "struere.config.ts")], {
+  const dirs = getResourceDirectories(cwd);
+  const watchPaths = [
+    dirs.agents,
+    dirs.entityTypes,
+    dirs.roles,
+    dirs.tools,
+    join5(cwd, "struere.config.ts")
+  ].filter((p) => existsSync5(p));
+  const watcher = chokidar.watch(watchPaths, {
     ignoreInitial: true,
     ignored: /node_modules/
   });
@@ -1585,7 +1444,6 @@ var devCommand = new Command3("dev").description("Sync agent to development envi
     console.log(chalk3.gray(`Changed: ${relativePath}`));
     const syncSpinner = ora3("Syncing...").start();
     try {
-      agent = await loadAgent(cwd);
       await performSync();
       syncSpinner.succeed("Synced");
     } catch (error) {
@@ -1600,217 +1458,50 @@ var devCommand = new Command3("dev").description("Sync agent to development envi
           return;
         }
         const retrySyncSpinner = ora3("Syncing...").start();
-        try {
-          await performSync();
-          retrySyncSpinner.succeed("Synced");
-        } catch (retryError) {
-          retrySyncSpinner.fail("Sync failed");
-          console.log(chalk3.red("Error:"), retryError instanceof Error ? retryError.message : String(retryError));
-        }
-      } else {
-        syncSpinner.fail("Sync failed");
-        console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
-      }
-    }
-  });
-  process.on("SIGINT", () => {
-    console.log();
-    watcher.close();
-    console.log(chalk3.gray("Stopped"));
-    process.exit(0);
-  });
-});
-async function interactiveSetup(cwd) {
-  const spinner = ora3();
-  let credentials = loadCredentials();
-  if (!credentials) {
-    console.log(chalk3.gray("Authentication required"));
-    console.log();
-    credentials = await performLogin();
-    if (!credentials) {
-      console.log(chalk3.red("Authentication failed"));
-      return null;
-    }
-  } else {
-    console.log(chalk3.green("\u2713"), "Logged in as", chalk3.cyan(credentials.user.name));
-    console.log();
-  }
-  spinner.start("Fetching agents");
-  const { agents: existingAgents, error: listError } = await listAgents();
-  if (listError) {
-    spinner.fail("Failed to fetch agents");
-    console.log();
-    console.log(chalk3.gray("Run"), chalk3.cyan("struere login"), chalk3.gray("to re-authenticate"));
-    return null;
-  }
-  const agents = existingAgents.map((a) => ({ id: a._id, name: a.name, slug: a.slug }));
-  spinner.succeed(`Found ${agents.length} existing agent(s)`);
-  let selectedAgent = null;
-  if (agents.length === 0) {
-    console.log(chalk3.gray("No existing agents found. Creating a new one..."));
-  } else {
-    console.log();
-    const choices = [
-      { value: "link", label: "Link to an existing agent" },
-      { value: "create", label: "Create a new agent" },
-      { value: "cancel", label: "Cancel" }
-    ];
-    const action = await promptChoiceArrows("No agent configured. Would you like to:", choices);
-    if (action === "cancel") {
-      console.log();
-      console.log(chalk3.gray("Run"), chalk3.cyan("struere init"), chalk3.gray("when ready to set up"));
-      return null;
-    }
-    if (action === "link") {
-      console.log();
-      const agentChoices = agents.map((a) => ({ value: a.id, label: `${a.name} (${a.slug})` }));
-      const agentId = await promptChoiceArrows("Select an agent:", agentChoices);
-      selectedAgent = agents.find((a) => a.id === agentId) || null;
-    }
-  }
-  if (!selectedAgent) {
-    console.log();
-    const projectName = slugify2(basename2(cwd));
-    const name = await promptText2("Agent name:", projectName);
-    const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-    spinner.start("Creating agent");
-    const { agentId, error: createError } = await createAgent({
-      name: displayName,
-      slug: name,
-      description: `${displayName} Agent`
-    });
-    if (createError || !agentId) {
-      spinner.fail("Failed to create agent");
-      console.log();
-      console.log(chalk3.red("Error:"), createError || "Unknown error");
-      return null;
-    }
-    selectedAgent = { id: agentId, name: displayName, slug: name };
-    spinner.succeed(`Created agent "${name}"`);
-  }
-  if (!selectedAgent) {
-    return null;
-  }
-  const projectData = {
-    agentId: selectedAgent.id,
-    team: credentials.organization.slug,
-    agent: {
-      slug: selectedAgent.slug,
-      name: selectedAgent.name
-    }
-  };
-  saveProject(cwd, projectData);
-  console.log(chalk3.green("\u2713"), "Created struere.json");
-  if (!hasAgentFiles(cwd)) {
-    const scaffoldResult = scaffoldAgentFiles(cwd, selectedAgent.slug);
-    for (const file of scaffoldResult.createdFiles) {
-      console.log(chalk3.green("\u2713"), `Created ${file}`);
-    }
-    console.log();
-    spinner.start("Installing dependencies");
-    try {
-      const proc = Bun.spawn(["bun", "install"], {
-        cwd,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      await proc.exited;
-      if (proc.exitCode === 0) {
-        spinner.succeed("Dependencies installed");
-      } else {
-        spinner.fail("Failed to install dependencies");
-        console.log(chalk3.yellow("Run"), chalk3.cyan("bun install"), chalk3.yellow("manually"));
-      }
-    } catch {
-      spinner.fail("Failed to install dependencies");
-      console.log(chalk3.yellow("Run"), chalk3.cyan("bun install"), chalk3.yellow("manually"));
-    }
-  }
-  console.log();
-  return projectData;
-}
-function slugify2(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-async function promptChoiceArrows(message, choices) {
-  return new Promise((resolve) => {
-    let selectedIndex = 0;
-    const render = () => {
-      process.stdout.write("\x1B[?25l");
-      process.stdout.write(`\x1B[${choices.length + 2}A`);
-      console.log(chalk3.gray(message));
-      console.log();
-      for (let i = 0;i < choices.length; i++) {
-        const prefix = i === selectedIndex ? chalk3.cyan("\u276F") : " ";
-        const label = i === selectedIndex ? chalk3.cyan(choices[i].label) : choices[i].label;
-        console.log(`${prefix} ${label}`);
+        try {
+          await performSync();
+          retrySyncSpinner.succeed("Synced");
+        } catch (retryError) {
+          retrySyncSpinner.fail("Sync failed");
+          console.log(chalk3.red("Error:"), retryError instanceof Error ? retryError.message : String(retryError));
+        }
+      } else {
+        syncSpinner.fail("Sync failed");
+        console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
       }
-    };
-    console.log(chalk3.gray(message));
-    console.log();
-    for (let i = 0;i < choices.length; i++) {
-      const prefix = i === selectedIndex ? chalk3.cyan("\u276F") : " ";
-      const label = i === selectedIndex ? chalk3.cyan(choices[i].label) : choices[i].label;
-      console.log(`${prefix} ${label}`);
     }
-    if (!process.stdin.isTTY) {
-      resolve(choices[0].value);
-      return;
+  });
+  watcher.on("add", async (path) => {
+    const relativePath = path.replace(cwd, ".");
+    console.log(chalk3.gray(`Added: ${relativePath}`));
+    const syncSpinner = ora3("Syncing...").start();
+    try {
+      await performSync();
+      syncSpinner.succeed("Synced");
+    } catch (error) {
+      syncSpinner.fail("Sync failed");
+      console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
     }
-    process.stdin.setRawMode?.(true);
-    process.stdin.resume();
-    const onKeypress = (key) => {
-      const char = key.toString();
-      if (char === "\x1B[A" || char === "k") {
-        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
-        render();
-      } else if (char === "\x1B[B" || char === "j") {
-        selectedIndex = (selectedIndex + 1) % choices.length;
-        render();
-      } else if (char === "\r" || char === `
-`) {
-        process.stdin.removeListener("data", onKeypress);
-        process.stdin.setRawMode?.(false);
-        process.stdin.pause();
-        process.stdout.write("\x1B[?25h");
-        resolve(choices[selectedIndex].value);
-      } else if (char === "\x03") {
-        process.stdin.removeListener("data", onKeypress);
-        process.stdin.setRawMode?.(false);
-        process.stdout.write("\x1B[?25h");
-        process.exit(0);
-      }
-    };
-    process.stdin.on("data", onKeypress);
   });
-}
-async function promptText2(message, defaultValue) {
-  process.stdout.write(chalk3.gray(`${message} `));
-  process.stdout.write(chalk3.cyan(`(${defaultValue}) `));
-  const answer = await readLine2();
-  return answer || defaultValue;
-}
-function readLine2() {
-  return new Promise((resolve) => {
-    let buffer = "";
-    const onData = (chunk) => {
-      const str = chunk.toString();
-      buffer += str;
-      if (str.includes(`
-`) || str.includes("\r")) {
-        process.stdin.removeListener("data", onData);
-        process.stdin.pause();
-        process.stdin.setRawMode?.(false);
-        resolve(buffer.replace(/[\r\n]/g, "").trim());
-      }
-    };
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode?.(false);
+  watcher.on("unlink", async (path) => {
+    const relativePath = path.replace(cwd, ".");
+    console.log(chalk3.gray(`Removed: ${relativePath}`));
+    const syncSpinner = ora3("Syncing...").start();
+    try {
+      await performSync();
+      syncSpinner.succeed("Synced");
+    } catch (error) {
+      syncSpinner.fail("Sync failed");
+      console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
     }
-    process.stdin.resume();
-    process.stdin.on("data", onData);
   });
-}
+  process.on("SIGINT", () => {
+    console.log();
+    watcher.close();
+    console.log(chalk3.gray("Stopped"));
+    process.exit(0);
+  });
+});
 
 // src/cli/commands/build.ts
 import { Command as Command4 } from "commander";
@@ -1818,6 +1509,74 @@ import chalk4 from "chalk";
 import ora4 from "ora";
 import { join as join8 } from "path";
 
+// src/cli/utils/config.ts
+import { join as join6 } from "path";
+var defaultConfig = {
+  port: 3000,
+  host: "localhost",
+  cors: {
+    origins: ["http://localhost:3000"],
+    credentials: true
+  },
+  logging: {
+    level: "info",
+    format: "pretty"
+  },
+  auth: {
+    type: "none"
+  }
+};
+async function loadConfig(cwd) {
+  const configPath = join6(cwd, "struere.config.ts");
+  try {
+    const module = await import(configPath);
+    const config = module.default || module;
+    return {
+      ...defaultConfig,
+      ...config,
+      cors: {
+        ...defaultConfig.cors,
+        ...config.cors
+      },
+      logging: {
+        ...defaultConfig.logging,
+        ...config.logging
+      },
+      auth: {
+        ...defaultConfig.auth,
+        ...config.auth
+      }
+    };
+  } catch {
+    return defaultConfig;
+  }
+}
+
+// src/cli/utils/agent.ts
+import { join as join7 } from "path";
+async function loadAgent(cwd) {
+  const agentPath = join7(cwd, "src/agent.ts");
+  try {
+    const module = await import(`${agentPath}?t=${Date.now()}`);
+    const agent = module.default || module;
+    if (!agent.name) {
+      throw new Error("Agent must have a name");
+    }
+    if (!agent.version) {
+      throw new Error("Agent must have a version");
+    }
+    if (!agent.systemPrompt) {
+      throw new Error("Agent must have a systemPrompt");
+    }
+    return agent;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(`Agent not found at ${agentPath}`);
+    }
+    throw error;
+  }
+}
+
 // src/cli/utils/validate.ts
 function validateAgent(agent) {
   const errors = [];
@@ -2138,12 +1897,11 @@ function formatAssertionError(assertion, context) {
 import { Command as Command6 } from "commander";
 import chalk6 from "chalk";
 import ora6 from "ora";
-var deployCommand = new Command6("deploy").description("Deploy agent to production").option("--dry-run", "Show what would be deployed without deploying").action(async (options) => {
-  const environment = "production";
+var deployCommand = new Command6("deploy").description("Deploy all agents to production").option("--dry-run", "Show what would be deployed without deploying").action(async (options) => {
   const spinner = ora6();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk6.bold("Deploying Agent"));
+  console.log(chalk6.bold("Deploying Agents"));
   console.log();
   if (!hasProject(cwd)) {
     console.log(chalk6.yellow("No struere.json found"));
@@ -2152,59 +1910,73 @@ var deployCommand = new Command6("deploy").description("Deploy agent to producti
     console.log();
     process.exit(1);
   }
-  const project = loadProject(cwd);
+  const version = getProjectVersion(cwd);
+  if (version === "1.0") {
+    console.log(chalk6.yellow("This is a v1 agent-centric project."));
+    console.log(chalk6.yellow("Please migrate to v2 structure or use an older CLI version."));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProjectV2(cwd);
   if (!project) {
     console.log(chalk6.red("Failed to load struere.json"));
     process.exit(1);
   }
-  console.log(chalk6.gray("Agent:"), chalk6.cyan(project.agent.name));
+  console.log(chalk6.gray("Organization:"), chalk6.cyan(project.organization.name));
   console.log();
-  spinner.start("Loading configuration");
-  await loadConfig(cwd);
-  spinner.succeed("Configuration loaded");
-  spinner.start("Loading agent");
-  const agent = await loadAgent(cwd);
-  spinner.succeed(`Agent "${agent.name}" loaded`);
-  spinner.start("Validating agent");
-  const errors = validateAgent(agent);
-  if (errors.length > 0) {
-    spinner.fail("Validation failed");
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    console.log(chalk6.red("Not authenticated"));
     console.log();
-    for (const error of errors) {
-      console.log(chalk6.red("  x"), error);
-    }
+    console.log(chalk6.gray("Run"), chalk6.cyan("struere login"), chalk6.gray("to authenticate"));
+    console.log(chalk6.gray("Or set"), chalk6.cyan("STRUERE_API_KEY"), chalk6.gray("environment variable"));
     console.log();
     process.exit(1);
   }
-  spinner.succeed("Agent validated");
+  spinner.start("Loading resources");
+  let resources;
+  try {
+    resources = await loadAllResources(cwd);
+    spinner.succeed(`Loaded ${resources.agents.length} agents, ${resources.entityTypes.length} entity types, ${resources.roles.length} roles`);
+  } catch (error) {
+    spinner.fail("Failed to load resources");
+    console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (resources.agents.length === 0) {
+    console.log();
+    console.log(chalk6.yellow("No agents found to deploy"));
+    console.log();
+    console.log(chalk6.gray("Run"), chalk6.cyan("struere add agent my-agent"), chalk6.gray("to create an agent"));
+    console.log();
+    return;
+  }
   if (options.dryRun) {
     console.log();
     console.log(chalk6.yellow("Dry run mode - no changes will be made"));
     console.log();
     console.log("Would deploy:");
-    console.log(chalk6.gray("  -"), `Agent: ${chalk6.cyan(agent.name)}`);
-    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(agent.version)}`);
-    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(environment)}`);
-    console.log(chalk6.gray("  -"), `Agent ID: ${chalk6.cyan(project.agentId)}`);
+    for (const agent of resources.agents) {
+      console.log(chalk6.gray("  -"), `${chalk6.cyan(agent.name)} (${agent.slug}) v${agent.version}`);
+    }
     console.log();
-    return;
-  }
-  const credentials = loadCredentials();
-  const apiKey = getApiKey();
-  if (!credentials && !apiKey) {
-    spinner.fail("Not authenticated");
+    console.log("Entity types:");
+    for (const et of resources.entityTypes) {
+      console.log(chalk6.gray("  -"), chalk6.cyan(et.name), `(${et.slug})`);
+    }
     console.log();
-    console.log(chalk6.gray("Run"), chalk6.cyan("struere login"), chalk6.gray("to authenticate"));
-    console.log(chalk6.gray("Or set"), chalk6.cyan("STRUERE_API_KEY"), chalk6.gray("environment variable"));
+    console.log("Roles:");
+    for (const role of resources.roles) {
+      console.log(chalk6.gray("  -"), chalk6.cyan(role.name));
+    }
     console.log();
-    process.exit(1);
+    return;
   }
-  spinner.start("Extracting agent configuration");
-  const config = extractConfig(agent);
-  spinner.succeed("Configuration extracted");
   spinner.start("Syncing to development");
   try {
-    const syncResult = await syncToConvex(project.agentId, config);
+    const payload = extractSyncPayload(resources);
+    const syncResult = await syncOrganization(payload);
     if (!syncResult.success) {
       throw new Error(syncResult.error || "Sync failed");
     }
@@ -2214,24 +1986,34 @@ var deployCommand = new Command6("deploy").description("Deploy agent to producti
     console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
-  spinner.start(`Deploying to ${environment}`);
+  spinner.start("Deploying to production");
   try {
-    const deployResult = await deployToProduction(project.agentId);
+    const deployResult = await deployAllAgents();
     if (!deployResult.success) {
       throw new Error(deployResult.error || "Deployment failed");
     }
-    spinner.succeed(`Deployed to ${environment}`);
-    const prodUrl = `https://${project.agent.slug}.struere.dev`;
+    spinner.succeed("Deployed to production");
     console.log();
-    console.log(chalk6.green("Success!"), "Agent deployed");
+    console.log(chalk6.green("Success!"), "All agents deployed");
     console.log();
-    console.log("Deployment details:");
-    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(agent.version)}`);
-    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(environment)}`);
-    console.log(chalk6.gray("  -"), `URL: ${chalk6.cyan(prodUrl)}`);
+    if (deployResult.deployed && deployResult.deployed.length > 0) {
+      console.log("Deployed agents:");
+      for (const slug of deployResult.deployed) {
+        const agent = resources.agents.find((a) => a.slug === slug);
+        const prodUrl = `https://${slug}.struere.dev`;
+        console.log(chalk6.gray("  -"), chalk6.cyan(agent?.name || slug), chalk6.gray(`\u2192 ${prodUrl}`));
+      }
+    }
+    if (deployResult.skipped && deployResult.skipped.length > 0) {
+      console.log();
+      console.log(chalk6.yellow("Skipped (no development config):"));
+      for (const slug of deployResult.skipped) {
+        console.log(chalk6.gray("  -"), slug);
+      }
+    }
     console.log();
-    console.log(chalk6.gray("Test your agent:"));
-    console.log(chalk6.gray("  $"), chalk6.cyan(`curl -X POST ${prodUrl}/chat -H "Authorization: Bearer YOUR_API_KEY" -d '{"message": "Hello"}'`));
+    console.log(chalk6.gray("Test your agents:"));
+    console.log(chalk6.gray("  $"), chalk6.cyan(`curl -X POST https://<agent-slug>.struere.dev/chat -H "Authorization: Bearer YOUR_API_KEY" -d '{"message": "Hello"}'`));
     console.log();
   } catch (error) {
     spinner.fail("Deployment failed");
@@ -2469,10 +2251,223 @@ var whoamiCommand = new Command11("whoami").description("Show current logged in
     console.log();
   }
 });
+
+// src/cli/commands/add.ts
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
+var addCommand = new Command12("add").description("Scaffold a new resource").argument("<type>", "Resource type: agent, entity-type, or role").argument("<name>", "Resource name").action(async (type, name) => {
+  const cwd = process.cwd();
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk12.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk12.gray("Run"), chalk12.cyan("struere init"), chalk12.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const version = getProjectVersion(cwd);
+  if (version === "1.0") {
+    console.log(chalk12.yellow("This is a v1 agent-centric project."));
+    console.log(chalk12.yellow("The add command requires v2 structure."));
+    console.log();
+    process.exit(1);
+  }
+  const slug = slugify2(name);
+  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  let result;
+  switch (type.toLowerCase()) {
+    case "agent":
+      result = scaffoldAgent(cwd, displayName, slug);
+      if (result.createdFiles.length > 0) {
+        console.log(chalk12.green("\u2713"), `Created agent "${displayName}"`);
+        for (const file of result.createdFiles) {
+          console.log(chalk12.gray("  \u2192"), file);
+        }
+      } else {
+        console.log(chalk12.yellow("Agent already exists:"), `agents/${slug}.ts`);
+      }
+      break;
+    case "entity-type":
+    case "entitytype":
+    case "type":
+      result = scaffoldEntityType(cwd, displayName, slug);
+      if (result.createdFiles.length > 0) {
+        console.log(chalk12.green("\u2713"), `Created entity type "${displayName}"`);
+        for (const file of result.createdFiles) {
+          console.log(chalk12.gray("  \u2192"), file);
+        }
+      } else {
+        console.log(chalk12.yellow("Entity type already exists:"), `entity-types/${slug}.ts`);
+      }
+      break;
+    case "role":
+      result = scaffoldRole(cwd, slug);
+      if (result.createdFiles.length > 0) {
+        console.log(chalk12.green("\u2713"), `Created role "${slug}"`);
+        for (const file of result.createdFiles) {
+          console.log(chalk12.gray("  \u2192"), file);
+        }
+      } else {
+        console.log(chalk12.yellow("Role already exists:"), `roles/${slug}.ts`);
+      }
+      break;
+    default:
+      console.log(chalk12.red("Unknown resource type:"), type);
+      console.log();
+      console.log("Available types:");
+      console.log(chalk12.gray("  -"), chalk12.cyan("agent"), "- Create an AI agent");
+      console.log(chalk12.gray("  -"), chalk12.cyan("entity-type"), "- Create an entity type schema");
+      console.log(chalk12.gray("  -"), chalk12.cyan("role"), "- Create a role with permissions");
+      console.log();
+      process.exit(1);
+  }
+  console.log();
+  console.log(chalk12.gray("Run"), chalk12.cyan("struere dev"), chalk12.gray("to sync changes"));
+  console.log();
+});
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/cli/commands/status.ts
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+import ora11 from "ora";
+var statusCommand = new Command13("status").description("Compare local vs remote state").action(async () => {
+  const spinner = ora11();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk13.bold("Struere Status"));
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk13.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk13.gray("Run"), chalk13.cyan("struere init"), chalk13.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const version = getProjectVersion(cwd);
+  if (version === "1.0") {
+    console.log(chalk13.yellow("This is a v1 agent-centric project."));
+    console.log(chalk13.yellow("The status command requires v2 structure."));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProjectV2(cwd);
+  if (!project) {
+    console.log(chalk13.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  console.log(chalk13.gray("Organization:"), chalk13.cyan(project.organization.name));
+  console.log();
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    console.log(chalk13.red("Not authenticated"));
+    console.log();
+    console.log(chalk13.gray("Run"), chalk13.cyan("struere login"), chalk13.gray("to authenticate"));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Loading local resources");
+  let localResources;
+  try {
+    localResources = await loadAllResources(cwd);
+    spinner.succeed("Local resources loaded");
+  } catch (error) {
+    spinner.fail("Failed to load local resources");
+    console.log(chalk13.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  spinner.start("Fetching remote state");
+  const { state: remoteState, error: fetchError } = await getSyncState();
+  if (fetchError || !remoteState) {
+    spinner.fail("Failed to fetch remote state");
+    console.log(chalk13.red("Error:"), fetchError || "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Remote state fetched");
+  console.log();
+  const localAgentSlugs = new Set(localResources.agents.map((a) => a.slug));
+  const remoteAgentSlugs = new Set(remoteState.agents.map((a) => a.slug));
+  const localEntityTypeSlugs = new Set(localResources.entityTypes.map((et) => et.slug));
+  const remoteEntityTypeSlugs = new Set(remoteState.entityTypes.map((et) => et.slug));
+  const localRoleNames = new Set(localResources.roles.map((r) => r.name));
+  const remoteRoleNames = new Set(remoteState.roles.map((r) => r.name));
+  console.log(chalk13.bold("Agents"));
+  console.log(chalk13.gray("\u2500".repeat(60)));
+  if (localResources.agents.length === 0 && remoteState.agents.length === 0) {
+    console.log(chalk13.gray("  No agents"));
+  } else {
+    for (const agent of localResources.agents) {
+      const remote = remoteState.agents.find((a) => a.slug === agent.slug);
+      if (remote) {
+        const statusIcon = remote.hasProdConfig ? chalk13.green("\u25CF") : chalk13.yellow("\u25CB");
+        console.log(`  ${statusIcon} ${chalk13.cyan(agent.name)} (${agent.slug}) - v${agent.version}`);
+        if (!remote.hasProdConfig) {
+          console.log(chalk13.gray("      Not deployed to production"));
+        }
+      } else {
+        console.log(`  ${chalk13.blue("+")} ${chalk13.cyan(agent.name)} (${agent.slug}) - ${chalk13.blue("new")}`);
+      }
+    }
+    for (const remote of remoteState.agents) {
+      if (!localAgentSlugs.has(remote.slug)) {
+        console.log(`  ${chalk13.red("-")} ${remote.name} (${remote.slug}) - ${chalk13.red("will be deleted")}`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk13.bold("Entity Types"));
+  console.log(chalk13.gray("\u2500".repeat(60)));
+  if (localResources.entityTypes.length === 0 && remoteState.entityTypes.length === 0) {
+    console.log(chalk13.gray("  No entity types"));
+  } else {
+    for (const et of localResources.entityTypes) {
+      const remote = remoteState.entityTypes.find((r) => r.slug === et.slug);
+      if (remote) {
+        console.log(`  ${chalk13.green("\u25CF")} ${chalk13.cyan(et.name)} (${et.slug})`);
+      } else {
+        console.log(`  ${chalk13.blue("+")} ${chalk13.cyan(et.name)} (${et.slug}) - ${chalk13.blue("new")}`);
+      }
+    }
+    for (const remote of remoteState.entityTypes) {
+      if (!localEntityTypeSlugs.has(remote.slug)) {
+        console.log(`  ${chalk13.red("-")} ${remote.name} (${remote.slug}) - ${chalk13.red("will be deleted")}`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk13.bold("Roles"));
+  console.log(chalk13.gray("\u2500".repeat(60)));
+  if (localResources.roles.length === 0 && remoteState.roles.length === 0) {
+    console.log(chalk13.gray("  No roles"));
+  } else {
+    for (const role of localResources.roles) {
+      const remote = remoteState.roles.find((r) => r.name === role.name);
+      if (remote) {
+        console.log(`  ${chalk13.green("\u25CF")} ${chalk13.cyan(role.name)} (${role.policies.length} policies)`);
+      } else {
+        console.log(`  ${chalk13.blue("+")} ${chalk13.cyan(role.name)} - ${chalk13.blue("new")}`);
+      }
+    }
+    for (const remote of remoteState.roles) {
+      if (!localRoleNames.has(remote.name)) {
+        console.log(`  ${chalk13.red("-")} ${remote.name} - ${chalk13.red("will be deleted")}`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk13.gray("Legend:"));
+  console.log(chalk13.gray("  "), chalk13.green("\u25CF"), "Synced", chalk13.yellow("\u25CB"), "Not deployed", chalk13.blue("+"), "New", chalk13.red("-"), "Will be deleted");
+  console.log();
+  console.log(chalk13.gray("Run"), chalk13.cyan("struere dev"), chalk13.gray("to sync changes"));
+  console.log();
+});
 // package.json
 var package_default = {
   name: "struere",
-  version: "0.3.10",
+  version: "0.4.0",
   description: "Build, test, and deploy AI agents",
   keywords: [
     "ai",
@@ -2577,4 +2572,6 @@ program.addCommand(deployCommand);
 program.addCommand(validateCommand);
 program.addCommand(logsCommand);
 program.addCommand(stateCommand);
+program.addCommand(addCommand);
+program.addCommand(statusCommand);
 program.parse();