@amrhas82/agentic-kit 1.2.0 → 1.2.1

package/tests/test-variants-parsing.js

@@ -1,475 +0,0 @@
-#!/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

@@ -1,55 +0,0 @@
----
-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

@@ -1,103 +0,0 @@
----
-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

@@ -1,64 +0,0 @@
----
-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.