@claudetools/tools 0.9.1 → 0.9.2

package/dist/helpers/tasks.d.ts

@@ -142,6 +142,27 @@ export declare const LOCK_DURATION_BY_EFFORT: {
     readonly xl: 240;
 };
 export declare const DEFAULT_CAPACITY_BUDGET = 20;
+/**
+ * Workflow violation types for enforcement
+ */
+export interface WorkflowViolation {
+    type: 'no_active_task' | 'no_task_plan' | 'task_not_started';
+    message: string;
+    severity: 'warning' | 'error';
+}
+/**
+ * Get the active task for a specific agent (if any)
+ * Returns the task that is currently claimed by this agent
+ */
+export declare function getActiveTaskForAgent(userId: string, projectId: string, agentId: string): Promise<Task | null>;
+/**
+ * Check workflow compliance and return any violations
+ * Call this before completing significant work to ensure proper workflow was followed
+ */
+export declare function checkWorkflowCompliance(userId: string, projectId: string, agentId: string, context?: {
+    isCompletingTask?: boolean;
+    taskId?: string;
+}): Promise<WorkflowViolation[]>;
 /**
  * Get effort-weighted load of currently active tasks
  * Returns both in_progress and claimed (locked) task counts, plus effort-weighted load

package/dist/helpers/tasks.js

@@ -112,6 +112,58 @@ export const LOCK_DURATION_BY_EFFORT = {
 // Configuration: Default capacity budget in effort units
 // 20 units allows: 20 xs tasks OR 1 xl + 1 m task OR 5 m tasks, etc.
 export const DEFAULT_CAPACITY_BUDGET = 20;
+/**
+ * Get the active task for a specific agent (if any)
+ * Returns the task that is currently claimed by this agent
+ */
+export async function getActiveTaskForAgent(userId, projectId, agentId) {
+    const result = await listTasks(userId, projectId, {
+        status: 'in_progress',
+        assigned_to: agentId,
+        limit: 1,
+    });
+    if (!result.success || result.data.length === 0) {
+        return null;
+    }
+    // Check if the lock is still valid
+    const task = result.data[0];
+    if (task.lock_expires_at) {
+        const lockExpires = new Date(task.lock_expires_at);
+        if (lockExpires > new Date()) {
+            return task;
+        }
+    }
+    return null;
+}
+/**
+ * Check workflow compliance and return any violations
+ * Call this before completing significant work to ensure proper workflow was followed
+ */
+export async function checkWorkflowCompliance(userId, projectId, agentId, context = {}) {
+    const violations = [];
+    // Check 1: Is there an active task for this agent?
+    const activeTask = await getActiveTaskForAgent(userId, projectId, agentId);
+    if (!activeTask && !context.isCompletingTask) {
+        violations.push({
+            type: 'no_active_task',
+            message: '⚠️ No active task. Use task_start before beginning work.',
+            severity: 'warning',
+        });
+    }
+    // Check 2: If completing a task, was it properly started?
+    if (context.isCompletingTask && context.taskId) {
+        // We'll just note if the task wasn't claimed - the handler already handles this
+        // by auto-claiming, but we can still warn about the pattern
+        if (!activeTask || activeTask.id !== context.taskId) {
+            violations.push({
+                type: 'task_not_started',
+                message: '⚠️ Task was not started with task_start. Consider using proper workflow.',
+                severity: 'warning',
+            });
+        }
+    }
+    return violations;
+}
 /**
  * Get effort-weighted load of currently active tasks
  * Returns both in_progress and claimed (locked) task counts, plus effort-weighted load

package/dist/helpers/workers.d.ts

@@ -14,7 +14,7 @@ export declare const EXPERT_WORKERS: Record<string, ExpertWorker>;
  *
  * This function uses the new template system that includes:
  * - XML semantic boundaries for machine-parseable structure
- * - CodeDNA integration instructions (95-99% token savings for CRUD)
+ * - Codegen integration instructions (95-99% token savings for CRUD)
  * - Tool usage priorities (memory_search, codebase_find before writing)
  * - Tier-based complexity (minimal/standard/professional)
  *

package/dist/helpers/workers.js

@@ -2,10 +2,10 @@
 // Expert Worker Definitions (Orchestration System)
 // =============================================================================
 //
-// Updated with 10/10 AI System Prompt Architecture and CodeDNA integration.
-// Workers now know to use CodeDNA generators before writing boilerplate code.
+// Updated with 10/10 AI System Prompt Architecture.
+// Workers know to use codegen before writing boilerplate code.
 //
-import { buildWorkerPromptWithCodeDNA, } from '../templates/worker-prompt.js';
+import { buildWorkerPrompt as templateBuildWorkerPrompt, } from '../templates/worker-prompt.js';
 export const EXPERT_WORKERS = {
     'schema-expert': {
         id: 'schema-expert',
@@ -19,7 +19,7 @@ export const EXPERT_WORKERS = {
 - Index optimisation
 - Data modelling decisions
 
-CODEDNA: If task includes Entity DSL (e.g., "User(email:string:unique)"),
+CODEGEN: If task includes Entity DSL (e.g., "User(email:string:unique)"),
 the API layer will be generated automatically. Focus only on SQL schema.
 
 Focus only on schema-related changes. Do not modify application code.
@@ -38,15 +38,15 @@ When complete, provide a concise summary of changes made.`,
 - Error handling for endpoints
 
 PATTERN DETECTION (for existing projects):
-1. Call codedna_detect_patterns(package_json) to find existing patterns
+1. Check package.json for existing patterns
 2. MATCH detected patterns - don't introduce conflicting libraries
 3. Check for: zod vs yup validation, tanstack-query vs swr, etc.
 
-CODEDNA PRIORITY: Before writing CRUD code manually:
-1. Call codedna_list_generators() to discover available generators
+CODEGEN PRIORITY: Before writing CRUD code manually:
+1. Call codegen_list() to discover available generators
 2. Look for Entity DSL in task (e.g., "User(email:string:unique, password:string:hashed)")
 3. Detect framework from project (check package.json, existing patterns)
-4. Call codedna_generate_api(spec, framework="<detected>", options={...})
+4. Call codegen({ describe: "...", generate: [...], stack: {...} })
 5. Only write manually for complex business logic that can't be generated
 
 Focus only on API-related changes. Do not modify schema or extraction code.
@@ -119,20 +119,20 @@ When complete, provide a concise summary of integrations configured.`,
 - Client-side state management
 
 PATTERN DETECTION (CRITICAL for existing projects):
-1. Call codedna_detect_patterns(package_json) to detect existing patterns
+1. Check package.json to detect existing patterns
 2. RESPECT detected patterns - consistency > "better":
    - Compound components? Use compound pattern
    - React Hook Form? Don't introduce Formik
    - Zustand? Don't add Redux
    - Tailwind? Match styling approach
-3. Check codedna_list_patterns(category="anti-patterns") for code smells to avoid
+3. Check for common anti-patterns
 
-CODEDNA PRIORITY: Before writing UI components manually:
-1. Call codedna_list_generators() to discover available generators
+CODEGEN PRIORITY: Before writing UI components manually:
+1. Call codegen_list() to discover available generators
 2. Detect UI framework from project (check package.json for react, vue, etc.)
 3. Check for UI library (package.json: @shadcn/ui, @mui/material, @chakra-ui, etc.)
-4. Call codedna_generate_frontend or codedna_generate_component with detected settings
-5. DO NOT assume any specific framework/library - discover via list_generators, detect from project
+4. Call codegen({ describe: "...", generate: ["components"], stack: {...} })
+5. DO NOT assume any specific framework/library - discover via codegen_list, detect from project
 
 TOOLS: Use codebase_find to discover existing component patterns.
 TOOLS: Use memory_search for past UI decisions.
@@ -148,8 +148,8 @@ When complete, provide a concise summary of components created.`,
         capabilities: ['general-development', 'refactoring', 'documentation', 'testing'],
         promptTemplate: `You are a general purpose development expert.
 
-CODEDNA - DISCOVER THEN DETECT:
-1. Call codedna_list_generators() to see what's available
+CODEGEN - DISCOVER THEN DETECT:
+1. Call codegen_list() to see what's available
 2. Detect project framework from package.json/pyproject.toml
 3. Match detected framework to generator capabilities
 4. If no match, ASK the user which framework to use
@@ -170,7 +170,7 @@ When complete, provide a concise summary of work done.`,
  *
  * This function uses the new template system that includes:
  * - XML semantic boundaries for machine-parseable structure
- * - CodeDNA integration instructions (95-99% token savings for CRUD)
+ * - Codegen integration instructions (95-99% token savings for CRUD)
  * - Tool usage priorities (memory_search, codebase_find before writing)
  * - Tier-based complexity (minimal/standard/professional)
  *
@@ -189,8 +189,8 @@ export function buildWorkerPrompt(params, tier = 'standard') {
         content: ctx.content,
         source: ctx.source,
     }));
-    // Use the new 10/10 template system
-    return buildWorkerPromptWithCodeDNA({
+    // Use the 10/10 template system
+    return templateBuildWorkerPrompt({
         task: {
             id: task.id,
             title: task.title,

package/dist/setup.d.ts

@@ -2,3 +2,4 @@ export declare function runSetup(): Promise<void>;
 export declare function runUninstall(): Promise<void>;
 export declare function runInit(): Promise<void>;
 export declare function runCleanup(): Promise<void>;
+export declare function runOnboard(): Promise<void>;

package/dist/setup.js

@@ -1040,31 +1040,33 @@ docs_cache({ library: "tanstack-query" })
 
 This enables future sessions to reference up-to-date documentation.
 
-### Code Generation Tools
+### Code Generation
 
-**IMPORTANT**: When the project involves APIs, frontends, or full-stack development, inform the user about available code generation tools that can save 95%+ tokens:
+**IMPORTANT**: When the project involves APIs or data models, use the \`codegen\` tool to save 95%+ tokens:
 
-**Kappa v2.5** - For full-stack applications:
-- Use when: Multiple entities, pages, forms, API routes
-- Tools: \`kappa_parse\`, \`kappa_generate_all\`, \`kappa_generate_schema\`, etc.
-- Generates: Drizzle schemas, Zod validators, API routes, pages, forms, design tokens
+\`\`\`typescript
+codegen({ describe: "User with email, password, role (admin/user)" })
+\`\`\`
 
-**CodeDNA** - For individual components:
-- Use when: Single entity, specific component, or targeted generation
-- Tools: \`codedna_generate_api\`, \`codedna_generate_frontend\`, \`codedna_generate_component\`
-- Supports: Express, FastAPI, NestJS, Hono, React, Vue, SvelteKit
+**What it generates:**
+- Drizzle schema (database tables)
+- TypeScript types
+- Zod validators
+- API routes (Hono/Express)
 
-During onboarding, if the user is building:
-- **Full-stack app with multiple entities** → Suggest Kappa: "For your Next.js app with User, Task, and Project entities, I can use Kappa to generate your entire backend and frontend from a compact spec. Would you like to see an example?"
-- **Single API or component** → Suggest CodeDNA: "For this API, I can use CodeDNA to generate the routes, validation, and types. This saves significant time and tokens."
+**Smart field inference:**
+- \`email\` → email type, \`password\` → hashed, \`createdAt\` → timestamp
+- \`price\` → decimal, \`isActive\` → boolean, \`(admin/user)\` → enum
+
+Stack is auto-detected from package.json (Drizzle, Hono, Express, etc.)
 
 Store code generation preferences:
 \`\`\`typescript
 memory_store_fact({
   entity1: "ProjectName",
-  relationship: "PREFERS",
-  entity2: "Kappa",
-  context: "User prefers Kappa for full-stack generation"
+  relationship: "USES",
+  entity2: "codegen",
+  context: "Project uses codegen for schema/types/validators generation"
 })
 \`\`\`
 
@@ -2033,3 +2035,34 @@ export async function runCleanup() {
     console.log('\n' + chalk.green('  Cleanup complete!'));
     console.log(chalk.dim('  Restart Claude Code for changes to take effect.\n'));
 }
+// -----------------------------------------------------------------------------
+// Onboard Command (standalone)
+// -----------------------------------------------------------------------------
+export async function runOnboard() {
+    const cwd = process.cwd();
+    const projectName = basename(cwd);
+    // Load config
+    const config = await loadConfigFromFile();
+    if (!config?.apiKey) {
+        error('Not configured. Run: claudetools --setup');
+        process.exit(1);
+    }
+    const apiUrl = config.apiUrl || DEFAULT_CONFIG.apiUrl;
+    const apiKey = config.apiKey;
+    // Find project for current directory
+    if (!existsSync(PROJECTS_FILE)) {
+        error('No projects registered. Run: claudetools init');
+        process.exit(1);
+    }
+    const projectsData = JSON.parse(readFileSync(PROJECTS_FILE, 'utf-8'));
+    const binding = projectsData.bindings?.find((b) => b.local_path === cwd);
+    if (!binding) {
+        error('Current directory is not a registered project.');
+        info('Run: claudetools init');
+        process.exit(1);
+    }
+    const projectId = binding.project_id;
+    const displayName = binding.project_name || projectName;
+    // Run the onboarding flow
+    await runOnboarding(apiUrl, apiKey, projectId, displayName);
+}

package/dist/templates/claude-md.d.ts

@@ -5,7 +5,7 @@ export declare const PROJECT_SECTION_END = "<!-- CLAUDETOOLS:PROJECT:END -->";
 /**
  * Global CLAUDE.md content - added to ~/.claude/CLAUDE.md
  */
-export declare const GLOBAL_TEMPLATE = "\n<!-- CLAUDETOOLS:START -->\n# ClaudeTools Memory System\n\nYou have access to a persistent memory system. **Context is AUTO-INJECTED via hooks** - you rarely need to call memory tools explicitly.\n\n## \u26A0\uFE0F IMPORTANT: Hooks vs MCP Tools\n\n**AUTOMATIC (via hooks - zero context cost):**\n- Context injection \u2192 `user-prompt-submit` hook runs on every message\n- Fact extraction \u2192 `post-tool-use` hook extracts from your work\n- Session context \u2192 `session-start` hook provides initial context\n\n**EXPLICIT (MCP tools - costs context):**\n- `memory_store_fact` \u2192 Store a specific fact you learned\n- `task_plan` / `task_start` / `task_complete` \u2192 Task management\n\n**DO NOT CALL these tools routinely (context already injected):**\n- `memory_search` - only if you need DIFFERENT search params\n- `memory_inject` - only if you need to refresh for a different query\n- `memory_get_context` - only for debugging\n- `memory_index` - only for debugging\n\n## Storing Facts (DO use this)\n```\nmemory_store_fact(\n  entity1: \"UserService\",\n  relationship: \"USES\",\n  entity2: \"bcrypt\",\n  context: \"Password hashing uses bcrypt with 12 rounds\"\n)\n```\nStore important facts when you learn something concrete. The `post-tool-use` hook also extracts facts automatically.\n\n## Task Management\n\n### Creating Work Plans with Auto-Dispatch\n```\ntask_plan(\n  goal: \"Add user authentication\",\n  epic_title: \"User Auth System\",\n  tasks: [...]\n)\n```\nBreak down complex work into tracked tasks. **Tasks are automatically set to `ready` status.**\n\nAfter `task_plan` completes, you will receive Task tool invocations to spawn parallel agents.\n**Execute ALL Task tool calls in a SINGLE message** to enable parallel execution.\n\n### Parallel Agent Workflow\n1. User describes work needed\n2. Call `task_plan_draft` to present the plan\n3. User says \"go\" to approve\n4. Call `task_plan` - tasks created in `ready` status\n5. Execute the provided Task tool calls in ONE message\n6. Agents work in parallel, each calling `task_complete` when done\n\n### Manual Task Start (Sequential)\n```\ntask_start(task_id: \"task_xxx\")\n```\nClaim a task before working on it. Use for sequential execution.\n\n### Completing Tasks\n```\ntask_complete(task_id: \"task_xxx\", summary: \"Implemented JWT auth with refresh tokens\")\n```\nMark tasks done with a summary of work completed. **Always call this when a task is finished.**\n\n## Codebase Intelligence\n\n### Start with codebase_map() - ALWAYS\n```\ncodebase_map()  # FIRST TOOL when exploring unfamiliar code\n```\n**When to use:** Starting a new task, exploring unfamiliar code, understanding project structure, finding entry points.\n\nThe map shows:\n- Project structure and key directories\n- Entry points and their exports\n- Framework detection (React, Express, etc.)\n- Key symbols and their locations\n\n**Use codebase_map BEFORE using Grep/Glob** - it gives you the lay of the land so you know where to look.\n\n### Then use targeted tools\n```\ncodebase_find(\"UserService\")  # Find specific symbols/files\ncodebase_context(\"src/auth.ts\")  # Get file dependencies\nanalyze_impact(\"validateToken\")  # See what changing a function affects\n```\n\n## CodeDNA: Generate Code, Save 99% Tokens\n\n**BEFORE writing ANY code, check if CodeDNA can generate it.** Call `codedna_list_generators()` to see available generators.\n\n### Available Generators (20+)\n\n| Category | Frameworks | Tool |\n|----------|------------|------|\n| **API** | Express, FastAPI, NestJS, Hono, Elysia, tRPC | `codedna_generate_api` |\n| **Frontend** | React, Vue, SvelteKit, Astro, React Router v7, TanStack Start | `codedna_generate_frontend` |\n| **ORM** | Prisma, Drizzle | `codedna_generate_api` with database option |\n| **Auth** | Better Auth, Auth.js, Lucia | `codedna_generate_api` with auth option |\n| **Components** | Forms, Tables, Cards, Modals (React/Vue/Svelte) | `codedna_generate_component` |\n\n### Usage Examples\n\n```typescript\n// API with auth and validation\ncodedna_generate_api({\n  spec: \"User(email:string:unique, password:string:hashed)\",\n  framework: \"express\",  // or: fastapi, nestjs, hono, elysia, trpc\n  options: { auth: true, validation: true, tests: true }\n})\n\n// Frontend with forms and data fetching\ncodedna_generate_frontend({\n  spec: \"User(email:string, name:string, role:enum(admin,user))\",\n  framework: \"react\",  // or: vue, nextjs, sveltekit, astro\n  options: { forms: true, tables: true, ui: \"shadcn\" }\n})\n\n// Single component\ncodedna_generate_component({\n  spec: \"Product(name:string, price:decimal, inStock:boolean)\",\n  type: \"form\",  // or: table, card, modal\n  framework: \"react\",\n  options: { validation: true, ui: \"shadcn\" }\n})\n```\n\n### Entity DSL Quick Reference\n\n```\nEntityName(field:type:modifier, field2:type:modifier)\n\nTypes: string, integer, decimal, boolean, datetime, text, json\nModifiers: unique, required, optional, hashed, email, min(n), max(n), default(v)\nRelations: userId:User (reference), posts:Post[] (array)\nEnums: role:enum(admin,user,guest)\n```\n\n**Token savings:** 30,000 tokens \u2192 200 tokens (99% reduction per generation)\n\n## Kappa v2.5: Declarative Full-Stack Generation\n\n**For even higher-level generation**, use Kappa DSL - a declarative specification language that generates complete applications from compact specs.\n\n### When to Use Kappa vs CodeDNA\n\n| Use Case | Tool |\n|----------|------|\n| Single entity/component | CodeDNA (`codedna_generate_*`) |\n| Full application with multiple entities | Kappa (`kappa_generate_all`) |\n| Pages, forms, routing together | Kappa |\n| Design system + components | Kappa |\n\n### Kappa Tools\n\n| Tool | Purpose |\n|------|---------|\n| `kappa_parse` | Parse and validate Kappa spec |\n| `kappa_generate_schema` | Generate Drizzle schema + Zod + types |\n| `kappa_generate_api` | Generate API routes (Hono/Express/tRPC) |\n| `kappa_generate_pages` | Generate pages (TanStack Start/Next.js) |\n| `kappa_generate_forms` | Generate forms (React Hook Form + Zod + shadcn) |\n| `kappa_generate_components` | Generate React components (compound, forwardRef) |\n| `kappa_generate_design` | Generate CSS variables + Tailwind config |\n| `kappa_generate_all` | Generate complete full-stack application |\n\n### Kappa DSL Example\n\n```\n// Complete app specification in ~50 lines\nproject TaskManager {\n  database postgres\n  framework tanstack-start\n}\n\nentity Task {\n  title string required max(100)\n  description text\n  status enum(todo, in_progress, done) default(todo)\n  dueDate datetime\n  assignee User\n}\n\nentity User {\n  email string unique email\n  name string required\n  tasks Task[]\n}\n\napi /tasks {\n  GET / -> list Task[]\n  POST / -> create Task\n  GET /:id -> get Task\n  PUT /:id -> update Task\n  DELETE /:id -> delete Task\n}\n\npage /tasks {\n  layout dashboard\n  load tasks from /api/tasks\n  components [TaskList, TaskForm]\n}\n\nform TaskForm for Task {\n  fields [title, description, status, dueDate]\n  submit POST /api/tasks\n}\n\ndesign {\n  colors {\n    primary #3B82F6\n    secondary #6B7280\n  }\n  typography {\n    fontFamily \"Inter\"\n    scale { sm: \"0.875rem\", base: \"1rem\", lg: \"1.125rem\" }\n  }\n}\n```\n\n### Usage\n\n```typescript\n// Generate everything from spec\nkappa_generate_all({\n  spec: `project MyApp { ... }`,\n  options: {\n    framework: \"tanstack-start\",\n    ui: \"shadcn\",\n    dbDialect: \"postgres\"\n  }\n})\n\n// Or generate incrementally\nkappa_parse({ spec: \"...\" })  // Validate first\nkappa_generate_schema({ spec: \"...\", outputs: [\"drizzle\", \"zod\", \"types\"] })\nkappa_generate_api({ spec: \"...\", framework: \"hono\" })\nkappa_generate_pages({ spec: \"...\", framework: \"tanstack-start\" })\n```\n\n**Token savings:** ~50 lines of Kappa \u2192 thousands of lines of production code (95%+ reduction)\n\n## Best Practices\n\n1. **Trust auto-injection** - Context is injected automatically, don't call memory_search\n2. **Store decisions** - Use `memory_store_fact` for architectural choices\n3. **Use task tracking** - Break complex work into tasks\n4. **Use Kappa for full apps** - For multi-entity apps with pages/forms, use `kappa_generate_all`\n5. **Use CodeDNA for single components** - For individual entities or components, use `codedna_generate_*`\n6. **Minimize tool calls** - Every MCP call costs context tokens\n<!-- CLAUDETOOLS:END -->\n";
+export declare const GLOBAL_TEMPLATE = "\n<!-- CLAUDETOOLS:START -->\n# ClaudeTools Memory System\n\nYou have access to a persistent memory system. **Context is AUTO-INJECTED via hooks** - you rarely need to call memory tools explicitly.\n\n## \u26A0\uFE0F IMPORTANT: Hooks vs MCP Tools\n\n**AUTOMATIC (via hooks - zero context cost):**\n- Context injection \u2192 `user-prompt-submit` hook runs on every message\n- Fact extraction \u2192 `post-tool-use` hook extracts from your work\n- Session context \u2192 `session-start` hook provides initial context\n\n**EXPLICIT (MCP tools - costs context):**\n- `memory_store_fact` \u2192 Store a specific fact you learned\n- `task_plan` / `task_start` / `task_complete` \u2192 Task management\n\n**DO NOT CALL these tools routinely (context already injected):**\n- `memory_search` - only if you need DIFFERENT search params\n- `memory_inject` - only if you need to refresh for a different query\n- `memory_get_context` - only for debugging\n- `memory_index` - only for debugging\n\n## Storing Facts (DO use this)\n```\nmemory_store_fact(\n  entity1: \"UserService\",\n  relationship: \"USES\",\n  entity2: \"bcrypt\",\n  context: \"Password hashing uses bcrypt with 12 rounds\"\n)\n```\nStore important facts when you learn something concrete. The `post-tool-use` hook also extracts facts automatically.\n\n## Task Management\n\n### Creating Work Plans with Auto-Dispatch\n```\ntask_plan(\n  goal: \"Add user authentication\",\n  epic_title: \"User Auth System\",\n  tasks: [...]\n)\n```\nBreak down complex work into tracked tasks. **Tasks are automatically set to `ready` status.**\n\nAfter `task_plan` completes, you will receive Task tool invocations to spawn parallel agents.\n**Execute ALL Task tool calls in a SINGLE message** to enable parallel execution.\n\n### Parallel Agent Workflow\n1. User describes work needed\n2. Call `task_plan_draft` to present the plan\n3. User says \"go\" to approve\n4. Call `task_plan` - tasks created in `ready` status\n5. Execute the provided Task tool calls in ONE message\n6. Agents work in parallel, each calling `task_complete` when done\n\n### Manual Task Start (Sequential)\n```\ntask_start(task_id: \"task_xxx\")\n```\nClaim a task before working on it. Use for sequential execution.\n\n### Completing Tasks\n```\ntask_complete(task_id: \"task_xxx\", summary: \"Implemented JWT auth with refresh tokens\")\n```\nMark tasks done with a summary of work completed. **Always call this when a task is finished.**\n\n## Codebase Intelligence\n\n### Start with codebase_map() - ALWAYS\n```\ncodebase_map()  # FIRST TOOL when exploring unfamiliar code\n```\n**When to use:** Starting a new task, exploring unfamiliar code, understanding project structure, finding entry points.\n\nThe map shows:\n- Project structure and key directories\n- Entry points and their exports\n- Framework detection (React, Express, etc.)\n- Key symbols and their locations\n\n**Use codebase_map BEFORE using Grep/Glob** - it gives you the lay of the land so you know where to look.\n\n### Then use targeted tools\n```\ncodebase_find(\"UserService\")  # Find specific symbols/files\ncodebase_context(\"src/auth.ts\")  # Get file dependencies\nanalyze_impact(\"validateToken\")  # See what changing a function affects\n```\n\n## Code Generation (saves 95-99% tokens)\n\n**ALWAYS use `codegen` instead of writing boilerplate.** One line of natural language \u2192 10+ production files.\n\n### Quick Reference\n\n```typescript\n// Entities \u2192 schema + types + validators + API + tests\ncodegen({ describe: \"User with email, password, role (admin/user)\" })\ncodegen({ describe: \"Post with title, content, belongs to User as author\" })\n\n// Forms \u2192 React Hook Form + Zod + shadcn inputs\ncodegen({ describe: \"Login form with email, password, submit to /auth/login\" })\n\n// Components \u2192 Radix/shadcn with variants\ncodegen({ describe: \"Button with label, onClick, variant (primary/secondary)\" })\n\n// Pages \u2192 TanStack Start or Next.js routes\ncodegen({ describe: \"Dashboard page at /dashboard, requires auth, loads User\" })\n\n// Generate specific outputs\ncodegen({ describe: \"User with email\", generate: ['schema', 'types'] })\ncodegen({ describe: \"User with email\", generate: ['tests'] })\ncodegen({ describe: \"User with email\", generate: ['all'] })  // everything\n```\n\n### What It Generates\n| Type | Output Files |\n|------|-------------|\n| Entity | schema.ts, types.ts, validators.ts, routes.ts |\n| Tests | *.test.ts, *.factory.ts, *.mock.ts |\n| Form | *-form.tsx (RHF + Zod + shadcn) |\n| Component | *.tsx (Radix primitives + Tailwind) |\n| Page | route.tsx (loaders, guards, layouts) |\n\n### Smart Inference\n- Field names \u2192 types: `email` \u2192 email, `password` \u2192 hashed, `price` \u2192 decimal\n- Enums: `role (admin/user)` \u2192 enum type\n- Relationships: `belongs to User as author` \u2192 foreign key + relation\n- Forms: `email` \u2192 email input, `message` \u2192 textarea\n- Pages: `requires auth` \u2192 guard, `loads User` \u2192 data loader\n\n## Best Practices\n\n1. **Trust auto-injection** - Context is injected automatically, don't call memory_search\n2. **Store decisions** - Use `memory_store_fact` for architectural choices\n3. **Use task tracking** - Break complex work into tasks\n4. **Use codegen for boilerplate** - Generate schemas, types, validators, routes\n5. **Minimize tool calls** - Every MCP call costs context tokens\n<!-- CLAUDETOOLS:END -->\n";
 /**
  * Project-level CLAUDE.md content - added to .claude/CLAUDE.md
  */

package/dist/templates/claude-md.js

@@ -102,169 +102,55 @@ codebase_context("src/auth.ts")  # Get file dependencies
 analyze_impact("validateToken")  # See what changing a function affects
 \`\`\`
 
-## CodeDNA: Generate Code, Save 99% Tokens
+## Code Generation (saves 95-99% tokens)
 
-**BEFORE writing ANY code, check if CodeDNA can generate it.** Call \`codedna_list_generators()\` to see available generators.
+**ALWAYS use \`codegen\` instead of writing boilerplate.** One line of natural language → 10+ production files.
 
-### Available Generators (20+)
-
-| Category | Frameworks | Tool |
-|----------|------------|------|
-| **API** | Express, FastAPI, NestJS, Hono, Elysia, tRPC | \`codedna_generate_api\` |
-| **Frontend** | React, Vue, SvelteKit, Astro, React Router v7, TanStack Start | \`codedna_generate_frontend\` |
-| **ORM** | Prisma, Drizzle | \`codedna_generate_api\` with database option |
-| **Auth** | Better Auth, Auth.js, Lucia | \`codedna_generate_api\` with auth option |
-| **Components** | Forms, Tables, Cards, Modals (React/Vue/Svelte) | \`codedna_generate_component\` |
-
-### Usage Examples
+### Quick Reference
 
 \`\`\`typescript
-// API with auth and validation
-codedna_generate_api({
-  spec: "User(email:string:unique, password:string:hashed)",
-  framework: "express",  // or: fastapi, nestjs, hono, elysia, trpc
-  options: { auth: true, validation: true, tests: true }
-})
-
-// Frontend with forms and data fetching
-codedna_generate_frontend({
-  spec: "User(email:string, name:string, role:enum(admin,user))",
-  framework: "react",  // or: vue, nextjs, sveltekit, astro
-  options: { forms: true, tables: true, ui: "shadcn" }
-})
-
-// Single component
-codedna_generate_component({
-  spec: "Product(name:string, price:decimal, inStock:boolean)",
-  type: "form",  // or: table, card, modal
-  framework: "react",
-  options: { validation: true, ui: "shadcn" }
-})
-\`\`\`
-
-### Entity DSL Quick Reference
-
-\`\`\`
-EntityName(field:type:modifier, field2:type:modifier)
-
-Types: string, integer, decimal, boolean, datetime, text, json
-Modifiers: unique, required, optional, hashed, email, min(n), max(n), default(v)
-Relations: userId:User (reference), posts:Post[] (array)
-Enums: role:enum(admin,user,guest)
-\`\`\`
-
-**Token savings:** 30,000 tokens → 200 tokens (99% reduction per generation)
-
-## Kappa v2.5: Declarative Full-Stack Generation
-
-**For even higher-level generation**, use Kappa DSL - a declarative specification language that generates complete applications from compact specs.
-
-### When to Use Kappa vs CodeDNA
-
-| Use Case | Tool |
-|----------|------|
-| Single entity/component | CodeDNA (\`codedna_generate_*\`) |
-| Full application with multiple entities | Kappa (\`kappa_generate_all\`) |
-| Pages, forms, routing together | Kappa |
-| Design system + components | Kappa |
-
-### Kappa Tools
-
-| Tool | Purpose |
-|------|---------|
-| \`kappa_parse\` | Parse and validate Kappa spec |
-| \`kappa_generate_schema\` | Generate Drizzle schema + Zod + types |
-| \`kappa_generate_api\` | Generate API routes (Hono/Express/tRPC) |
-| \`kappa_generate_pages\` | Generate pages (TanStack Start/Next.js) |
-| \`kappa_generate_forms\` | Generate forms (React Hook Form + Zod + shadcn) |
-| \`kappa_generate_components\` | Generate React components (compound, forwardRef) |
-| \`kappa_generate_design\` | Generate CSS variables + Tailwind config |
-| \`kappa_generate_all\` | Generate complete full-stack application |
-
-### Kappa DSL Example
+// Entities → schema + types + validators + API + tests
+codegen({ describe: "User with email, password, role (admin/user)" })
+codegen({ describe: "Post with title, content, belongs to User as author" })
 
-\`\`\`
-// Complete app specification in ~50 lines
-project TaskManager {
-  database postgres
-  framework tanstack-start
-}
-
-entity Task {
-  title string required max(100)
-  description text
-  status enum(todo, in_progress, done) default(todo)
-  dueDate datetime
-  assignee User
-}
-
-entity User {
-  email string unique email
-  name string required
-  tasks Task[]
-}
-
-api /tasks {
-  GET / -> list Task[]
-  POST / -> create Task
-  GET /:id -> get Task
-  PUT /:id -> update Task
-  DELETE /:id -> delete Task
-}
+// Forms → React Hook Form + Zod + shadcn inputs
+codegen({ describe: "Login form with email, password, submit to /auth/login" })
 
-page /tasks {
-  layout dashboard
-  load tasks from /api/tasks
-  components [TaskList, TaskForm]
-}
+// Components → Radix/shadcn with variants
+codegen({ describe: "Button with label, onClick, variant (primary/secondary)" })
 
-form TaskForm for Task {
-  fields [title, description, status, dueDate]
-  submit POST /api/tasks
-}
+// Pages → TanStack Start or Next.js routes
+codegen({ describe: "Dashboard page at /dashboard, requires auth, loads User" })
 
-design {
-  colors {
-    primary #3B82F6
-    secondary #6B7280
-  }
-  typography {
-    fontFamily "Inter"
-    scale { sm: "0.875rem", base: "1rem", lg: "1.125rem" }
-  }
-}
+// Generate specific outputs
+codegen({ describe: "User with email", generate: ['schema', 'types'] })
+codegen({ describe: "User with email", generate: ['tests'] })
+codegen({ describe: "User with email", generate: ['all'] })  // everything
 \`\`\`
 
-### Usage
-
-\`\`\`typescript
-// Generate everything from spec
-kappa_generate_all({
-  spec: \`project MyApp { ... }\`,
-  options: {
-    framework: "tanstack-start",
-    ui: "shadcn",
-    dbDialect: "postgres"
-  }
-})
-
-// Or generate incrementally
-kappa_parse({ spec: "..." })  // Validate first
-kappa_generate_schema({ spec: "...", outputs: ["drizzle", "zod", "types"] })
-kappa_generate_api({ spec: "...", framework: "hono" })
-kappa_generate_pages({ spec: "...", framework: "tanstack-start" })
-\`\`\`
+### What It Generates
+| Type | Output Files |
+|------|-------------|
+| Entity | schema.ts, types.ts, validators.ts, routes.ts |
+| Tests | *.test.ts, *.factory.ts, *.mock.ts |
+| Form | *-form.tsx (RHF + Zod + shadcn) |
+| Component | *.tsx (Radix primitives + Tailwind) |
+| Page | route.tsx (loaders, guards, layouts) |
 
-**Token savings:** ~50 lines of Kappa → thousands of lines of production code (95%+ reduction)
+### Smart Inference
+- Field names → types: \`email\` → email, \`password\` → hashed, \`price\` → decimal
+- Enums: \`role (admin/user)\` → enum type
+- Relationships: \`belongs to User as author\` → foreign key + relation
+- Forms: \`email\` → email input, \`message\` → textarea
+- Pages: \`requires auth\` → guard, \`loads User\` → data loader
 
 ## Best Practices
 
 1. **Trust auto-injection** - Context is injected automatically, don't call memory_search
 2. **Store decisions** - Use \`memory_store_fact\` for architectural choices
 3. **Use task tracking** - Break complex work into tasks
-4. **Use Kappa for full apps** - For multi-entity apps with pages/forms, use \`kappa_generate_all\`
-5. **Use CodeDNA for single components** - For individual entities or components, use \`codedna_generate_*\`
-6. **Minimize tool calls** - Every MCP call costs context tokens
+4. **Use codegen for boilerplate** - Generate schemas, types, validators, routes
+5. **Minimize tool calls** - Every MCP call costs context tokens
 ${SECTION_END}
 `;
 /**
@@ -297,12 +183,11 @@ task_start({ task_id: "task_xxx" })
 task_complete({ task_id: "task_xxx", summary: "What was done" })
 \`\`\`
 
-## CodeDNA (saves 95-99% tokens)
-\`\`\`
-codedna_list_generators()  // See all available generators
-codedna_generate_api("User(email:string:unique, password:string)", "express")
-codedna_generate_frontend("User(email:string, name:string)", "react")
-codedna_generate_component("Product(name:string, price:decimal)", "form", "react")
+## Code Generation (95-99% token savings)
+\`\`\`typescript
+codegen({ describe: "User with email, password, role (admin/user)" })  // → schema + types + API + tests
+codegen({ describe: "Login form with email, password" })               // → RHF + Zod form
+codegen({ describe: "Dashboard page at /dashboard, requires auth" })   // → TanStack/Next route
 \`\`\`
 ${SECTION_END}
 `;

package/dist/templates/orchestrator-prompt.d.ts

@@ -18,9 +18,9 @@ export declare function buildOrchestratorPrompt(params: {
     availableWorkers?: string[];
 }): string;
 /**
- * Get CodeDNA usage hint for task descriptions
+ * Get codegen usage hint for task descriptions
  */
-export declare function getCodeDNAHint(entitySpec: string): string;
+export declare function getCodegenHint(entityDescription: string): string;
 /**
  * Validate task description doesn't contain code
  */