opencode-enhancer-plugin 1.0.1 → 1.5.0

package/dist/index.js

@@ -1,29 +1,325 @@
+import { TodoParser } from "./utils/todoParser.js";
+import { todoStore } from "./utils/sessionStore.js";
+// === TODO ENFORCER CONSTANTS ===
+const TODO_ENFORCER_AGENTS = ['ultraplan', 'strategos'];
+const TODO_MARKER_START = '<!-- TODOS-START -->';
+const TODO_MARKER_END = '<!-- TODOS-END -->';
+// === STRATEGOS MODE CONSTANTS ===
+const STRATEGOS_KEYWORDS = [
+    'strategos',
+    'strategy',
+    'strat',
+    'interview mode',
+    'strategic plan',
+    'complex plan',
+    'architecture decision',
+    'design review',
+    'comprehensive plan',
+    '🎯',
+];
+// Validation Constants
+const VALID_MODEL_PATTERNS = [
+    /^opencode\//,
+    /^anthropic\//,
+    /^openai\//,
+    /^google\//,
+    /^mistral\//,
+    /^cohere\//,
+    /^ollama\//,
+    /^zai-coding-plan\//,
+    /^kimi-for-coding\//
+];
+const DEFAULT_MODEL = "opencode/kimi-k2.5-free";
+// Model Validation Function
+function validateModel(model, agentName, client) {
+    if (!model || typeof model !== 'string') {
+        client.app.log({
+            service: "enhancer",
+            level: "warn",
+            message: `Invalid model for ${agentName}, using default`
+        }).catch(() => { });
+        return DEFAULT_MODEL;
+    }
+    const isValid = VALID_MODEL_PATTERNS.some(pattern => pattern.test(model));
+    if (!isValid) {
+        client.app.log({
+            service: "enhancer",
+            level: "warn",
+            message: `Unknown model provider for ${agentName}: ${model}, using default`
+        }).catch(() => { });
+        return DEFAULT_MODEL;
+    }
+    return model;
+}
+// Model Resolver with Hierarchical Configuration
+function resolveModel(agentName, agentType, existingConfig, client) {
+    let model;
+    // 1. Check existing OpenCode Config (highest priority)
+    if (existingConfig?.model) {
+        return validateModel(existingConfig.model, agentName, client);
+    }
+    // 2. Specific environment variable (e.g., ENHANCER_MODEL_REVIEW_PLAN)
+    const specificVar = `ENHANCER_MODEL_${agentName.toUpperCase().replace(/-/g, '_')}`;
+    model = process.env[specificVar];
+    if (model) {
+        client.app.log({
+            service: "enhancer",
+            level: "info",
+            message: `Using specific env var ${specificVar} for ${agentName}`
+        }).catch(() => { });
+        return validateModel(model, agentName, client);
+    }
+    // 3. Grouped environment variable (ENHANCER_MODEL_SUBAGENT or ENHANCER_MODEL_PRIMARY)
+    const groupVar = `ENHANCER_MODEL_${agentType.toUpperCase()}`;
+    model = process.env[groupVar];
+    if (model) {
+        client.app.log({
+            service: "enhancer",
+            level: "info",
+            message: `Using group env var ${groupVar} for ${agentName}`
+        }).catch(() => { });
+        return validateModel(model, agentName, client);
+    }
+    // 4. Default
+    return DEFAULT_MODEL;
+}
 export const EnhancerPlugin = async ({ client }) => {
     client.app.log({
         service: "enhancer",
         level: "info",
-        message: "Enhancer plugin initialized"
+        message: "🔥 Enhancer plugin v1.5.0 initialized with 5 Specialized Subagents"
     }).catch(() => { });
     return {
         config: async (input) => {
             if (!input.agent) {
                 input.agent = {};
             }
-            input.agent["explore-context"] = {
-                mode: "subagent",
-                hidden: true,
-                model: "opencode/kimi-k2.5-free",
-                prompt: `You are the UNIVERSAL CONTEXT DETECTIVE. Map the codebase and extract technical context.`,
+            // Helper function to configure agent with merging logic
+            const configureAgent = (name, type, defaultConfig) => {
+                const existing = input.agent[name] || {};
+                const resolvedModel = resolveModel(name, type, existing, client);
+                // Merge: Default → User Config → Resolved Model → Fixed Props
+                input.agent[name] = {
+                    ...defaultConfig,
+                    ...existing,
+                    model: resolvedModel,
+                    mode: type === 'subagent' ? 'subagent' : 'primary',
+                    ...(type === 'subagent' ? { hidden: true } : {})
+                };
+            };
+            // === SUBAGENTS (4 spezialisierte Experten) ===
+            // 1. LIBRARIAN - Dokumentation & Recherche
+            configureAgent('librarian', 'subagent', {
+                prompt: `You are LIBRARIAN - a documentation and codebase research specialist.
+
+YOUR EXPERTISE:
+- Find official documentation (Context7)
+- Search GitHub for implementation examples (codesearch)
+- Map project structure and entry points
+- Identify tech stack and frameworks
+
+WORKFLOW:
+1. ALWAYS check context7 first for detected libraries
+2. Use codesearch for real-world usage patterns
+3. List project structure with glob
+4. Return structured findings
+
+OUTPUT FORMAT:
+# 📚 Librarian Report
+
+## Tech Stack Detected
+- **Framework**: [Name + Version]
+- **Language**: [TypeScript/Python/etc.]
+- **Key Libraries**: [List with Context7 links]
+
+## Project Structure
+- **Entry Point**: [Main file]
+- **Core Directories**: [src/, lib/, etc.]
+- **Config Files**: [package.json, tsconfig.json, etc.]
+
+## Documentation Resources
+- Context7 Libraries: [List of libraries with docs available]
+- GitHub Examples: [Patterns found via codesearch]
+
+## Recommendations
+- [What should the primary agent know?]
+- [Any missing dependencies?]`,
                 tools: {
                     list: true,
                     read: true,
                     grep: true,
-                    bash: true
+                    context7_resolve_library_id: true,
+                    context7_query_docs: true,
+                    codesearch: true
                 }
-            };
-            input.agent.enhancer = {
-                mode: "primary",
-                model: "opencode/kimi-k2.5-free",
+            });
+            // 2. ORACLE - Debugging & Code Analysis
+            configureAgent('oracle', 'subagent', {
+                prompt: `You are ORACLE - a debugging and code architecture specialist.
+
+YOUR EXPERTISE:
+- Deep code analysis and understanding
+- Error pattern recognition
+- Architecture evaluation
+- Root cause analysis (not symptoms!)
+
+WORKFLOW:
+1. Read relevant source files thoroughly
+2. Analyze patterns and relationships
+3. Identify issues or architectural concerns
+4. Provide specific, actionable insights
+
+OUTPUT FORMAT:
+# 🔮 Oracle Analysis
+
+## Code Understanding
+- **File**: [path/to/file.ts]
+- **Purpose**: [What does this code do?]
+- **Key Functions**: [List important functions/classes]
+
+## Issues Found
+- **[SEVERITY: Critical/Warning/Info]** [Issue description]
+  - Location: [File:Line]
+  - Impact: [What could go wrong]
+  - Fix: [Specific recommendation]
+
+## Architecture Assessment
+- **Patterns Used**: [Singleton, Factory, etc.]
+- **Coupling**: [High/Medium/Low]
+- **Recommendations**: [Improvements]`,
+                tools: {
+                    read: true,
+                    grep: true
+                }
+            });
+            // 3. ARCHITECT - Dependencies & System Design
+            configureAgent('architect', 'subagent', {
+                prompt: `You are ARCHITECT - a dependency and system design specialist.
+
+YOUR EXPERTISE:
+- Dependency analysis and conflicts
+- Import patterns and module relationships
+- System architecture evaluation
+- Integration complexity assessment
+
+WORKFLOW:
+1. Analyze package.json / requirements / dependencies
+2. Map import patterns across codebase
+3. Check for version conflicts or deprecated packages
+4. Assess system boundaries
+
+OUTPUT FORMAT:
+# 🏗️ Architecture Report
+
+## Dependencies Analysis
+- **Core Libraries**: [List with versions]
+- **Dev Dependencies**: [Testing, build tools]
+- **Peer Dependencies**: [Compatibility requirements]
+
+## Import Patterns
+- **Common Imports**: [Most used modules]
+- **Circular Dependencies**: [If any found]
+- **Unused Dependencies**: [Potential cleanup]
+
+## System Boundaries
+- **External APIs**: [Services integrated]
+- **Database/Storage**: [Data layer]
+- **Authentication**: [Auth mechanism]
+
+## Risk Assessment
+- **Version Conflicts**: [Issues]
+- **Deprecated Packages**: [Needs update]
+- **Security Concerns**: [Vulnerabilities]`,
+                tools: {
+                    read: true,
+                    grep: true,
+                    glob: true
+                }
+            });
+            // 4. REVIEWER - Plan Validation
+            configureAgent('reviewer', 'subagent', {
+                prompt: `You are REVIEWER - a critical plan validation specialist.
+
+YOUR EXPERTISE:
+- Spot missing steps in plans
+- Identify technical risks early
+- Validate file paths and assumptions
+- Ensure test coverage
+
+WORKFLOW:
+1. Analyze the proposed plan
+2. Check for completeness gaps
+3. Verify technical feasibility
+4. Provide critical feedback
+
+OUTPUT FORMAT:
+# ✅ Plan Review
+
+## Summary
+- **Status**: [APPROVED / NEEDS_REVISION]
+- **Completeness**: [X%]
+- **Risk Level**: [Low/Medium/High]
+
+## Critical Issues
+1. [Issue] → [Fix]
+
+## Warnings
+1. [Concern] → [Mitigation]
+
+## Missing Elements
+- [What was forgotten?]
+
+## Final Verdict
+[One paragraph assessment]`,
+                tools: {
+                    read: true,
+                    task: true
+                }
+            });
+            // 5. INTERVIEWER (nur für strategos)
+            configureAgent('interviewer', 'subagent', {
+                prompt: `You are INTERVIEWER - a requirements clarification specialist.
+
+YOUR EXPERTISE:
+- Ask the right questions
+- Uncover hidden assumptions
+- Define clear scope and success criteria
+- Identify stakeholders and constraints
+
+RULES:
+- Ask 3-5 questions maximum
+- Focus on "Must Have" vs "Nice to Have"
+- Clarify technical constraints
+- Define "Done"
+
+OUTPUT FORMAT:
+# 🎤 Interview Report
+
+## Clarification Questions
+
+### Q1: [Question]
+**Why**: [Context]
+
+### Q2: [Question]
+**Why**: [Context]
+
+### Q3: [Question]
+**Why**: [Context]
+
+## Anticipated Complexity
+- **Level**: [Low/Medium/High]
+- **Estimated Effort**: [X hours/days]
+- **Main Risks**: [List]
+
+## Next Steps
+[What to do after getting answers]`,
+                tools: {
+                    read: true
+                }
+            });
+            // Configure Primary Agents
+            // enhancer - Prompt Enhancement
+            configureAgent('enhancer', 'primary', {
                 description: "Universal Technical Architect & Prompt Enhancer",
                 color: "#9C27B0",
                 steps: 15,
@@ -34,36 +330,478 @@ export const EnhancerPlugin = async ({ client }) => {
                     edit: false,
                     write: false
                 },
-                prompt: `You are the CHIEF ARCHITECT (Enhancer). Translate user wishes into precise engineering specifications.`
-            };
+                permission: {
+                    edit: "deny",
+                    bash: "deny"
+                },
+                prompt: `You are ENHANCER - generate enhanced, executable prompts.
+
+WORKFLOW:
+1. Classify intent: FIX/FEAT/REFACTOR/TEST/EXPLAIN
+2. Call subagents IN PARALLEL:
+   - FIX/FEAT: librarian + oracle + architect
+   - REFACTOR: librarian + oracle + reviewer
+   - TEST: librarian + oracle + architect + reviewer
+   - EXPLAIN: librarian + oracle
+3. Synthesize results
+4. Generate markdown prompt
+
+OUTPUT FORMAT:
+# Task: [Title]
+
+## Context
+[Tech stack and key files]
+
+## Instructions
+1. [Specific step]
+2. [Specific step]
+
+## Technical Constraints
+- [Constraint 1]
+- [Constraint 2]
+
+---
+**Run in Build mode to execute**
+
+=== RULES ===
+- ALL paths from subagents
+- Be specific, never vague`
+            });
+            // ultraplan - Vereinfacht & Fokussiert
+            configureAgent('ultraplan', 'primary', {
+                description: "Planning Agent with Parallel Discovery 🔍",
+                color: "#FF5722",
+                steps: 20,
+                tools: {
+                    task: true,
+                    read: true,
+                    bash: false,
+                    edit: false,
+                    write: false,
+                    todowrite: true // ⭐ Todo-Integration
+                },
+                permission: {
+                    edit: "deny",
+                    bash: "deny"
+                },
+                prompt: `You are ULTRAPLAN - create implementation plans through parallel discovery.
+
+=== WORKFLOW (STRICT) ===
+
+**STEP 1: PARALLEL DISCOVERY** ⚡
+Call ALL subagents IN PARALLEL:
+- librarian: Map project structure & docs
+- oracle: Analyze relevant code
+- architect: Check dependencies & system design
+
+WAIT for all results. Do NOT proceed before all return.
+
+**STEP 2: CREATE TODOS** 🔒
+MUST use todowrite tool:
+\`\`\`
+todowrite({ 
+  todos: [
+    { id: "1", content: "Step 1: [Specific task]", status: "pending", priority: "high" },
+    { id: "2", content: "Step 2: [Specific task]", status: "pending", priority: "high" },
+    // 3-8 todos depending on complexity
+  ]
+})
+\`\`\`
+
+**STEP 3: CREATE PLAN**
+Generate markdown plan with:
+- File paths from discovery (NEVER invent!)
+- Specific implementation steps
+- Error handling strategy
+
+**STEP 4: REQUEST REVIEW** (optional for complex tasks)
+Call reviewer subagent if plan is high-risk.
+
+=== RULES ===
+- ALL file paths must come from librarian/oracle/architect
+- ALWAYS create todos via todowrite tool
+- NEVER enable write/edit tools
+- End with: "Copy this plan and run in **Build** mode"
+
+=== WHEN TO USE ===
+- Simple bugfixes
+- Small features (1-3 files)
+- Documentation
+- Adding tests
+
+=== WHEN TO USE STRATEGOS ===
+- New features (>3 files)
+- Architecture changes
+- Integrations (APIs, DBs)
+- Performance/Security work`
+            });
+            // ask - Question Answering
+            configureAgent('ask', 'primary', {
+                description: "Context-Aware Question Answering",
+                color: "#2196F3",
+                steps: 15,
+                tools: {
+                    task: true,
+                    read: true,
+                    bash: false,
+                    edit: false,
+                    write: false
+                },
+                permission: {
+                    edit: "deny",
+                    bash: "deny"
+                },
+                prompt: `You are ASK - a context-aware research assistant.
+
+=== WORKFLOW ===
+
+**STEP 1: CLASSIFY QUESTION**
+- CODE: "How does X work?", "Explain this function"
+- ARCHITECTURE: "How is this project structured?"
+- DEBUG: "Why is this not working?"
+- GENERAL: "What is this project about?"
+
+**STEP 2: PARALLEL SUBAGENTS**
+Call based on type:
+
+| Type | Subagents |
+|------|-----------|
+| CODE | librarian + oracle + architect |
+| ARCHITECTURE | librarian + oracle |
+| DEBUG | librarian + oracle + architect + reviewer |
+| GENERAL | librarian |
+
+**STEP 3: SYNTHESIZE**
+- Wait for ALL results
+- Combine findings
+- Resolve conflicts
+
+**STEP 4: ANSWER FORMAT**
+
+## Answer
+[2-4 sentences]
+
+## Details
+
+### Relevant Files
+- \`path/to/file.ts\` - [Why it matters]
+
+### Key Code
+\`\`\`typescript
+// From: path/to/file.ts
+[Snippet]
+\`\`\`
+
+### Context
+- **Tech Stack**: [Technologies]
+- **Pattern**: [Design patterns]
+
+## Explore Further
+- [Suggestion 1]
+- [Suggestion 2]
+
+=== RULES ===
+- ALL paths from subagents (never invent)
+- Cite sources (which subagent found what)
+- Be concise but thorough`
+            });
+            // strategos - Strategic Planning
+            configureAgent('strategos', 'primary', {
+                description: "🎯 Strategic Planner with Interview Mode",
+                color: "#FF6F00",
+                steps: 30,
+                tools: {
+                    task: true,
+                    read: true,
+                    bash: false,
+                    edit: false,
+                    write: false,
+                    todowrite: true
+                },
+                permission: {
+                    edit: "deny",
+                    bash: "deny",
+                },
+                prompt: `You are STRATEGOS - the Strategic General.
+
+=== STRATEGOS WORKFLOW ===
+
+**PHASE 1: INTERVIEW (If needed)**
+When requirements are unclear:
+1. Call interviewer subagent
+2. Present questions to user
+3. Wait for answers
+4. Analyze and confirm understanding
+
+**PHASE 2: DISCOVERY**
+Call ALL in PARALLEL:
+- librarian: Project & docs
+- oracle: Code analysis
+- architect: Dependencies & system
+
+**PHASE 3: STRATEGIC PLANNING**
+
+Create structured plan:
+
+# 🎯 Strategos Strategic Plan
+
+## Mission Statement
+[1-2 sentences]
+
+## Requirements Analysis
+### Must Have
+- [ ]
+### Should Have
+- [ ]
+### Could Have
+- [ ]
+
+## Architecture Decisions
+| Decision | Rationale | Trade-offs |
+|----------|-----------|------------|
+| [Decision] | [Why] | [Pros/Cons] |
+
+## Implementation Roadmap
+
+### Phase 1: Foundation
+**Goal**: [What to achieve]
+**Deliverables**:
+- [ ] [Specific deliverable]
+**Files**:
+- \`path/to/file.ts\` - [Why?]
+**Steps**:
+1. [Concrete step]
+
+### Phase 2: Core Implementation
+...
+
+### Phase 3: Integration & Testing
+...
+
+## Risk Assessment
+| Risk | Probability | Impact | Mitigation |
+|------|------------|--------|------------|
+| [Risk] | High/Med/Low | High/Med/Low | [Strategy] |
+
+## ✅ Quality Gates
+- [ ] Gate 1: [Criterion]
+- [ ] Gate 2: [Criterion]
+
+## 🧪 Validation Plan
+[How to test success]
+
+**NEXT STEP**: Run in **Build** mode.
+
+=== TODO CREATION ===
+MUST create todos via todowrite:
+- Phase 1: [Description]
+- Phase 2: [Description]
+- Phase 3: [Description]
+
+⚠️ You cannot stop until all todos are completed!
+
+=== WHEN TO USE STRATEGOS ===
+- New features (>3 files)
+- Architecture changes
+- Integrations (APIs, DBs)
+- Performance/Security work
+- Complex refactoring
+
+=== WHEN TO USE ULTRAPLAN ===
+- Simple tasks (<3 files)
+- Bugfixes
+- Documentation`,
+            });
+            // Log configured agent models
+            const configuredAgents = [
+                'librarian', 'oracle', 'architect', 'reviewer', 'interviewer',
+                'enhancer', 'ultraplan', 'ask', 'strategos'
+            ];
+            const modelSummary = configuredAgents
+                .map(name => `${name}=${input.agent[name]?.model || 'default'}`)
+                .join(', ');
+            client.app.log({
+                service: "enhancer",
+                level: "info",
+                message: `🔥 Registered ${Object.keys(input.agent).length} agents: ${Object.keys(input.agent).join(", ")}`
+            }).catch(() => { });
+            client.app.log({
+                service: "enhancer",
+                level: "debug",
+                message: `Agent models configured: ${modelSummary}`
+            }).catch(() => { });
         },
         "tool.execute.before": async (input, output) => {
             if (input.tool === "task") {
                 const args = output.args;
-                if (args?.subagent_type === "explore-context") {
+                const validSubagents = [
+                    "librarian", "oracle", "architect", "reviewer", "interviewer"
+                ];
+                if (args?.subagent_type && validSubagents.includes(args.subagent_type)) {
                     client.app.log({
                         service: "enhancer",
                         level: "debug",
-                        message: "Calling explore-context subagent"
+                        message: `Calling ${args.subagent_type} subagent`
                     }).catch(() => { });
                 }
             }
         },
         "message.updated": async (input, output) => {
-            if (input.session?.agent?.name !== "enhancer") {
+            const agentName = input.session?.agent?.name;
+            if (!["enhancer", "ultraplan", "ask", "strategos"].includes(agentName)) {
                 return;
             }
             const content = input.message?.content || "";
             if (content.includes("Build mode") || content.includes("Build Mode")) {
                 return;
             }
-            if (content.includes("```markdown") || content.includes("# Task:")) {
+            if (content.includes("\`\`\`markdown") || content.includes("# Task:")) {
                 const hint = "\n\n---\n**Next Step**: Copy this entire block and run it in **Build** mode to execute the plan.";
                 if (output && typeof output === "object") {
                     output.content = content + hint;
                 }
             }
-        }
+        },
+        // === TODO ENFORCER: Message Completed Hook ===
+        // Extracts todos from agent responses and stores them
+        "message.completed": async (input, output) => {
+            const agentName = input.session?.agent?.name;
+            const sessionId = input.session?.id || input.sessionId || 'default';
+            // Only for Todo-enforced agents
+            if (!TODO_ENFORCER_AGENTS.includes(agentName)) {
+                return;
+            }
+            try {
+                const content = input.message?.content || output?.content || "";
+                // Extract todos
+                const result = TodoParser.extractTodos(content);
+                if (result.hasTodos) {
+                    // Store todos
+                    todoStore.set(sessionId, result.todos, agentName);
+                    // Log for debugging
+                    await client.app.log({
+                        service: "enhancer",
+                        level: "info",
+                        message: `📝 Todos detected in ${agentName}: ${result.completedCount}/${result.todos.length} completed`
+                    }).catch(() => { });
+                    // Add visual todo block if pending todos exist
+                    if (result.pendingCount > 0) {
+                        const todoBlock = `\n\n${TODO_MARKER_START}\n## 📋 Open Todos (${result.pendingCount}/${result.todos.length})\n\n${TodoParser.formatTodoList(result.todos, true)}\n\n⚠️ **Note**: You cannot stop until all Todos are completed!\n${TODO_MARKER_END}`;
+                        if (output && typeof output === "object") {
+                            output.content = content + todoBlock;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                await client.app.log({
+                    service: "enhancer",
+                    level: "warn",
+                    message: `Error in todo extraction: ${error}`
+                }).catch(() => { });
+            }
+        },
+        // === TODO ENFORCER: Stop Requested Hook ===
+        // Prevents stop when todos are open
+        "stop.requested": async (input, output) => {
+            const agentName = input.session?.agent?.name;
+            const sessionId = input.session?.id || input.sessionId || 'default';
+            // Only for Todo-enforced agents
+            if (!TODO_ENFORCER_AGENTS.includes(agentName)) {
+                return;
+            }
+            try {
+                const unfinishedCount = todoStore.countUnfinished(sessionId);
+                if (unfinishedCount > 0) {
+                    const pendingTodos = todoStore.getAllPending(sessionId);
+                    // DENY STOP
+                    output.continue = true;
+                    output.reason = `🛑 **STOP DENIED** - ${unfinishedCount} TODO(S) STILL OPEN!\n\nYou cannot end the session until all tasks are completed. Please work on the remaining todos:\n\n${pendingTodos.map((t, i) => `${i + 1}. [ ] ${t.description}`).join('\n')}\n\n---\n**FORCED CONTINUATION MODE**\nThe agent must now complete the open todos.`;
+                    await client.app.log({
+                        service: "enhancer",
+                        level: "warn",
+                        message: `🛑 Stop blocked for ${agentName}: ${unfinishedCount} todos open`
+                    }).catch(() => { });
+                }
+                else {
+                    // All todos completed - clean up store
+                    if (todoStore.has(sessionId)) {
+                        todoStore.delete(sessionId);
+                        await client.app.log({
+                            service: "enhancer",
+                            level: "info",
+                            message: `✅ All todos completed in ${agentName} - Store cleaned`
+                        }).catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                await client.app.log({
+                    service: "enhancer",
+                    level: "error",
+                    message: `Error in stop.requested hook: ${error}`
+                }).catch(() => { });
+            }
+        },
+        // === TODO ENFORCER: Session Start Hook ===
+        // Cleans old todos on new session
+        "session.start": async (input, output) => {
+            const agentName = input.agent?.name;
+            if (TODO_ENFORCER_AGENTS.includes(agentName)) {
+                // Cleanup old sessions
+                todoStore.cleanup();
+                await client.app.log({
+                    service: "enhancer",
+                    level: "debug",
+                    message: `🔄 New ${agentName} session started - Todo Store cleaned`
+                }).catch(() => { });
+            }
+        },
+        // === TODO ENFORCER: Session End Hook ===
+        "session.end": async (input, output) => {
+            const agentName = input.agent?.name;
+            const sessionId = input.session?.id || input.sessionId || 'default';
+            if (TODO_ENFORCER_AGENTS.includes(agentName)) {
+                // Check if open todos exist
+                if (todoStore.has(sessionId)) {
+                    const stats = todoStore.get(sessionId);
+                    const unfinished = stats?.todos.filter(t => t.status !== 'completed').length || 0;
+                    if (unfinished > 0) {
+                        await client.app.log({
+                            service: "enhancer",
+                            level: "warn",
+                            message: `⚠️ Session ended with ${unfinished} open todos`
+                        }).catch(() => { });
+                    }
+                    // Clean up
+                    todoStore.delete(sessionId);
+                }
+            }
+        },
+        // === STRATEGOS MODE ACTIVATION ===
+        // Auto-switch to strategos on keywords
+        "user.prompt.submitted": async (input, output) => {
+            const prompt = input.prompt || "";
+            const currentAgent = input.agent?.name;
+            const lowerPrompt = prompt.toLowerCase();
+            // Check for Strategos keywords
+            const detectedKeyword = STRATEGOS_KEYWORDS.find(kw => lowerPrompt.includes(kw.toLowerCase()));
+            if (detectedKeyword && currentAgent !== 'strategos') {
+                // Switch to strategos Agent
+                output.agent = 'strategos';
+                // Add hint
+                output.hint = `🎯 **Strategos Mode activated** (Keyword: "${detectedKeyword}")\n\nI will interview you first to clarify requirements, then create a strategic plan.`;
+                await client.app.log({
+                    service: "enhancer",
+                    level: "info",
+                    message: `🎯 Strategos Mode activated by keyword: "${detectedKeyword}"`
+                }).catch(() => { });
+            }
+            // Alternative: Interview Mode hint for ultraplan
+            if (lowerPrompt.includes('interview me') && currentAgent === 'ultraplan') {
+                output.hint = `💡 **Tip**: For complex tasks with interview, use the **strategos** Agent (Tab → strategos)`;
+            }
+        },
     };
 };
 export default EnhancerPlugin;