@claudetools/tools 0.9.0 → 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

@@ -21,6 +21,7 @@ const MCP_CONFIG_PATH = join(CLAUDE_DIR, 'mcp.json');
 const CLAUDE_DESKTOP_CONFIG_PATH = join(CLAUDE_DIR, 'claude_desktop_config.json');
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
 const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const COMMANDS_DIR = join(CLAUDE_DIR, 'commands');
 const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md');
 const SYSTEM_FILE = join(CLAUDETOOLS_DIR, 'system.json');
 const PROJECTS_FILE = join(CLAUDETOOLS_DIR, 'projects.json');
@@ -920,6 +921,197 @@ exit 0
     writeFileSync(preCompactPath, preCompactHook, { mode: 0o755 });
     success('Installed pre-compact.sh hook');
 }
+// -----------------------------------------------------------------------------
+// Slash Commands Installation
+// -----------------------------------------------------------------------------
+const PROJECT_INIT_COMMAND = `---
+description: Initialize a new project with AI-driven onboarding
+model: claude-sonnet-4-5
+---
+
+# Project Onboarding
+
+Starting interactive onboarding for this project...
+
+## Instructions for Claude
+
+You are beginning an onboarding session for a new or existing project. Your goal is to:
+1. Gather project context through conversational questioning
+2. **Store ALL learned facts in the memory system immediately** (don't batch - store as you learn)
+3. **Cache documentation for libraries/frameworks mentioned** (using \`docs_cache\`)
+4. **Verify ClaudeTools integration is working correctly**
+
+### Phase 1: ClaudeTools Verification
+
+Before starting onboarding, verify the tooling is correctly set up:
+
+\`\`\`bash
+# Check session facts cache exists
+ls -la ~/.claudetools/session-facts.json
+
+# Check hooks are in place
+ls -la ~/.claude/hooks/
+
+# Verify MCP connection
+# (If memory_search works, MCP is connected)
+\`\`\`
+
+If any issues found, help the user fix their ClaudeTools setup before proceeding.
+
+### Phase 2: Onboarding Workflow
+
+**1. Check if project exists**
+- Use \`memory_search\` to check for existing project context
+- If exists, offer to update/extend vs start fresh
+
+**2. Start onboarding conversation**
+Ask about (store facts AS you learn them, not at the end):
+
+- **Project Type**: What kind of project? (web app, API, library, CLI, etc.)
+  → Store: \`[ProjectName] IS_TYPE [ProjectType]\`
+
+- **Tech Stack**: What technologies/frameworks?
+  → Store: \`[ProjectName] USES [Technology]\` for EACH technology
+  → **IMPORTANT**: Call \`docs_cache({ library: "technology-name" })\` for each library mentioned
+
+- **Architecture**: Key patterns, structure, decisions?
+  → Store: \`[ProjectName] USES_PATTERN [Pattern]\`
+  → Store: \`[Component] IMPLEMENTS [Pattern]\`
+
+- **Constraints**: Performance requirements, limitations, must-haves?
+  → Store: \`[ProjectName] HAS_CONSTRAINT [Constraint]\`
+
+- **External Integrations**: APIs, services, databases?
+  → Store: \`[ProjectName] INTEGRATES_WITH [Service]\`
+  → Call \`docs_cache\` if documentation available
+
+- **Development Practices**: Testing, CI/CD, code style?
+  → Store: \`[ProjectName] FOLLOWS [Practice]\`
+
+**3. Research when needed**
+If user mentions:
+- Existing specs/docs → Read and extract facts
+- External libraries → Cache docs with \`docs_cache({ library: "name" })\`
+- Existing code → Analyse patterns and store architectural decisions
+
+**4. Complete onboarding**
+- Summarise what was learned
+- Confirm with user before finalising
+- List all cached documentation
+
+### Memory Storage (CRITICAL)
+
+**Store facts IMMEDIATELY as you learn them, not at the end.**
+
+\`\`\`typescript
+// After learning tech stack
+memory_store_fact({
+  entity1: "MyProject",
+  relationship: "USES",
+  entity2: "React",
+  context: "Frontend framework chosen for component-based architecture"
+})
+
+// Immediately cache React docs
+docs_cache({ library: "react" })
+\`\`\`
+
+**Fact relationship types:**
+- \`IS_TYPE\` - Project classification
+- \`USES\` - Technologies, libraries, frameworks
+- \`USES_PATTERN\` - Architectural patterns
+- \`HAS_CONSTRAINT\` - Requirements, limitations
+- \`INTEGRATES_WITH\` - External services
+- \`FOLLOWS\` - Development practices
+- \`DEPENDS_ON\` - Critical dependencies
+- \`OWNED_BY\` - Team/ownership info
+
+### Documentation Caching
+
+For ANY library/framework mentioned, cache its docs:
+
+\`\`\`typescript
+// Cache documentation for mentioned technologies
+docs_cache({ library: "next.js" })
+docs_cache({ library: "prisma" })
+docs_cache({ library: "zod" })
+docs_cache({ library: "tanstack-query" })
+\`\`\`
+
+This enables future sessions to reference up-to-date documentation.
+
+### Code Generation
+
+**IMPORTANT**: When the project involves APIs or data models, use the \`codegen\` tool to save 95%+ tokens:
+
+\`\`\`typescript
+codegen({ describe: "User with email, password, role (admin/user)" })
+\`\`\`
+
+**What it generates:**
+- Drizzle schema (database tables)
+- TypeScript types
+- Zod validators
+- API routes (Hono/Express)
+
+**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: "USES",
+  entity2: "codegen",
+  context: "Project uses codegen for schema/types/validators generation"
+})
+\`\`\`
+
+### Conversation Style
+
+- Be conversational, not interrogative
+- Explain WHY you're asking each question
+- Store facts immediately after each answer (don't wait)
+- Confirm what you've stored: "I've noted that you're using React for..."
+- Offer to skip questions if not relevant
+- Summarise understanding periodically
+
+### Troubleshooting ClaudeTools
+
+If MCP tools aren't available:
+1. Check \`~/.claudetools/config.json\` exists
+2. Verify Claude Code has MCP server configured
+3. Run \`/doctor\` command if available
+
+If hooks aren't triggering:
+1. Check \`~/.claude/hooks/\` directory
+2. Verify hook files are executable
+3. Check hook logs in \`/tmp/claude-*.log\`
+
+### User Request (if provided):
+
+$ARGUMENTS
+`;
+async function installSlashCommands() {
+    header('Slash Commands');
+    // Create commands/project directory
+    const projectCommandsDir = join(COMMANDS_DIR, 'project');
+    if (!existsSync(projectCommandsDir)) {
+        mkdirSync(projectCommandsDir, { recursive: true });
+    }
+    // Install project:init command
+    const initPath = join(projectCommandsDir, 'init.md');
+    if (existsSync(initPath)) {
+        const backup = backupFile(initPath);
+        if (backup)
+            info(`Backed up existing command to ${basename(backup)}`);
+    }
+    writeFileSync(initPath, PROJECT_INIT_COMMAND);
+    success('Installed /project:init slash command');
+}
 async function configureSettings() {
     header('Claude Code Settings');
     // Read existing settings
@@ -1244,11 +1436,13 @@ export async function runSetup() {
         await configureMcpSettings(services);
         // Step 8: Install Hooks
         await installHooks();
-        // Step 9: Configure Settings
+        // Step 9: Install Slash Commands
+        await installSlashCommands();
+        // Step 10: Configure Settings
         await configureSettings();
-        // Step 10: Configure CLAUDE.md
+        // Step 11: Configure CLAUDE.md
         await configureCLAUDEMD();
-        // Step 11: Verify
+        // Step 12: Verify
         await verifySetup(extendedConfig);
         // Done
         header('Setup Complete');
@@ -1841,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
  */