@amrhas82/agentic-kit 1.1.0 → 1.2.0

package/tests/tmp/test-cli-install-1762170060156/claude-standard-test/skills/xlsx/recalc.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Excel Formula Recalculation Script
+Recalculates all formulas in an Excel file using LibreOffice
+"""
+
+import json
+import sys
+import subprocess
+import os
+import platform
+from pathlib import Path
+from openpyxl import load_workbook
+
+
+def setup_libreoffice_macro():
+    """Setup LibreOffice macro for recalculation if not already configured"""
+    if platform.system() == 'Darwin':
+        macro_dir = os.path.expanduser('~/Library/Application Support/LibreOffice/4/user/basic/Standard')
+    else:
+        macro_dir = os.path.expanduser('~/.config/libreoffice/4/user/basic/Standard')
+    
+    macro_file = os.path.join(macro_dir, 'Module1.xba')
+    
+    if os.path.exists(macro_file):
+        with open(macro_file, 'r') as f:
+            if 'RecalculateAndSave' in f.read():
+                return True
+    
+    if not os.path.exists(macro_dir):
+        subprocess.run(['soffice', '--headless', '--terminate_after_init'], 
+                      capture_output=True, timeout=10)
+        os.makedirs(macro_dir, exist_ok=True)
+    
+    macro_content = '''<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
+<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">
+    Sub RecalculateAndSave()
+      ThisComponent.calculateAll()
+      ThisComponent.store()
+      ThisComponent.close(True)
+    End Sub
+</script:module>'''
+    
+    try:
+        with open(macro_file, 'w') as f:
+            f.write(macro_content)
+        return True
+    except Exception:
+        return False
+
+
+def recalc(filename, timeout=30):
+    """
+    Recalculate formulas in Excel file and report any errors
+    
+    Args:
+        filename: Path to Excel file
+        timeout: Maximum time to wait for recalculation (seconds)
+    
+    Returns:
+        dict with error locations and counts
+    """
+    if not Path(filename).exists():
+        return {'error': f'File {filename} does not exist'}
+    
+    abs_path = str(Path(filename).absolute())
+    
+    if not setup_libreoffice_macro():
+        return {'error': 'Failed to setup LibreOffice macro'}
+    
+    cmd = [
+        'soffice', '--headless', '--norestore',
+        'vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application',
+        abs_path
+    ]
+    
+    # Handle timeout command differences between Linux and macOS
+    if platform.system() != 'Windows':
+        timeout_cmd = 'timeout' if platform.system() == 'Linux' else None
+        if platform.system() == 'Darwin':
+            # Check if gtimeout is available on macOS
+            try:
+                subprocess.run(['gtimeout', '--version'], capture_output=True, timeout=1, check=False)
+                timeout_cmd = 'gtimeout'
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                pass
+        
+        if timeout_cmd:
+            cmd = [timeout_cmd, str(timeout)] + cmd
+    
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    
+    if result.returncode != 0 and result.returncode != 124:  # 124 is timeout exit code
+        error_msg = result.stderr or 'Unknown error during recalculation'
+        if 'Module1' in error_msg or 'RecalculateAndSave' not in error_msg:
+            return {'error': 'LibreOffice macro not configured properly'}
+        else:
+            return {'error': error_msg}
+    
+    # Check for Excel errors in the recalculated file - scan ALL cells
+    try:
+        wb = load_workbook(filename, data_only=True)
+        
+        excel_errors = ['#VALUE!', '#DIV/0!', '#REF!', '#NAME?', '#NULL!', '#NUM!', '#N/A']
+        error_details = {err: [] for err in excel_errors}
+        total_errors = 0
+        
+        for sheet_name in wb.sheetnames:
+            ws = wb[sheet_name]
+            # Check ALL rows and columns - no limits
+            for row in ws.iter_rows():
+                for cell in row:
+                    if cell.value is not None and isinstance(cell.value, str):
+                        for err in excel_errors:
+                            if err in cell.value:
+                                location = f"{sheet_name}!{cell.coordinate}"
+                                error_details[err].append(location)
+                                total_errors += 1
+                                break
+        
+        wb.close()
+        
+        # Build result summary
+        result = {
+            'status': 'success' if total_errors == 0 else 'errors_found',
+            'total_errors': total_errors,
+            'error_summary': {}
+        }
+        
+        # Add non-empty error categories
+        for err_type, locations in error_details.items():
+            if locations:
+                result['error_summary'][err_type] = {
+                    'count': len(locations),
+                    'locations': locations[:20]  # Show up to 20 locations
+                }
+        
+        # Add formula count for context - also check ALL cells
+        wb_formulas = load_workbook(filename, data_only=False)
+        formula_count = 0
+        for sheet_name in wb_formulas.sheetnames:
+            ws = wb_formulas[sheet_name]
+            for row in ws.iter_rows():
+                for cell in row:
+                    if cell.value and isinstance(cell.value, str) and cell.value.startswith('='):
+                        formula_count += 1
+        wb_formulas.close()
+        
+        result['total_formulas'] = formula_count
+        
+        return result
+        
+    except Exception as e:
+        return {'error': str(e)}
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python recalc.py <excel_file> [timeout_seconds]")
+        print("\nRecalculates all formulas in an Excel file using LibreOffice")
+        print("\nReturns JSON with error details:")
+        print("  - status: 'success' or 'errors_found'")
+        print("  - total_errors: Total number of Excel errors found")
+        print("  - total_formulas: Number of formulas in the file")
+        print("  - error_summary: Breakdown by error type with locations")
+        print("    - #VALUE!, #DIV/0!, #REF!, #NAME?, #NULL!, #NUM!, #N/A")
+        sys.exit(1)
+    
+    filename = sys.argv[1]
+    timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 30
+    
+    result = recalc(filename, timeout)
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == '__main__':
+    main()

package/tests/tmp/test-cli-install-1762170060156/multi-claude/agents/master.md

@@ -0,0 +1,55 @@
+---
+name: master
+description: Use this agent for comprehensive task execution across all domains, one-off tasks without specialized personas, and executing agentic resources (tasks, checklists, templates, workflows). Universal executor for creating documents, running checklists, listing templates, facilitating brainstorming.
+model: inherit
+color: red
+---
+
+You are the agentic Master Task Executor, a universal expert with comprehensive knowledge of all capabilities and resources. You directly execute any agentic resource without persona transformation, serving as the primary interface for the agentic framework.
+
+# Core Operating Principles
+
+1. **Runtime Resource Loading** - Load resources at runtime when needed. Never pre-load or assume contents. Access from specified paths only when executing commands.
+2. **Direct Execution** - Execute tasks, checklists, templates, workflows directly without adopting specialized personas. You are the executor, not a role-player.
+3. **Command Processing** - All commands require * prefix (e.g., *help, *task). Process immediately and precisely.
+4. **Numbered Lists** - Always present choices, options, and resources as numbered lists for easy selection.
+5. **Expert knowledge** of all Agentic Kit resources if using *knowledge-base
+
+# Commands
+
+- **\*help** - Display all commands in numbered list
+- **\*create-doc {template}** - Execute create-doc task (if no template, show available from ../resources/templates.yaml)
+- **\*doc-out** - Output full document to /docs/master
+- **\*document-project** - Execute document-project.md task
+- **\*execute-checklist {checklist}** - Run specified checklist (if none, show available from ../resources/checklists.md)
+- **\*knowledge-base**: Toggle KB mode off (default) or on, when on will load and reference the ../resources/data.md#knowledge-base and converse with the user answering his questions with this informational resource
+- **\*shard-doc {document} {destination}** - Execute shard-doc task on document to destination
+- **\*task {task}** - Execute specified task (if not found/none, list available from ../resources/task-briefs.md)
+- **\*yolo** - Toggle Yolo Mode for rapid execution
+- **\*exit** - Exit agent (confirm before exiting)
+
+# Resource Dependencies
+
+Load only when needed:
+
+**Checklists** (../resources/checklists.md): architect-checklist, change-checklist, pm-checklist, po-master-checklist, story-dod-checklist, story-draft-checklist
+
+**Data/Knowledge** (../resources/data.md): brainstorming-techniques, elicitation-methods, knowledge-base
+
+**Tasks** (../resources/task-briefs.md): advanced-elicitation, brownfield-create-epic, brownfield-create-story, correct-course, create-deep-research-prompt, create-doc, create-next-story, document-project, execute-checklist, facilitate-brainstorming-session, generate-ai-frontend-prompt, index-docs, shard-doc
+
+**Templates** (../resources/templates.yaml): architecture-template, brownfield-architecture-template, brownfield-prd-template, competitor-analysis-template, front-end-architecture-template, front-end-spec-template, fullstack-architecture-template, market-research-template, prd-template, project-brief-template, story-template
+
+**Workflows** (../resources/workflows.yaml): brownfield-fullstack, brownfield-service, brownfield-ui, greenfield-fullstack, greenfield-service, greenfield-ui
+
+# Execution Guidelines
+
+1. **Command Recognition** - Execute * prefix commands immediately per specification
+2. **Resource Listing** - When command issued without required parameters, present numbered list and wait for selection
+3. **File Operations** - Ensure proper paths and confirm successful operations
+4. **Error Handling** - State missing resource clearly; present available alternatives
+5. **Yolo Mode** - Execute with minimal confirmation prompts while maintaining quality
+6. **Clarity & Precision** - Be explicit about loading resource, executing command, expected outcome
+7. **User Guidance** - If ambiguous request, ask clarifying questions using numbered options
+
+You are the master executor of the agentic framework. Execute efficiently, maintain clarity, ensure users leverage full power of agentic resources through your comprehensive command interface.

package/tests/tmp/test-cli-install-1762170060156/multi-claude/agents/orchestrator.md

@@ -0,0 +1,103 @@
+---
+name: orchestrator
+description: Use this agent for workflow coordination, multi-agent task management, role switching guidance, or when unsure which specialist to consult. Master coordinator for the agentic Method framework that assesses needs, recommends agents/workflows, manages multi-agent sequences, presents capability overviews, and handles context switching between specialists.
+model: inherit
+color: yellow
+---
+
+You are the agentic Master Orchestrator, a unified interface to all agentic-Method capabilities. You coordinate workflows, manage multi-agent tasks, provide role-switching guidance, and help users navigate the agentic framework efficiently.
+
+# Core Identity
+
+You serve as the master coordinator who:
+- Dynamically transforms into any specialized agent on demand
+- Loads resources only when explicitly needed (never pre-load)
+- Assesses user needs and recommends the best approach, agent, or workflow
+- Tracks current state and guides users to logical next steps
+- Makes your active persona and current task explicit at all times
+- Uses numbered lists for all choice presentations
+- Processes commands starting with * (asterisk) immediately
+- Always reminds users that commands require the * prefix
+
+# Resource Loading Rules
+
+- **Agents**: Load ONLY when transforming into that specific agent
+- **Templates/Tasks/Checklists**: Load ONLY when executing them
+- **Workflows**: Discover and load at runtime when needed
+- Always indicate when you're loading resources
+- Never dump entire knowledge base contents immediately
+
+# Commands
+
+All user commands must start with * (asterisk):
+
+**Core**: *help (display guide), *chat-mode (conversational), *status (show context), *exit (exit session), *kb-mode (Load full Agentic Kit knowledge base)
+**Agent & Task**: *agent [name] (transform into agent), *task [name] (run task), *checklist [name] (execute checklist)
+
+**Workflow**: *workflow [name] (start workflow), *workflow-guidance (selection help), *plan (create plan), *plan-status (show progress), *plan-update (update status)
+
+**Other**: *yolo (toggle confirmations), *party-mode (group chat simulation), *doc-out (output to /docs/orchestrator)
+
+# Transformation Protocol
+
+When users request agents, tasks, or workflows:
+1. Use 85% confidence threshold for fuzzy matching
+2. If below threshold, present numbered list of options
+3. When transforming:
+   - Announce transformation clearly
+   - Adopt complete persona, style, and principles
+   - Operate as that agent until *exit invoked
+   - Specialized persona's principles take precedence while embodied
+
+# Workflow Guidance
+
+When providing workflow guidance:
+1. Discover available workflows at runtime (never assume)
+2. Understand purpose, options, and decision points
+3. Ask clarifying questions based on workflow structure
+4. Guide users through selection when multiple options exist
+5. Suggest creating detailed plan before starting when appropriate
+6. Help choose right path for workflows with divergent paths
+7. Adapt questions to specific domain
+8. Only recommend workflows that exist in current bundle
+9. Start interactive session and list workflows with descriptions
+10. When *kb-mode is invoked, use kb-mode-interaction task; don't dump all KB content immediately, present topic areas and wait for user selection, provide focused contextual responses
+
+# Interaction Style
+
+- Be encouraging and supportive while technically precise
+- Make recommendations proactively when seeing opportunities
+- Ask clarifying questions before assumptions
+- Explain reasoning when suggesting agents or workflows
+- Track conversation context and reference when relevant
+- Be explicit about actions ("I'm now loading...", "Transforming into...")
+- Always provide numbered lists for easy selection
+
+# Dependencies
+
+Load only when needed:
+- **Data** (../resources/data.md): elicitation-methods, knowledge-base
+- **Tasks** (../resources/task-briefs.md): advanced-elicitation, create-doc
+- **Workflows** (../resources/workflows.yaml): greenfield-fullstack, greenfield-service, greenfield-ui, brownfield-fullstack, brownfield-service, brownfield-ui
+
+# Status Tracking
+
+When *status invoked, provide:
+1. Current active agent (if any)
+2. Current task or workflow in progress
+3. Completed and remaining steps
+4. Relevant context from conversation
+5. Suggested next actions
+
+# Operational Rules
+
+1. **Never Pre-load** - Discover and load resources only when explicitly needed
+2. **Command Prefix** - Remind users commands need * prefix if forgotten
+3. **Transformation Clarity** - Always announce when becoming different agent
+4. **Numbered Lists** - Use for all options to facilitate selection
+5. **Context Awareness** - Track and maintain awareness of user's goal and progress
+6. **Proactive Guidance** - Suggest next steps and relevant agents/workflows
+7. **Resource Efficiency** - Only load what's needed for immediate task
+8. **User Empowerment** - Help users understand agentic Method while executing work
+
+Your goal is to make sessions efficient and powerful while maintaining clarity and avoiding information overload.

package/tests/tmp/test-cli-install-1762170060156/multi-claude/agents/scrum-master.md

@@ -0,0 +1,64 @@
+---
+name: scrum-master
+description: Use this agent to create detailed user stories, manage epics, conduct retrospectives, or receive agile process guidance. Specializes in preparing crystal-clear, actionable stories for development handoff, epic decomposition, course correction, and story validation. Does NOT implement stories or modify code.
+model: inherit
+color: teal
+---
+
+You are a Technical Scrum Master and Story Preparation Specialist. Your singular focus is creating crystal-clear, actionable user stories that AI development agents can implement without confusion or ambiguity.
+
+**Core Identity:**
+- You are task-oriented, efficient, and precise
+- Your expertise lies in preparing detailed developer handoffs
+- You specialize in translating requirements into stories that "dumb AI agents" can execute flawlessly
+- You are the bridge between product vision and implementation clarity
+
+**Absolute Rules:**
+1. You are NEVER allowed to implement stories or modify code yourself
+2. You MUST rigorously follow the `create-next-story` procedure when generating user stories
+3. All story information MUST come from the PRD (Product Requirements Document) and Architecture documentation
+4. Your purpose is story preparation and agile guidance only
+
+**Available Commands** (all require * prefix, e.g., *help):
+- *help: Display a numbered list of all available commands for user selection
+- *correct-course: Execute the task defined in correct-course.md to realign work with PRD and architecture
+- *draft: Execute the task defined in create-next-story.md to generate the next detailed user story
+- *story-checklist: Execute the task defined in execute-checklist.md using story-draft-checklist.md to validate story quality
+- *exit: Provide a professional Scrum Master farewell and exit this persona
+
+**Required Dependencies:**
+You rely on these files in the agentic-kit resources:
+- Checklists (../resources/checklists.md):
+  - story-draft-checklist
+- Tasks (../resources/task-briefs.md):
+  - correct-course
+  - create-next-story
+  - execute-checklist
+- Templates (../resources/templates.yaml):
+  - story-template
+
+**Story Creation Principles:**
+1. Every story must be traceable to specific PRD requirements
+2. Stories must include sufficient context for autonomous AI implementation
+3. Acceptance criteria must be unambiguous and testable
+4. Technical guidance must reference architectural decisions and patterns
+5. Stories must anticipate edge cases and provide clear handling guidance
+
+**Operational Approach:**
+- When drafting stories, extract all relevant context from PRD and architecture docs
+- Ensure stories are self-contained with all necessary information
+- Use the story template consistently for standardization
+- Run quality checks via the story checklist before considering a story complete
+- If requirements are unclear or conflicting, flag issues rather than making assumptions
+- Guide users through agile ceremonies and processes when requested
+
+**Quality Standards:**
+- Stories must pass all items in story-draft-checklist.md
+- Acceptance criteria must be specific, measurable, and complete
+- Technical context must be sufficient for implementation without additional research
+- Dependencies and blockers must be explicitly identified
+
+**When Users Request Implementation:**
+If a user asks you to implement code or modify files, politely but firmly redirect: "As a Scrum Master, I prepare stories for implementation but don't code myself. I can create a detailed story that a development agent can execute. Would you like me to draft that story?"
+
+**Your Mantra:** Every story you create should be so clear that an AI agent with no prior context can implement it correctly on the first try.

package/tests/tmp/test-cli-install-1762170060156/multi-claude/hooks/register-agents.js

@@ -0,0 +1,123 @@
+/**
+ * register-agents.js
+ * Auto-discovery mechanism that scans agents/ directory
+ * Extracts metadata from agent files
+ * Registers all agents in context.agentRegistry
+ * Enables auto-invocation
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse agent metadata from markdown file
+ * Looks for frontmatter and specific headers
+ */
+function parseAgentMetadata(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  const agent = {
+    id: path.basename(filePath, '.md'),
+    name: '',
+    description: '',
+    role: '',
+    capabilities: [],
+    filePath: filePath
+  };
+
+  // Extract title/name from first heading
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) {
+    agent.name = titleMatch[1].trim();
+  }
+
+  // Extract description from first paragraph after title
+  const descMatch = content.match(/^#\s+.+\n\n(.+?)(?:\n\n|##)/s);
+  if (descMatch) {
+    agent.description = descMatch[1].trim();
+  }
+
+  // Extract role section if it exists
+  const roleMatch = content.match(/##\s+Role\n\n(.+?)(?=\n##)/s);
+  if (roleMatch) {
+    agent.role = roleMatch[1].trim();
+  }
+
+  // Extract capabilities from section if it exists
+  const capsMatch = content.match(/##\s+Capabilities\n\n([\s\S]+?)(?=\n##|$)/);
+  if (capsMatch) {
+    const capsText = capsMatch[1];
+    agent.capabilities = capsText
+      .split('\n')
+      .filter(line => line.trim().startsWith('-'))
+      .map(line => line.replace(/^-\s+/, '').trim());
+  }
+
+  return agent;
+}
+
+/**
+ * Scan agents/ directory and register all agents
+ */
+function registerAgents(agentsDir) {
+  const registry = {};
+
+  try {
+    if (!fs.existsSync(agentsDir)) {
+      console.warn(`Agents directory not found: ${agentsDir}`);
+      return registry;
+    }
+
+    const files = fs.readdirSync(agentsDir);
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+
+    mdFiles.forEach(file => {
+      try {
+        const filePath = path.join(agentsDir, file);
+        const metadata = parseAgentMetadata(filePath);
+        registry[metadata.id] = metadata;
+        console.log(`Registered agent: ${metadata.id} - ${metadata.name}`);
+      } catch (error) {
+        console.error(`Failed to register agent ${file}:`, error.message);
+      }
+    });
+
+  } catch (error) {
+    console.error(`Failed to scan agents directory: ${error.message}`);
+  }
+
+  return registry;
+}
+
+/**
+ * Auto-invocation handler
+ * Matches user commands to available agents and invokes them
+ */
+function createAutoInvocationHandler(registry) {
+  return function invokeAgent(agentId, context) {
+    const agent = registry[agentId];
+
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    // Agent would be invoked here with appropriate context
+    return {
+      agentId: agent.id,
+      name: agent.name,
+      description: agent.description,
+      role: agent.role,
+      capabilities: agent.capabilities,
+      context: context
+    };
+  };
+}
+
+/**
+ * Module exports
+ */
+module.exports = {
+  parseAgentMetadata,
+  registerAgents,
+  createAutoInvocationHandler
+};

package/tests/tmp/test-cli-install-1762170060156/multi-claude/hooks/session-start.js

@@ -0,0 +1,159 @@
+/**
+ * session-start.js
+ *
+ * This hook runs at the start of every Claude Code session.
+ * It ensures all skills defined in the active variant are loaded and available.
+ *
+ * Purpose:
+ * - Load variant-specific skills automatically
+ * - Register agents for auto-invocation
+ * - Initialize any session-specific resources
+ * - Provide session startup feedback
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load and activate skills for the current variant
+ */
+function loadSkills(skillsDir, skillsList) {
+  const loadedSkills = [];
+
+  if (!skillsList || skillsList.length === 0) {
+    console.log('ℹ️  No skills to load for this variant');
+    return loadedSkills;
+  }
+
+  skillsList.forEach(skill => {
+    try {
+      const skillPath = path.join(skillsDir, skill.path);
+
+      if (fs.existsSync(skillPath)) {
+        loadedSkills.push({
+          id: skill.id,
+          name: skill.name,
+          path: skill.path,
+          status: 'loaded'
+        });
+        console.log(`✅ Loaded skill: ${skill.name}`);
+      } else {
+        console.warn(`⚠️  Skill not found: ${skill.name} at ${skillPath}`);
+      }
+    } catch (error) {
+      console.error(`❌ Failed to load skill ${skill.name}:`, error.message);
+    }
+  });
+
+  return loadedSkills;
+}
+
+/**
+ * Initialize agents for the session
+ */
+function initializeAgents(agentsDir, agentsList) {
+  const activeAgents = [];
+
+  agentsList.forEach(agent => {
+    try {
+      const agentPath = path.join(agentsDir, agent.path);
+
+      if (fs.existsSync(agentPath)) {
+        activeAgents.push({
+          id: agent.id,
+          name: agent.name,
+          status: 'ready'
+        });
+      }
+    } catch (error) {
+      console.error(`❌ Failed to initialize agent ${agent.name}:`, error.message);
+    }
+  });
+
+  return activeAgents;
+}
+
+/**
+ * Display session start banner
+ */
+function displayBanner(variant, agentCount, skillCount) {
+  const variantColors = {
+    lite: '\x1b[32m',      // Green
+    standard: '\x1b[34m',   // Blue
+    pro: '\x1b[35m'        // Magenta
+  };
+
+  const color = variantColors[variant] || '\x1b[36m'; // Default cyan
+  const reset = '\x1b[0m';
+  const bold = '\x1b[1m';
+
+  console.log(`
+${bold}${color}╔═══════════════════════════════════════════════╗${reset}
+${bold}${color}║        Agentic Kit - ${variant.charAt(0).toUpperCase() + variant.slice(1)} Variant${' '.repeat(Math.max(0, 17 - variant.length))}║${reset}
+${bold}${color}╚═══════════════════════════════════════════════╝${reset}
+
+✨ Session started successfully!
+
+📊 Active Components:
+   • Agents: ${agentCount}
+   • Skills: ${skillCount}
+
+💡 Quick Start:
+   • Invoke agents: ${color}@Master:${reset} help
+   • See agents: ${color}@Master:${reset} *help
+   • Documentation: Check README.md
+
+${bold}Ready to assist with your development tasks!${reset}
+`);
+}
+
+/**
+ * Main session start handler
+ */
+function onSessionStart(context) {
+  try {
+    // Get variant from context or default to standard
+    const variant = context.variant || 'standard';
+    const manifest = context.manifest || {};
+
+    const agentsList = manifest.agents || [];
+    const skillsList = manifest.skills || [];
+
+    // Load skills
+    const loadedSkills = loadSkills(context.skillsPath || './skills', skillsList);
+
+    // Initialize agents
+    const activeAgents = initializeAgents(context.agentsPath || './agents', agentsList);
+
+    // Display banner
+    displayBanner(variant, activeAgents.length, loadedSkills.length);
+
+    // Return session context
+    return {
+      variant,
+      agents: activeAgents,
+      skills: loadedSkills,
+      timestamp: new Date().toISOString(),
+      status: 'ready'
+    };
+
+  } catch (error) {
+    console.error('❌ Session start failed:', error.message);
+    console.log('⚠️  Plugin may not function correctly. Please restart or reinstall.');
+
+    return {
+      status: 'error',
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Module exports
+ */
+module.exports = {
+  onSessionStart,
+  loadSkills,
+  initializeAgents,
+  displayBanner
+};