@claudetools/tools 0.9.0 → 0.9.2

package/dist/handlers/tool-handlers.js

@@ -12,11 +12,10 @@ import { queryDependencies, analyzeImpact } from '../helpers/dependencies.js';
 import { checkPatterns } from '../helpers/patterns.js';
 import { formatContextForClaude } from '../helpers/formatter.js';
 import { shortId, compactTaskList, compactTaskCreated, compactTaskStart, compactTaskComplete, compactTaskClaim, compactTaskRelease, compactStatusUpdate, compactContextAdded, compactHeartbeat, compactTaskHandoff, compactSummary, } from '../helpers/compact-formatter.js';
-import { createTask, listTasks, getTask, claimTask, releaseTask, updateTaskStatus, addTaskContext, getTaskSummary, heartbeatTask, handoffTask, parseJsonArray, getDispatchableTasks, getExecutionContext, resolveTaskDependencies, getEpicStatus, getEpicAggregate, getActiveTaskCount, reviseEpic, } from '../helpers/tasks.js';
+import { createTask, listTasks, getTask, claimTask, releaseTask, updateTaskStatus, addTaskContext, getTaskSummary, heartbeatTask, handoffTask, parseJsonArray, getDispatchableTasks, getExecutionContext, resolveTaskDependencies, getEpicStatus, getEpicAggregate, getActiveTaskCount, reviseEpic, checkWorkflowCompliance, } from '../helpers/tasks.js';
 import { detectTimedOutTasks, retryTask, failTask, autoRetryTimedOutTasks, } from '../helpers/tasks-retry.js';
 import { detectLibrariesFromPlan } from '../helpers/library-detection.js';
-import { handleGenerateApi, handleGenerateFrontend, handleGenerateComponent, handleListGenerators, handleValidateSpec, handleListPatterns, handleGetPattern, handleDetectPatterns, handleInitProject, } from './codedna-handlers.js';
-import { handleKappaParse, handleKappaGenerateSchema, handleKappaGenerateApi, handleKappaGeneratePages, handleKappaGenerateForms, handleKappaGenerateComponents, handleKappaGenerateDesign, handleKappaGenerateAll, } from './kappa-handlers.js';
+import { cloudCodegen, CloudCodegenClient } from '../codegen/cloud-client.js';
 export function registerToolHandlers(server) {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
@@ -769,7 +768,7 @@ export function registerToolHandlers(server) {
                             }
                         }
                         output += `\n**Tip:** For entities, use DSL format: "User(email:string:unique, password:string:hashed)"\n`;
-                        output += `Workers will use CodeDNA to generate code automatically.\n`;
+                        output += `Workers will use codegen to generate code automatically.\n`;
                     }
                     // Auto-dispatch section with exact Task tool invocations
                     output += `\n---\n\n`;
@@ -777,7 +776,7 @@ export function registerToolHandlers(server) {
                     output += `**IMPORTANT:** Execute these Task tool calls in a SINGLE message to spawn parallel workers:\n\n`;
                     output += `\`\`\`\n`;
                     for (const dt of dispatchable) {
-                        // Build a comprehensive prompt using 10/10 template with CodeDNA instructions
+                        // Build a comprehensive prompt using 10/10 template with codegen instructions
                         const workerPrompt = buildWorkerPrompt({
                             task: {
                                 id: dt.task.id,
@@ -800,8 +799,8 @@ export function registerToolHandlers(server) {
                             ``,
                             dt.task.description || '',
                             ``,
-                            `## CodeDNA Priority`,
-                            `If this task involves CRUD/API operations, use codedna_generate_api FIRST.`,
+                            `## Codegen Priority`,
+                            `If this task involves CRUD/API operations, use codegen FIRST.`,
                             `Look for Entity DSL in description (e.g., "User(email:string:unique)").`,
                             ``,
                             `## Protocol`,
@@ -913,6 +912,9 @@ export function registerToolHandlers(server) {
                     const taskId = args?.task_id;
                     const summary = args?.summary;
                     const agentId = args?.agent_id || 'claude-code';
+                    const verification = args?.verification;
+                    // Check workflow compliance BEFORE claiming (to detect if task_start was skipped)
+                    const workflowViolations = await checkWorkflowCompliance(DEFAULT_USER_ID, projectId, agentId, { isCompletingTask: true, taskId });
                     // Try to claim first in case task wasn't started via task_start
                     // This makes task_complete work standalone without requiring task_start
                     try {
@@ -922,16 +924,26 @@ export function registerToolHandlers(server) {
                         // Ignore claim errors - task might already be claimed by this agent or another
                         // releaseTask will handle the actual authorization check
                     }
-                    // Add completion context
-                    await addTaskContext(DEFAULT_USER_ID, projectId, taskId, 'work_log', summary, agentId);
+                    // Add completion context (include verification if provided)
+                    const contextSummary = verification
+                        ? `${summary}\n\nVerification: ${JSON.stringify(verification)}`
+                        : summary;
+                    await addTaskContext(DEFAULT_USER_ID, projectId, taskId, 'work_log', contextSummary, agentId);
                     // Release and mark as done
                     const releaseResult = await releaseTask(DEFAULT_USER_ID, projectId, taskId, agentId, 'done', summary);
                     const task = releaseResult.data.task;
                     // Check for newly unblocked tasks (orchestration awareness)
                     const newlyUnblocked = await resolveTaskDependencies(DEFAULT_USER_ID, projectId, taskId, task.parent_id || undefined);
                     mcpLogger.toolResult(name, true, timer());
-                    // Compact output
-                    const output = compactTaskComplete(task, summary, newlyUnblocked);
+                    // Compact output with verification status
+                    let output = compactTaskComplete(task, summary, newlyUnblocked, verification);
+                    // Append workflow warnings if any violations detected
+                    if (workflowViolations.length > 0) {
+                        output += '\n\n📋 **Workflow Notes:**';
+                        for (const v of workflowViolations) {
+                            output += `\n${v.message}`;
+                        }
+                    }
                     return {
                         content: [{ type: 'text', text: output }],
                     };
@@ -1883,223 +1895,114 @@ export function registerToolHandlers(server) {
                     };
                 }
                 // =========================================================================
-                // CODEDNA CODE GENERATION HANDLERS
+                // CODEGEN TOOL (Cloud-Only)
                 // =========================================================================
-                case 'codedna_generate_api': {
-                    const result = await handleGenerateApi(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'codedna_generate_frontend': {
-                    const result = await handleGenerateFrontend(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'codedna_generate_component': {
-                    const result = await handleGenerateComponent(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'codedna_list_generators': {
-                    const result = await handleListGenerators(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                case 'codedna_validate_spec': {
-                    const result = await handleValidateSpec(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                // =====================================================================
-                // CodeDNA Pattern Library Tools
-                // =====================================================================
-                case 'codedna_list_patterns': {
-                    const result = await handleListPatterns(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                case 'codedna_get_pattern': {
-                    const result = await handleGetPattern(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                case 'codedna_detect_patterns': {
-                    const result = await handleDetectPatterns(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                case 'codedna_init_project': {
-                    const result = await handleInitProject(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                // =====================================================================
-                // Kappa v2.5 DSL Tools
-                // =====================================================================
-                case 'kappa_parse': {
-                    const result = await handleKappaParse(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(result, null, 2),
-                            }],
-                    };
-                }
-                case 'kappa_generate_schema': {
-                    const result = await handleKappaGenerateSchema(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'kappa_generate_api': {
-                    const result = await handleKappaGenerateApi(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'kappa_generate_pages': {
-                    const result = await handleKappaGeneratePages(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
+                case 'codegen': {
+                    const describe = args?.describe;
+                    const stack = args?.stack;
+                    const generate = args?.generate;
+                    if (!describe) {
+                        return {
+                            content: [{ type: 'text', text: '❌ Missing required parameter: describe' }],
+                            isError: true,
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'kappa_generate_forms': {
-                    const result = await handleKappaGenerateForms(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
+                    try {
+                        const result = await cloudCodegen({
+                            describe,
+                            stack,
+                            generate,
+                        });
+                        mcpLogger.toolResult(name, result.success, timer(), result.summary);
+                        if (!result.success) {
+                            let errorOutput = `❌ Code generation failed\n\n`;
+                            errorOutput += `**Error:** ${result.summary}\n`;
+                            if (result.errors && result.errors.length > 0) {
+                                errorOutput += `\n**Details:**\n`;
+                                result.errors.forEach((e) => {
+                                    errorOutput += `- ${e}\n`;
+                                });
+                            }
+                            errorOutput += `\n**Tip:** Describe entities naturally, e.g., "User with email, password, role (admin/user)"`;
+                            return {
+                                content: [{ type: 'text', text: errorOutput }],
+                                isError: true,
+                            };
+                        }
+                        // Format successful output
+                        let output = `# ✓ Generated ${result.files?.length || 0} files\n\n`;
+                        output += `**Entities:** ${result.entities?.join(', ')}\n`;
+                        if (result.generators && result.generators.length > 0) {
+                            output += `**Generators:** ${result.generators.map(g => g.name).join(', ')}\n`;
+                        }
+                        if (result.generationTimeMs) {
+                            output += `**Generation Time:** ${result.generationTimeMs}ms\n`;
+                        }
+                        output += `\n## Files\n\n`;
+                        for (const file of result.files || []) {
+                            output += `### ${file.path}\n`;
+                            output += `${file.description}\n\n`;
+                            const ext = file.path.split('.').pop() || 'typescript';
+                            output += `\`\`\`${ext}\n${file.content}\n\`\`\`\n\n`;
+                        }
+                        if (workflowWarnings) {
+                            output += '\n\n' + workflowWarnings;
+                        }
+                        return {
+                            content: [{ type: 'text', text: output }],
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'kappa_generate_components': {
-                    const result = await handleKappaGenerateComponents(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
+                    catch (error) {
+                        mcpLogger.toolResult(name, false, timer(), String(error));
+                        return {
+                            content: [{ type: 'text', text: `❌ API error: ${error instanceof Error ? error.message : String(error)}` }],
+                            isError: true,
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
                 }
-                case 'kappa_generate_design': {
-                    const result = await handleKappaGenerateDesign(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
+                case 'codegen_list': {
+                    const category = args?.category;
+                    const framework = args?.framework;
+                    try {
+                        const client = new CloudCodegenClient();
+                        const generators = await client.listGenerators({ category, framework });
+                        mcpLogger.toolResult(name, true, timer(), `${generators.length} generators`);
+                        let output = `# Available Generators`;
+                        if (category)
+                            output += ` (${category})`;
+                        if (framework)
+                            output += ` [${framework}]`;
+                        output += `\n\n`;
+                        output += `Found **${generators.length}** published generators:\n\n`;
+                        // Group by category
+                        const byCategory = new Map();
+                        for (const gen of generators) {
+                            const cat = gen.categoryName || gen.category;
+                            if (!byCategory.has(cat)) {
+                                byCategory.set(cat, []);
+                            }
+                            byCategory.get(cat).push(gen);
+                        }
+                        for (const [cat, gens] of byCategory) {
+                            output += `## ${cat}\n\n`;
+                            output += `| Generator | Quality | Uses | Description |\n`;
+                            output += `|-----------|---------|------|-------------|\n`;
+                            for (const gen of gens) {
+                                output += `| ${gen.name} | ${gen.qualityScore}% | ${gen.usageCount} | ${gen.description.slice(0, 50)}${gen.description.length > 50 ? '...' : ''} |\n`;
+                            }
+                            output += `\n`;
+                        }
+                        return {
+                            content: [{ type: 'text', text: output }],
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
-                }
-                case 'kappa_generate_all': {
-                    const result = await handleKappaGenerateAll(args);
-                    mcpLogger.toolResult(name, true, timer());
-                    let output = JSON.stringify(result, null, 2);
-                    if (workflowWarnings) {
-                        output += '\n\n' + workflowWarnings;
+                    catch (error) {
+                        mcpLogger.toolResult(name, false, timer(), String(error));
+                        return {
+                            content: [{ type: 'text', text: `❌ Failed to list generators: ${error instanceof Error ? error.message : String(error)}` }],
+                            isError: true,
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: output,
-                            }],
-                    };
                 }
                 default:
                     throw new Error(`Unknown tool: ${name}`);

package/dist/helpers/api-client.js

@@ -22,7 +22,21 @@ export async function apiRequest(endpoint, method = 'GET', body) {
     }
     const response = await fetch(url, options);
     if (!response.ok) {
-        throw new Error(`API error: ${response.status} ${response.statusText}`);
+        // Try to extract error message from response body
+        let errorMessage = `${response.status} ${response.statusText}`;
+        try {
+            const errorBody = await response.json();
+            if (errorBody.error) {
+                errorMessage = errorBody.error;
+            }
+            else if (errorBody.message) {
+                errorMessage = errorBody.message;
+            }
+        }
+        catch {
+            // Response body wasn't JSON, use status text
+        }
+        throw new Error(`API error: ${errorMessage}`);
     }
     return response.json();
 }
@@ -54,11 +68,42 @@ export async function getContext(projectId, query, userId = DEFAULT_USER_ID) {
     return apiRequest(`/api/v1/memory/${userId}/${projectId}/context${params}`);
 }
 export async function getSummary(projectId, userId = DEFAULT_USER_ID) {
-    const response = await fetch(`${API_BASE_URL}/api/v1/memory/${userId}/${projectId}/summary`);
+    // Use same auth pattern as apiRequest for consistency
+    const config = getConfig();
+    const apiKey = config.apiKey || process.env.CLAUDETOOLS_API_KEY || process.env.MEMORY_API_KEY;
+    if (!apiKey) {
+        throw new Error('No API key found. Set CLAUDETOOLS_API_KEY or MEMORY_API_KEY in environment or ~/.claudetools/config.json');
+    }
+    const url = `${API_BASE_URL}/api/v1/memory/${userId}/${projectId}/summary`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        let errorMessage = `${response.status} ${response.statusText}`;
+        try {
+            const errorBody = await response.json();
+            if (errorBody.error) {
+                errorMessage = errorBody.error;
+            }
+            else if (errorBody.message) {
+                errorMessage = errorBody.message;
+            }
+        }
+        catch {
+            // Response body wasn't JSON, use status text
+        }
+        throw new Error(`API error: ${errorMessage}`);
+    }
+    // Server returns plain text summary
     return response.text();
 }
 export async function getEntities(projectId, userId = DEFAULT_USER_ID) {
-    return apiRequest(`/api/v1/memory/${userId}/${projectId}/entities`);
+    const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/entities`);
+    return response.data || [];
 }
 export async function injectContext(projectId, query, userId = DEFAULT_USER_ID) {
     const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/inject`, 'POST', {

package/dist/helpers/compact-formatter.d.ts

@@ -1,4 +1,11 @@
 import type { Task, TaskContext } from './tasks.js';
+/** Verification evidence for completed tasks */
+export interface TaskVerification {
+    tests_passed?: boolean;
+    type_check_passed?: boolean;
+    manually_verified?: boolean;
+    evidence?: string;
+}
 /** Truncate task ID to first 8 chars */
 export declare function shortId(id: string): string;
 /** Format task status with icon */
@@ -11,8 +18,8 @@ export declare function compactTaskList(tasks: Task[]): string;
 export declare function compactTaskCreated(task: Task): string;
 /** Compact task start result */
 export declare function compactTaskStart(task: Task, lockExpires: string): string;
-/** Compact task complete result */
-export declare function compactTaskComplete(task: Task, summary: string, unblocked?: Task[]): string;
+/** Compact task complete result with verification status */
+export declare function compactTaskComplete(task: Task, summary: string, unblocked?: Task[], verification?: TaskVerification): string;
 /** Compact task claim result */
 export declare function compactTaskClaim(task: Task, claimed: boolean, expires: string): string;
 /** Compact task release result */

package/dist/helpers/compact-formatter.js

@@ -38,9 +38,33 @@ export function compactTaskCreated(task) {
 export function compactTaskStart(task, lockExpires) {
     return `Started: ${task.title} (${shortId(task.id)}) lock until ${new Date(lockExpires).toLocaleTimeString()}`;
 }
-/** Compact task complete result */
-export function compactTaskComplete(task, summary, unblocked) {
+/** Compact task complete result with verification status */
+export function compactTaskComplete(task, summary, unblocked, verification) {
     let result = `✅ ${task.title} → done`;
+    // Add verification status if provided
+    if (verification) {
+        const checks = [];
+        if (verification.tests_passed === true)
+            checks.push('✓tests');
+        else if (verification.tests_passed === false)
+            checks.push('✗tests');
+        if (verification.type_check_passed === true)
+            checks.push('✓types');
+        else if (verification.type_check_passed === false)
+            checks.push('✗types');
+        if (verification.manually_verified === true)
+            checks.push('✓manual');
+        if (checks.length > 0) {
+            result += ` [${checks.join(' ')}]`;
+        }
+        if (verification.evidence) {
+            result += `\n📋 ${verification.evidence}`;
+        }
+    }
+    else {
+        // Warn if no verification provided (encourages best practice)
+        result += ' [⚠️ no verification]';
+    }
     if (unblocked && unblocked.length > 0) {
         result += `\n🔓 Unblocked: ${unblocked.map(t => t.title).join(', ')}`;
     }

package/dist/helpers/config.d.ts

@@ -34,8 +34,13 @@ export declare function resolveProjectId(): string;
 export declare function resolveProjectIdAsync(): Promise<string>;
 /**
  * Gets the default project ID (synchronous version)
- * ALWAYS checks session-context.md first (even if cached), then config, then falls back to cwd resolution
- * This handles race conditions where MCP server starts before session-start hook writes the file
+ *
+ * CRITICAL: Uses "lock on first read" strategy to prevent multi-session conflicts:
+ * - First call: reads session-context.md (or config/cwd) and LOCKS the value
+ * - Subsequent calls: returns the locked value, ignoring session-context.md changes
+ *
+ * This ensures each MCP server process uses the project ID from when it started,
+ * even if other Claude Code sessions overwrite the shared session-context.md file.
  */
 export declare function getDefaultProjectId(): string;
 /**

package/dist/helpers/config.js

@@ -164,26 +164,38 @@ export async function resolveProjectIdAsync() {
         `  3. Or manually register via API`);
 }
 // Lazy-loaded DEFAULT_PROJECT_ID to avoid startup errors
+// IMPORTANT: Once set, this is LOCKED for the lifetime of this MCP server process
+// This prevents multi-session conflicts where different Claude Code sessions
+// overwrite the shared session-context.md file
 let _defaultProjectId = null;
+let _projectIdLocked = false; // Tracks if we've completed initial resolution
 /**
  * Gets the default project ID (synchronous version)
- * ALWAYS checks session-context.md first (even if cached), then config, then falls back to cwd resolution
- * This handles race conditions where MCP server starts before session-start hook writes the file
+ *
+ * CRITICAL: Uses "lock on first read" strategy to prevent multi-session conflicts:
+ * - First call: reads session-context.md (or config/cwd) and LOCKS the value
+ * - Subsequent calls: returns the locked value, ignoring session-context.md changes
+ *
+ * This ensures each MCP server process uses the project ID from when it started,
+ * even if other Claude Code sessions overwrite the shared session-context.md file.
  */
 export function getDefaultProjectId() {
-    // ALWAYS check session-context.md first - it may have been written after we cached a fallback value
-    // This handles the race condition where MCP server starts before Claude Code's session-start hook runs
+    // If already locked, return cached value immediately
+    // This prevents other sessions from hijacking this MCP server's project context
+    if (_projectIdLocked && _defaultProjectId) {
+        return _defaultProjectId;
+    }
+    // First-time resolution: check session-context.md
     const sessionProjectId = getProjectIdFromSessionContext();
     if (sessionProjectId) {
-        // Update cache if different (session-context.md is authoritative)
-        if (_defaultProjectId !== sessionProjectId) {
-            mcpLogger.debug('MEMORY', `Updating project ID from session-context: ${sessionProjectId} (was: ${_defaultProjectId})`);
-            _defaultProjectId = sessionProjectId;
-        }
+        _defaultProjectId = sessionProjectId;
+        _projectIdLocked = true;
+        mcpLogger.info('MEMORY', `Project ID locked from session-context: ${sessionProjectId}`);
         return _defaultProjectId;
     }
-    // If we have a cached value and no session-context.md, use cache
+    // If we have a cached value but not locked, lock it now
     if (_defaultProjectId) {
+        _projectIdLocked = true;
         return _defaultProjectId;
     }
     // Try config second
@@ -192,15 +204,18 @@ export function getDefaultProjectId() {
             // Legacy format - convert to local_ format instead of throwing
             const sanitized = config.defaultProjectId.toLowerCase().replace(/[^a-z0-9]/g, '_');
             _defaultProjectId = `local_${sanitized}`;
+            _projectIdLocked = true;
             console.error(`[claudetools] Warning: Legacy project ID "${config.defaultProjectId}" ` +
                 `converted to "${_defaultProjectId}". Run "claudetools cleanup" to fix config.`);
             return _defaultProjectId;
         }
         _defaultProjectId = config.defaultProjectId;
+        _projectIdLocked = true;
         return _defaultProjectId;
     }
     // Fall back to resolveProjectId (throws if not resolved)
     _defaultProjectId = resolveProjectId();
+    _projectIdLocked = true;
     return _defaultProjectId;
 }
 /**

package/dist/helpers/session-validation.d.ts

@@ -12,7 +12,7 @@ export declare function validateTaskStartSequence(taskId: string): {
 };
 /**
  * Validate that codebase_map was called before code modification tools
- * Code modification tools: codedna_generate_*, or any task involving file changes
+ * Code modification tools: codegen, or any task involving file changes
  */
 export declare function validateCodebaseMapSequence(): {
     valid: boolean;

package/dist/helpers/session-validation.js

@@ -91,7 +91,7 @@ export function validateTaskStartSequence(taskId) {
 }
 /**
  * Validate that codebase_map was called before code modification tools
- * Code modification tools: codedna_generate_*, or any task involving file changes
+ * Code modification tools: codegen, or any task involving file changes
  */
 export function validateCodebaseMapSequence() {
     const warnings = [];
@@ -108,9 +108,7 @@ export function validateCodebaseMapSequence() {
  */
 export function isCodeModificationTool(toolName) {
     const codeTools = [
-        'codedna_generate_api',
-        'codedna_generate_frontend',
-        'codedna_generate_component',
+        'codegen',
         'task_start', // Tasks often involve code changes
     ];
     return codeTools.includes(toolName);