awesome-slash 2.4.4 → 2.5.0

package/plugins/next-task/agents/task-discoverer.md

@@ -1,12 +1,14 @@
 ---
 name: task-discoverer
-description: Discover and prioritize tasks from configured sources. Use this agent after policy selection to find the next task to work on.
-tools: Bash(gh:*), Bash(git:*), Grep, Read
-model: inherit
+description: Discover and prioritize tasks from configured sources. CRITICAL - You MUST use AskUserQuestion tool to present task selection as checkboxes. This agent is invoked after policy selection to find, score, and let the user select the next task to work on via structured checkbox UI.
+tools: Bash(gh:*), Bash(glab:*), Bash(git:*), Grep, Read, AskUserQuestion
+model: sonnet
 ---
 
 # Task Discoverer Agent
 
+**CRITICAL REQUIREMENT**: You MUST use the AskUserQuestion tool to present task selection as checkboxes to the user. Do NOT present tasks as plain text or ask the user to type a number. The AskUserQuestion tool creates a structured checkbox UI that is required for this agent to function correctly.
+
 You discover tasks from configured sources, validate them against the codebase,
 and present prioritized recommendations to the user.
 
@@ -51,35 +53,93 @@ if (claimedTasks.length > 0) {
 
 ## Phase 3: Fetch Tasks by Source
 
+The source configuration comes from policy. It can be:
+- `"github"` or `"gh-issues"` - Use GitHub CLI
+- `"gitlab"` - Use GitLab CLI
+- `"local"` or `"tasks-md"` - Read local markdown files
+- `{ source: "custom", type: "cli", tool: "tea" }` - Custom CLI tool
+- `{ source: "other", description: "..." }` - Agent interprets description
+
+### Parse Source Configuration
+
+```javascript
+const { sources } = require('${CLAUDE_PLUGIN_ROOT}/lib');
+
+// Source can be string or object
+const sourceConfig = typeof policy.taskSource === 'string'
+  ? { source: policy.taskSource }
+  : policy.taskSource;
+
+const sourceType = sourceConfig.source || sourceConfig;
+```
+
 ### GitHub Issues
 
+**IMPORTANT**: GitHub CLI defaults to 30 issues. For repos with many issues, use `--limit`
+and consider filtering by label to reduce noise. If you hit the limit, iterate with
+pagination or apply stricter label filters.
+
 ```bash
-if [ "$TASK_SOURCE" = "gh-issues" ]; then
-  gh issue list --state open \
-    --json number,title,body,labels,assignees,createdAt,url \
-    --limit 100 > /tmp/gh-issues.json
+if [ "$SOURCE_TYPE" = "github" ] || [ "$SOURCE_TYPE" = "gh-issues" ]; then
+  # First, get total count to check if pagination needed
+  TOTAL_OPEN=$(gh issue list --state open --json number --jq 'length')
+  echo "Total open issues: $TOTAL_OPEN"
+
+  # If many issues exist, filter by priority labels first
+  if [ "$TOTAL_OPEN" -gt 100 ]; then
+    echo "Large backlog detected. Fetching high-priority issues first..."
+
+    # Fetch by priority labels (adjust labels to match repo conventions)
+    gh issue list --state open \
+      --label "priority:high,priority:critical,bug,security" \
+      --json number,title,body,labels,assignees,createdAt,url \
+      --limit 100 > /tmp/gh-issues.json
+
+    ISSUE_COUNT=$(cat /tmp/gh-issues.json | jq length)
+
+    # If still not enough, fetch more without label filter
+    if [ "$ISSUE_COUNT" -lt 20 ]; then
+      echo "Few priority issues found. Fetching recent issues..."
+      gh issue list --state open \
+        --json number,title,body,labels,assignees,createdAt,url \
+        --limit 100 > /tmp/gh-issues.json
+      ISSUE_COUNT=$(cat /tmp/gh-issues.json | jq length)
+    fi
+  else
+    # Small backlog - fetch all
+    gh issue list --state open \
+      --json number,title,body,labels,assignees,createdAt,url \
+      --limit 100 > /tmp/gh-issues.json
+    ISSUE_COUNT=$(cat /tmp/gh-issues.json | jq length)
+  fi
 
-  ISSUE_COUNT=$(cat /tmp/gh-issues.json | jq length)
   echo "Fetched $ISSUE_COUNT issues from GitHub"
+
+  # Warn if at limit
+  if [ "$ISSUE_COUNT" -eq 100 ]; then
+    echo "WARNING: Hit 100 issue limit. Some issues may not be included."
+    echo "Consider using priority filter to narrow scope."
+  fi
 fi
 ```
 
-### Linear (via GitHub links)
+### GitLab Issues
 
 ```bash
-if [ "$TASK_SOURCE" = "linear" ]; then
-  # Extract Linear IDs from GitHub issue bodies
-  gh issue list --state open --json body,number,title --limit 50 | \
-    jq -r '.[] | select(.body | contains("linear.app")) |
-           {number, title, linearUrl: (.body | capture("https://linear.app/[^\\s]+") | .linearUrl)}' \
-    > /tmp/linear-tasks.json
+if [ "$SOURCE_TYPE" = "gitlab" ]; then
+  glab issue list --state opened \
+    --output json \
+    --per-page 100 > /tmp/glab-issues.json
+
+  ISSUE_COUNT=$(cat /tmp/glab-issues.json | jq length)
+  echo "Fetched $ISSUE_COUNT issues from GitLab"
 fi
 ```
 
-### PLAN.md / tasks.md
+### Local tasks.md
 
 ```bash
-if [ "$TASK_SOURCE" = "tasks-md" ]; then
+if [ "$SOURCE_TYPE" = "local" ] || [ "$SOURCE_TYPE" = "tasks-md" ]; then
   # Find task files
   TASK_FILE=""
   for f in PLAN.md tasks.md TODO.md; do
@@ -98,6 +158,85 @@ if [ "$TASK_SOURCE" = "tasks-md" ]; then
 fi
 ```
 
+### Custom Source (CLI/MCP/Skill)
+
+For custom sources, use cached tool capabilities:
+
+```javascript
+if (sourceConfig.source === 'custom') {
+  const toolName = sourceConfig.tool;
+  const toolType = sourceConfig.type;
+
+  // Load cached capabilities
+  let capabilities = sources.getToolCapabilities(toolName);
+
+  // If not cached, probe the tool
+  if (!capabilities && toolType === 'cli') {
+    capabilities = sources.probeCLI(toolName);
+    if (capabilities.available) {
+      sources.saveToolCapabilities(toolName, capabilities);
+    }
+  }
+
+  if (capabilities?.commands?.list_issues) {
+    // Execute the list_issues command
+    const cmd = capabilities.commands.list_issues;
+    console.log(`Executing: ${cmd}`);
+    // Run command and parse output
+  } else if (toolType === 'mcp') {
+    // Call MCP tool
+    console.log(`Calling MCP server: ${toolName}`);
+    // MCP call logic
+  } else if (toolType === 'skill') {
+    // Invoke skill
+    console.log(`Invoking skill: ${toolName}`);
+    // Skill invocation logic
+  } else {
+    console.log(`Unknown custom source type: ${toolType}`);
+    console.log(`Tool: ${toolName}`);
+    console.log(`Attempting generic help: ${toolName} --help`);
+  }
+}
+```
+
+### Other Source (Agent Interprets)
+
+For "other" sources, the agent interprets the user's description:
+
+```javascript
+if (sourceConfig.source === 'other') {
+  const description = sourceConfig.description;
+
+  console.log(`User described task source: ${description}`);
+  console.log('');
+  console.log('Interpreting description to find tasks...');
+
+  // Agent uses reasoning to figure out how to list tasks
+  // Common patterns to try:
+  // - "Jira" → check for jira CLI or MCP
+  // - "Linear" → check for linear CLI or MCP
+  // - "Notion" → check for notion MCP
+  // - "file at /path" → read that file
+  // - "backlog.md" → read that file
+
+  // If can't figure it out, ask user for clarification
+  if (!tasksFound) {
+    AskUserQuestion({
+      questions: [{
+        header: 'Clarify Source',
+        question: `I couldn't automatically find tasks from "${description}". How should I access them?`,
+        options: [
+          { label: 'CLI Command', description: 'Provide a command to list tasks' },
+          { label: 'File Path', description: 'Provide path to task file' },
+          { label: 'MCP Server', description: 'Specify MCP server name' }
+        ],
+        multiSelect: false
+      }]
+    });
+  }
+}
+```
+
 ## Phase 4: Exclude Claimed Tasks
 
 Remove tasks that are already claimed by other workflows:
@@ -249,6 +388,8 @@ Select a task (1-5) or provide a custom task:
 
 ## Phase 9: User Selection via AskUserQuestion
 
+**CRITICAL**: You MUST use AskUserQuestion here - do NOT present tasks as text and ask for typed input.
+
 ```javascript
 AskUserQuestion({
   questions: [
@@ -348,10 +489,10 @@ fi
 - State updated with task details
 - Phase advanced to worktree-setup
 
-## Model Choice: Inherit
+## Model Choice: Sonnet
 
-This agent uses **inherit** because:
-- Complexity varies by calling context
-- When called from orchestrator (sonnet), inherits sonnet
-- Simple task fetching doesn't need opus
-- Allows flexibility without over-specifying
+This agent uses **sonnet** because:
+- Needs reasoning for "other" source interpretation
+- Custom source handling requires some intelligence
+- Simple enough that opus would be overkill
+- Fast response for interactive task selection

package/plugins/next-task/commands/next-task.md

@@ -8,6 +8,20 @@ allowed-tools: Bash(git:*), Bash(gh:*), Bash(npm:*), Bash(node:*), Read, Write,
 
 Discover what to work on next and execute the complete implementation workflow.
 
+## Default Behavior (No Arguments)
+
+**When you run `/next-task` with NO arguments**:
+1. Goes to Phase 1: Policy Selection
+2. Policy selector checks for existing tasks in `.claude/tasks.json`
+3. If existing tasks found, **ASKS USER** what to do:
+   - Start new task (recommended - leaves existing task untouched)
+   - Resume existing task
+   - Abort existing task
+   - View status only
+4. Then continues with normal policy configuration
+
+**CRITICAL**: The workflow NEVER auto-resumes existing tasks. It ALWAYS asks first.
+
 ## Workflow Overview
 
 ```
@@ -190,12 +204,55 @@ Parse from $ARGUMENTS:
 ╚══════════════════════════════════════════════════════════════════════════╝
 ```
 
+## ⛔ CRITICAL: NO AUTO-RESUME GATE
+
+```
+╔══════════════════════════════════════════════════════════════════════════╗
+║                         ⛔ NO AUTO-RESUME ⛔                              ║
+╠══════════════════════════════════════════════════════════════════════════╣
+║                                                                          ║
+║  MANDATORY RULE: DO NOT automatically resume existing tasks/worktrees   ║
+║                                                                          ║
+║  ✅ CORRECT BEHAVIOR:                                                    ║
+║  - No arguments → Go to Phase 1 (Policy Selection)                      ║
+║  - Policy selector WILL ask about existing tasks                         ║
+║  - User explicitly chooses: resume, start fresh, or view status          ║
+║                                                                          ║
+║  ❌ INCORRECT BEHAVIOR (NEVER DO THIS):                                 ║
+║  - Seeing .claude/tasks.json with existing task → Auto-resume it        ║
+║  - Finding a worktree → Auto-resume it                                  ║
+║  - Detecting "in_progress" status → Auto-resume it                      ║
+║  - Assuming "user wants to continue" → Auto-resume it                   ║
+║                                                                          ║
+║  THE ONLY VALID WAYS TO RESUME:                                         ║
+║  1. User explicitly passes --resume flag                                ║
+║  2. Policy selector asks and user chooses "Resume"                      ║
+║                                                                          ║
+║  EXISTING TASKS ARE USUALLY NOT STALE - THEY MAY BE:                    ║
+║  - Running in another terminal/session                                  ║
+║  - Running by another agent                                             ║
+║  - Paused for user review                                               ║
+║  - Waiting for external CI/deployment                                   ║
+║                                                                          ║
+║  AUTO-RESUMING = CORRUPTING PARALLEL WORKFLOWS                          ║
+║                                                                          ║
+╚══════════════════════════════════════════════════════════════════════════╝
+```
+
 ## Pre-flight: Handle Arguments
 
 ```javascript
 const workflowState = require('${CLAUDE_PLUGIN_ROOT}/lib/state/workflow-state.js');
 const args = '$ARGUMENTS'.split(' ').filter(Boolean);
 
+// ⛔ CRITICAL CHECK: If no flags provided, DO NOT check for existing tasks here
+// That check happens in policy-selector, which will ASK the user
+if (args.length === 0 || (!args.includes('--resume') && !args.includes('--status') && !args.includes('--abort'))) {
+  console.log("No arguments provided - starting Phase 1 (Policy Selection)");
+  console.log("Policy selector will check for existing tasks and ask user what to do.");
+  // SKIP to Phase 1 below
+}
+
 // Handle --status
 if (args.includes('--status')) {
   const summary = workflowState.getWorkflowSummary();
@@ -294,31 +351,70 @@ function mapStepToPhase(step) {
 }
 ```
 
-## Phase 1: Policy Selection
+## Phase 1: Policy Selection (Direct Questions)
 
-→ **Agent**: `next-task:policy-selector` (haiku)
+No agent needed - call `sources.getPolicyQuestions()` and use AskUserQuestion.
 
 ```javascript
-workflowState.startPhase('policy-selection');
+const { sources } = require('${CLAUDE_PLUGIN_ROOT}/lib');
 
-await Task({
-  subagent_type: "next-task:policy-selector",
-  prompt: `Configure workflow via checkbox selection. Gather: task source, priority filter, stopping point.`
+// Get questions with cache-aware options (cached preference shown first if exists)
+const { questions, cachedPreference } = sources.getPolicyQuestions();
+
+// Ask all 3 questions at once
+AskUserQuestion({ questions });
+
+// After user responds, check if follow-up needed
+if (sources.needsCustomFollowUp(sourceAnswer)) {
+  // Custom: ask type (CLI/MCP/Skill/File)
+  AskUserQuestion(sources.getCustomTypeQuestions());
+
+  // Then ask for name/path
+  const typeInternal = sources.mapTypeSelection(typeAnswer);
+  AskUserQuestion(sources.getCustomNameQuestion(typeInternal));
+}
+
+if (sources.needsOtherDescription(sourceAnswer)) {
+  // Other: user types free description (via "Other" option in AskUserQuestion)
+}
+
+// Parse responses and cache preference
+const policy = sources.parseAndCachePolicy({
+  source: sourceAnswer,
+  priority: priorityAnswer,
+  stopPoint: stopPointAnswer,
+  custom: { type: typeAnswer, name: nameAnswer, description: otherDescription }
 });
 
-// Policy now in state
+workflowState.updateFlow({ policy, phase: 'task-discovery', status: 'in_progress' });
 ```
 
+**What the lib function handles:**
+- Reads cache from `.claude/sources/preference.json`
+- If cached, shows it as first option with "(last used)" label
+- Returns ready-to-use AskUserQuestion structure
+- `parseAndCachePolicy()` saves preference for next time
+
 ## Phase 2: Task Discovery
 
-→ **Agent**: `next-task:task-discoverer` (inherit)
+→ **Agent**: `next-task:task-discoverer` (sonnet)
+
+The task-discoverer receives the source configuration from policy and handles:
+- **github**: Uses `gh issue list`
+- **gitlab**: Uses `glab issue list`
+- **local**: Reads `tasks.md`, `PLAN.md`, or `TODO.md`
+- **custom**: Uses cached tool capabilities (e.g., `tea issues list` for Gitea)
+- **other**: Agent interprets user's description and figures out how to list tasks
 
 ```javascript
 workflowState.startPhase('task-discovery');
 
+// Pass full source config to task-discoverer
+const sourceConfig = policy.taskSource;
+
 await Task({
   subagent_type: "next-task:task-discoverer",
-  prompt: `Discover tasks from ${policy.taskSource}, filter by ${policy.priorityFilter}. Present top 5 to user for selection.`
+  prompt: `Discover tasks from source: ${JSON.stringify(sourceConfig)}. Filter by: ${policy.priorityFilter}. Present top 5 to user for selection.`
 });
 
 // Selected task now in state.task
@@ -362,20 +458,90 @@ await Task({
 ```javascript
 workflowState.startPhase('planning');
 
-await Task({
+const planOutput = await Task({
   subagent_type: "next-task:planning-agent",
   model: "opus",
-  prompt: `Design implementation plan for task #${state.task.id}. Enter plan mode for user approval.`
+  prompt: `Design implementation plan for task #${state.task.id}. Output structured JSON plan between === PLAN_START === and === PLAN_END === markers.`
 });
 
-// Agent uses EnterPlanMode → user approves → ExitPlanMode
+// Parse the plan from agent output
+const planMatch = planOutput.match(/=== PLAN_START ===([\s\S]*?)=== PLAN_END ===/);
+if (!planMatch) {
+  console.error("ERROR: Planning agent did not output structured plan");
+  return;
+}
+
+const plan = JSON.parse(planMatch[1].trim());
+console.log(`✓ Plan received: ${plan.steps.length} steps, ${plan.complexity.overall} complexity`);
 ```
 
-## Phase 6: User Approval
+## Phase 6: User Approval (Plan Mode)
 
-Planning agent handles this via EnterPlanMode/ExitPlanMode.
 **This is the LAST human interaction point.**
 
+The orchestrator enters plan mode and presents the structured plan:
+
+```javascript
+// Convert plan to markdown for presentation
+const planMarkdown = `# Implementation Plan: ${plan.task.title}
+
+## Overview
+${plan.overview}
+
+## Architecture Decision
+${plan.architecture}
+
+${plan.steps.map((step, i) => `
+## Step ${i + 1}: ${step.title}
+
+**Goal**: ${step.goal}
+
+**Files to modify**:
+${step.files.map(f => `- \`${f.path}\` - ${f.changes}`).join('\n')}
+
+**Implementation**:
+${step.details.map(d => `- ${d}`).join('\n')}
+
+${step.risks?.length ? `**Risks**: ${step.risks.join(', ')}` : ''}
+`).join('\n')}
+
+## Critical Paths
+
+**High Risk**: ${plan.critical.highRisk.join(', ') || 'None'}
+**Needs Review**: ${plan.critical.needsReview.join(', ') || 'None'}
+${plan.critical.performance?.length ? `**Performance**: ${plan.critical.performance.join(', ')}` : ''}
+${plan.critical.security?.length ? `**Security**: ${plan.critical.security.join(', ')}` : ''}
+
+## Complexity Assessment
+
+**Overall**: ${plan.complexity.overall}
+**Confidence**: ${plan.complexity.confidence}
+**Reasoning**: ${plan.complexity.reasoning}
+`;
+
+console.log("✓ Entering plan mode for user approval...");
+
+// Enter plan mode with the formatted plan
+EnterPlanMode();
+
+// When we reach here, user has approved via ExitPlanMode
+console.log("✓ Plan approved by user");
+console.log("✓ Proceeding to implementation...");
+
+// Save approved plan to state
+workflowState.completePhase({
+  planApproved: true,
+  plan: plan,
+  approvedAt: new Date().toISOString()
+});
+```
+
+**What happens in plan mode**:
+1. User sees the formatted plan
+2. User reviews and can request changes
+3. User approves via ExitPlanMode
+4. Control returns here to Phase 7 (Implementation)
+
 ## Phase 7: Implementation
 
 → **Agent**: `next-task:implementation-agent` (opus)

package/plugins/next-task/lib/index.js

@@ -0,0 +1,170 @@
+/**
+ * Awesome-Slash Core Library
+ *
+ * Unified entry point for all core library modules.
+ * Provides platform detection, pattern matching, workflow state management,
+ * configuration management, and context optimization utilities.
+ *
+ * @module awesome-slash/lib
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const detectPlatform = require('./platform/detect-platform');
+const verifyTools = require('./platform/verify-tools');
+const reviewPatterns = require('./patterns/review-patterns');
+const slopPatterns = require('./patterns/slop-patterns');
+const workflowState = require('./state/workflow-state');
+const contextOptimizer = require('./utils/context-optimizer');
+const shellEscape = require('./utils/shell-escape');
+const config = require('./config');
+const sourceCache = require('./sources/source-cache');
+const customHandler = require('./sources/custom-handler');
+const policyQuestions = require('./sources/policy-questions');
+
+/**
+ * Platform detection and verification utilities
+ */
+const platform = {
+  /**
+   * Detect project platform configuration
+   * @see module:platform/detect-platform
+   */
+  detect: detectPlatform.detect,
+  detectAsync: detectPlatform.detectAsync,
+  detectCI: detectPlatform.detectCI,
+  detectDeployment: detectPlatform.detectDeployment,
+  detectProjectType: detectPlatform.detectProjectType,
+  detectPackageManager: detectPlatform.detectPackageManager,
+  detectBranchStrategy: detectPlatform.detectBranchStrategy,
+  detectMainBranch: detectPlatform.detectMainBranch,
+  invalidateCache: detectPlatform.invalidateCache,
+
+  /**
+   * Verify tool availability
+   * @see module:platform/verify-tools
+   */
+  verifyTools: verifyTools.verify,
+  verifyToolsAsync: verifyTools.verifyAsync,
+  checkTool: verifyTools.checkTool,
+  checkToolAsync: verifyTools.checkToolAsync,
+  TOOL_DEFINITIONS: verifyTools.TOOL_DEFINITIONS
+};
+
+/**
+ * Code pattern matching utilities
+ */
+const patterns = {
+  /**
+   * Review patterns for code quality analysis
+   * @see module:patterns/review-patterns
+   */
+  review: reviewPatterns,
+
+  /**
+   * Slop patterns for AI-generated code detection
+   * @see module:patterns/slop-patterns
+   */
+  slop: slopPatterns
+};
+
+/**
+ * Workflow state management
+ * @see module:state/workflow-state
+ */
+const state = {
+  // Constants
+  SCHEMA_VERSION: workflowState.SCHEMA_VERSION,
+  PHASES: workflowState.PHASES,
+  DEFAULT_POLICY: workflowState.DEFAULT_POLICY,
+
+  // Core functions
+  generateWorkflowId: workflowState.generateWorkflowId,
+  getStatePath: workflowState.getStatePath,
+  ensureStateDir: workflowState.ensureStateDir,
+  validateStateSchema: workflowState.validateStateSchema,
+
+  // CRUD operations
+  createState: workflowState.createState,
+  readState: workflowState.readState,
+  writeState: workflowState.writeState,
+  updateState: workflowState.updateState,
+  deleteState: workflowState.deleteState,
+
+  // Phase management
+  startPhase: workflowState.startPhase,
+  completePhase: workflowState.completePhase,
+  failPhase: workflowState.failPhase,
+  skipToPhase: workflowState.skipToPhase,
+
+  // Workflow lifecycle
+  completeWorkflow: workflowState.completeWorkflow,
+  abortWorkflow: workflowState.abortWorkflow,
+  hasActiveWorkflow: workflowState.hasActiveWorkflow,
+  getWorkflowSummary: workflowState.getWorkflowSummary,
+
+  // Agent management
+  updateAgentResult: workflowState.updateAgentResult,
+  incrementIteration: workflowState.incrementIteration
+};
+
+/**
+ * Git command optimization and string escaping utilities
+ * @see module:utils/context-optimizer
+ * @see module:utils/shell-escape
+ */
+const utils = {
+  contextOptimizer,
+  shellEscape
+};
+
+/**
+ * Task source management
+ * @see module:sources/source-cache
+ * @see module:sources/custom-handler
+ * @see module:sources/policy-questions
+ */
+const sources = {
+  // Main entry point - returns ready-to-use question structure
+  getPolicyQuestions: policyQuestions.getPolicyQuestions,
+  getCustomTypeQuestions: policyQuestions.getCustomTypeQuestions,
+  getCustomNameQuestion: policyQuestions.getCustomNameQuestion,
+  parseAndCachePolicy: policyQuestions.parseAndCachePolicy,
+  isUsingCached: policyQuestions.isUsingCached,
+  needsCustomFollowUp: policyQuestions.needsCustomFollowUp,
+  needsOtherDescription: policyQuestions.needsOtherDescription,
+
+  // Cache operations (direct access if needed)
+  getPreference: sourceCache.getPreference,
+  savePreference: sourceCache.savePreference,
+  getToolCapabilities: sourceCache.getToolCapabilities,
+  saveToolCapabilities: sourceCache.saveToolCapabilities,
+  clearCache: sourceCache.clearCache,
+
+  // Custom source handling (direct access if needed)
+  SOURCE_TYPES: customHandler.SOURCE_TYPES,
+  probeCLI: customHandler.probeCLI,
+  buildCustomConfig: customHandler.buildCustomConfig
+};
+
+// Main exports
+module.exports = {
+  platform,
+  patterns,
+  state,
+  utils,
+  config,
+  sources,
+
+  // Direct module access for backward compatibility
+  detectPlatform,
+  verifyTools,
+  reviewPatterns,
+  slopPatterns,
+  workflowState,
+  contextOptimizer,
+  shellEscape,
+  sourceCache,
+  customHandler,
+  policyQuestions
+};