@amrhas82/agentic-kit 1.0.0 → 1.2.0

package/tests/test-variants-parsing.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+
+/**
+ * Manual Test Script for variants.json Parsing
+ *
+ * Purpose: Verify that all variants.json files can be loaded and parsed correctly,
+ * and that variant selection logic works as expected.
+ *
+ * Tests:
+ * - JSON parsing for all 4 tools (Claude, Opencode, Ampcode, Droid)
+ * - Structure validation for each variant (Lite, Standard, Pro)
+ * - Wildcard patterns ("*")
+ * - Specific selections (["item1", "item2"])
+ * - Empty arrays ([])
+ * - Metadata fields (name, description, useCase, targetUsers)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+// ANSI color codes for output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m'
+};
+
+// Test results tracking
+let totalTests = 0;
+let passedTests = 0;
+let failedTests = 0;
+const failures = [];
+
+// Project root
+const projectRoot = path.join(__dirname, '..');
+const packagesDir = path.join(projectRoot, 'packages');
+
+// Tools to test
+const tools = ['claude', 'opencode', 'ampcode', 'droid'];
+
+// Required variants
+const requiredVariants = ['lite', 'standard', 'pro'];
+
+// Required fields per variant
+const requiredFields = ['name', 'description', 'useCase', 'targetUsers', 'agents', 'skills', 'resources', 'hooks'];
+
+// Expected structure for each variant category
+const expectedCategories = ['agents', 'skills', 'resources', 'hooks'];
+
+/**
+ * Log functions
+ */
+function logSection(message) {
+  console.log(`\n${colors.cyan}${'='.repeat(70)}${colors.reset}`);
+  console.log(`${colors.cyan}${message}${colors.reset}`);
+  console.log(`${colors.cyan}${'='.repeat(70)}${colors.reset}\n`);
+}
+
+function logTest(message) {
+  console.log(`${colors.gray}Testing: ${message}${colors.reset}`);
+}
+
+function logPass(message) {
+  console.log(`  ${colors.green}✓ ${message}${colors.reset}`);
+  passedTests++;
+  totalTests++;
+}
+
+function logFail(message, error) {
+  console.log(`  ${colors.red}✗ ${message}${colors.reset}`);
+  if (error) {
+    console.log(`    ${colors.red}${error}${colors.reset}`);
+  }
+  failedTests++;
+  totalTests++;
+  failures.push({ test: message, error: error || 'Unknown error' });
+}
+
+function logWarning(message) {
+  console.log(`  ${colors.yellow}⚠ ${message}${colors.reset}`);
+}
+
+function logInfo(message) {
+  console.log(`  ${colors.gray}${message}${colors.reset}`);
+}
+
+/**
+ * Test functions
+ */
+
+function testFileExists(toolId) {
+  logTest(`${toolId}: variants.json file exists`);
+  const variantsPath = path.join(packagesDir, toolId, 'variants.json');
+
+  try {
+    assert(fs.existsSync(variantsPath), `File not found: ${variantsPath}`);
+    logPass(`File exists at ${variantsPath}`);
+    return variantsPath;
+  } catch (error) {
+    logFail(`File does not exist`, error.message);
+    return null;
+  }
+}
+
+function testJSONParsing(toolId, variantsPath) {
+  logTest(`${toolId}: JSON parsing`);
+
+  try {
+    const content = fs.readFileSync(variantsPath, 'utf8');
+    const data = JSON.parse(content);
+    assert(typeof data === 'object' && data !== null, 'Parsed data is not an object');
+    logPass(`Valid JSON parsed successfully`);
+    return data;
+  } catch (error) {
+    logFail(`JSON parsing failed`, error.message);
+    return null;
+  }
+}
+
+function testRequiredVariants(toolId, data) {
+  logTest(`${toolId}: Required variants exist (lite, standard, pro)`);
+
+  let allVariantsExist = true;
+  for (const variant of requiredVariants) {
+    if (!data[variant]) {
+      logFail(`Missing variant: ${variant}`, `Variant "${variant}" not found in variants.json`);
+      allVariantsExist = false;
+    }
+  }
+
+  if (allVariantsExist) {
+    logPass(`All required variants present: ${requiredVariants.join(', ')}`);
+  }
+
+  return allVariantsExist;
+}
+
+function testVariantStructure(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Structure validation`);
+
+  let allFieldsValid = true;
+
+  // Test required fields
+  for (const field of requiredFields) {
+    if (!variantData.hasOwnProperty(field)) {
+      logFail(`Missing field: ${field}`, `Field "${field}" not found in ${variantName} variant`);
+      allFieldsValid = false;
+    }
+  }
+
+  if (allFieldsValid) {
+    logPass(`All required fields present: ${requiredFields.join(', ')}`);
+  }
+
+  return allFieldsValid;
+}
+
+function testMetadataFields(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Metadata fields`);
+
+  const metadataFields = ['name', 'description', 'useCase', 'targetUsers'];
+  let allMetadataValid = true;
+
+  for (const field of metadataFields) {
+    if (typeof variantData[field] !== 'string' || variantData[field].trim() === '') {
+      logFail(`Invalid ${field}`, `Field "${field}" must be a non-empty string`);
+      allMetadataValid = false;
+    }
+  }
+
+  if (allMetadataValid) {
+    logPass(`All metadata fields are non-empty strings`);
+    logInfo(`Name: "${variantData.name}"`);
+    logInfo(`Description: "${variantData.description.substring(0, 60)}..."`);
+  }
+
+  return allMetadataValid;
+}
+
+function testSelectionPatterns(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Selection patterns`);
+
+  let allPatternsValid = true;
+
+  for (const category of expectedCategories) {
+    const value = variantData[category];
+
+    // Must be either "*" (wildcard), array, or empty string
+    if (value === '*') {
+      logInfo(`${category}: wildcard "*" (select all)`);
+    } else if (Array.isArray(value)) {
+      if (value.length === 0) {
+        logInfo(`${category}: empty array [] (select none)`);
+      } else {
+        logInfo(`${category}: specific selection [${value.length} items]`);
+        // Validate all items are strings
+        const invalidItems = value.filter(item => typeof item !== 'string');
+        if (invalidItems.length > 0) {
+          logFail(`Invalid items in ${category}`, `Array contains non-string items: ${invalidItems.join(', ')}`);
+          allPatternsValid = false;
+        }
+      }
+    } else {
+      logFail(`Invalid pattern in ${category}`, `Must be "*", array, or empty string. Got: ${typeof value}`);
+      allPatternsValid = false;
+    }
+  }
+
+  if (allPatternsValid) {
+    logPass(`All selection patterns are valid`);
+  }
+
+  return allPatternsValid;
+}
+
+function testWildcardExpansion(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Wildcard expansion logic`);
+
+  // Simulate wildcard expansion
+  const wildcardCategories = expectedCategories.filter(cat => variantData[cat] === '*');
+
+  if (wildcardCategories.length === 0) {
+    logInfo(`No wildcards in this variant`);
+    passedTests++;
+    totalTests++;
+    return true;
+  }
+
+  logInfo(`Wildcards found in: ${wildcardCategories.join(', ')}`);
+
+  // In real implementation, wildcard "*" should expand to all available files
+  // For this test, we just verify the pattern is recognized
+  for (const category of wildcardCategories) {
+    const categoryPath = path.join(packagesDir, toolId, category);
+    if (fs.existsSync(categoryPath)) {
+      const files = fs.readdirSync(categoryPath);
+      logInfo(`  ${category}: would expand to ${files.length} items`);
+    } else {
+      logWarning(`  ${category}: directory not found (${categoryPath})`);
+    }
+  }
+
+  logPass(`Wildcard expansion logic verified`);
+  return true;
+}
+
+function testSpecificSelection(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Specific selection logic`);
+
+  // Find categories with specific selections (arrays with items)
+  const specificCategories = expectedCategories.filter(cat =>
+    Array.isArray(variantData[cat]) && variantData[cat].length > 0
+  );
+
+  if (specificCategories.length === 0) {
+    logInfo(`No specific selections in this variant`);
+    passedTests++;
+    totalTests++;
+    return true;
+  }
+
+  logInfo(`Specific selections found in: ${specificCategories.join(', ')}`);
+
+  let allSelectionsValid = true;
+
+  for (const category of specificCategories) {
+    const selectedItems = variantData[category];
+    logInfo(`  ${category}: ${selectedItems.length} items selected`);
+
+    // Check if the selected items exist (only for Claude package which has actual content)
+    if (toolId === 'claude') {
+      const categoryPath = path.join(packagesDir, toolId, category);
+      if (fs.existsSync(categoryPath)) {
+        for (const item of selectedItems) {
+          // Check if item exists as file or directory
+          const itemPath = path.join(categoryPath, item);
+          const itemPathMd = path.join(categoryPath, `${item}.md`);
+
+          if (!fs.existsSync(itemPath) && !fs.existsSync(itemPathMd)) {
+            logWarning(`    Item not found: ${item}`);
+          } else {
+            logInfo(`    ✓ ${item}`);
+          }
+        }
+      }
+    } else {
+      // For other tools, just list the items
+      selectedItems.forEach(item => logInfo(`    - ${item}`));
+    }
+  }
+
+  if (allSelectionsValid) {
+    logPass(`Specific selection logic verified`);
+  }
+
+  return allSelectionsValid;
+}
+
+function testEmptySelection(toolId, variantName, variantData) {
+  logTest(`${toolId}: ${variantName} - Empty selection logic`);
+
+  // Find categories with empty selections
+  const emptyCategories = expectedCategories.filter(cat =>
+    Array.isArray(variantData[cat]) && variantData[cat].length === 0
+  );
+
+  if (emptyCategories.length === 0) {
+    logInfo(`No empty selections in this variant`);
+    passedTests++;
+    totalTests++;
+    return true;
+  }
+
+  logInfo(`Empty selections found in: ${emptyCategories.join(', ')}`);
+
+  // Empty selection means nothing should be installed from that category
+  for (const category of emptyCategories) {
+    logInfo(`  ${category}: no items will be installed`);
+  }
+
+  logPass(`Empty selection logic verified`);
+  return true;
+}
+
+function testVariantConsistency(toolId, data) {
+  logTest(`${toolId}: Variant consistency checks`);
+
+  let allConsistent = true;
+
+  // Lite should have fewer selections than Standard, Standard fewer than Pro
+  const liteAgents = data.lite.agents;
+  const standardAgents = data.standard.agents;
+  const proAgents = data.pro.agents;
+
+  const liteSkills = data.lite.skills;
+  const standardSkills = data.standard.skills;
+  const proSkills = data.pro.skills;
+
+  // Check agents progression
+  if (Array.isArray(liteAgents) && liteAgents.length > 0) {
+    if (standardAgents !== '*' && Array.isArray(standardAgents)) {
+      if (standardAgents.length < liteAgents.length) {
+        logWarning(`Standard has fewer agents than Lite`);
+      }
+    }
+  }
+
+  // Check skills progression: Lite < Standard < Pro
+  if (Array.isArray(liteSkills) && liteSkills.length === 0) {
+    logInfo(`Lite: 0 skills (as expected)`);
+  }
+
+  if (Array.isArray(standardSkills) && standardSkills.length > 0) {
+    logInfo(`Standard: ${standardSkills.length} skills`);
+  }
+
+  if (proSkills === '*') {
+    logInfo(`Pro: all skills (wildcard)`);
+  }
+
+  logPass(`Variant consistency verified`);
+  return allConsistent;
+}
+
+/**
+ * Main test runner
+ */
+function runTestsForTool(toolId) {
+  logSection(`Testing ${toolId.toUpperCase()}`);
+
+  // Test 1: File exists
+  const variantsPath = testFileExists(toolId);
+  if (!variantsPath) {
+    logWarning(`Skipping remaining tests for ${toolId} due to missing file`);
+    return;
+  }
+
+  // Test 2: JSON parsing
+  const data = testJSONParsing(toolId, variantsPath);
+  if (!data) {
+    logWarning(`Skipping remaining tests for ${toolId} due to parsing failure`);
+    return;
+  }
+
+  // Test 3: Required variants exist
+  const hasAllVariants = testRequiredVariants(toolId, data);
+  if (!hasAllVariants) {
+    logWarning(`Some variants missing for ${toolId}`);
+  }
+
+  // Test each variant
+  for (const variantName of requiredVariants) {
+    if (!data[variantName]) continue;
+
+    console.log(`\n${colors.yellow}--- Variant: ${variantName.toUpperCase()} ---${colors.reset}`);
+
+    const variantData = data[variantName];
+
+    // Test 4: Structure validation
+    testVariantStructure(toolId, variantName, variantData);
+
+    // Test 5: Metadata fields
+    testMetadataFields(toolId, variantName, variantData);
+
+    // Test 6: Selection patterns
+    testSelectionPatterns(toolId, variantName, variantData);
+
+    // Test 7: Wildcard expansion
+    testWildcardExpansion(toolId, variantName, variantData);
+
+    // Test 8: Specific selection
+    testSpecificSelection(toolId, variantName, variantData);
+
+    // Test 9: Empty selection
+    testEmptySelection(toolId, variantName, variantData);
+  }
+
+  // Test 10: Variant consistency
+  console.log('');
+  testVariantConsistency(toolId, data);
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  console.log(`${colors.cyan}
+╔════════════════════════════════════════════════════════════════════╗
+║                                                                    ║
+║   Variants.json Parsing Test Suite                                ║
+║   Testing all 4 tools × 3 variants = 12 configurations            ║
+║                                                                    ║
+╚════════════════════════════════════════════════════════════════════╝
+${colors.reset}`);
+
+  console.log(`Project root: ${projectRoot}`);
+  console.log(`Packages directory: ${packagesDir}`);
+
+  // Run tests for all tools
+  for (const toolId of tools) {
+    runTestsForTool(toolId);
+  }
+
+  // Summary
+  logSection('TEST SUMMARY');
+
+  console.log(`Total tests: ${totalTests}`);
+  console.log(`${colors.green}Passed: ${passedTests}${colors.reset}`);
+  console.log(`${colors.red}Failed: ${failedTests}${colors.reset}`);
+
+  if (failedTests > 0) {
+    console.log(`\n${colors.red}FAILED TESTS:${colors.reset}`);
+    failures.forEach((failure, index) => {
+      console.log(`\n${index + 1}. ${failure.test}`);
+      console.log(`   ${colors.red}${failure.error}${colors.reset}`);
+    });
+  }
+
+  console.log(`\n${colors.cyan}${'='.repeat(70)}${colors.reset}\n`);
+
+  if (failedTests === 0) {
+    console.log(`${colors.green}✓ All tests passed!${colors.reset}\n`);
+    process.exit(0);
+  } else {
+    console.log(`${colors.red}✗ Some tests failed. See details above.${colors.reset}\n`);
+    process.exit(1);
+  }
+}
+
+// Run tests
+main();

package/tests/tmp/test-cli-install-1762170060156/claude-lite-test/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/claude-lite-test/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/claude-lite-test/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.