claude-flow-novice 2.15.7 → 2.15.9

package/claude-assets/skills/cfn-loop-orchestration/helpers/iteration-manager-ts.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Iteration Manager (TypeScript Wrapper)
+# Prepares next iteration and generates wake signals
+#
+# Usage:
+#   iteration-manager-ts.sh --current-iteration <n> \
+#                           --agents <agent1,agent2,...> \
+#                           [--feedback <json>]
+#
+# Returns:
+#   Next iteration metadata (JSON)
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+CURRENT_ITERATION=""
+AGENTS=""
+FEEDBACK="{}"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --current-iteration) CURRENT_ITERATION="$2"; shift 2 ;;
+    --agents) AGENTS="$2"; shift 2 ;;
+    --feedback) FEEDBACK="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$CURRENT_ITERATION" ] || [ -z "$AGENTS" ]; then
+  echo "Error: Missing required parameters" >&2
+  exit 1
+fi
+
+# Convert comma-separated agents to JSON array
+IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
+AGENTS_JSON="["
+for i in "${!AGENT_ARRAY[@]}"; do
+  if [ $i -gt 0 ]; then
+    AGENTS_JSON+=","
+  fi
+  AGENTS_JSON+="\"${AGENT_ARRAY[$i]}\""
+done
+AGENTS_JSON+="]"
+
+# Build TypeScript invocation
+TS_CODE="
+import { prepareIteration, wakeAgents } from './iteration-manager';
+
+const iteration = prepareIteration({
+  currentIteration: $CURRENT_ITERATION,
+  feedback: $FEEDBACK
+});
+
+console.log('Iteration Preparation:');
+console.log(\`  Next Iteration: \${iteration.nextIteration}\`);
+console.log(\`  Timestamp: \${iteration.timestamp}\`);
+console.log();
+
+const agentIds = $AGENTS_JSON;
+const wake = wakeAgents(agentIds);
+
+console.log('Wake Signals Generated:');
+wake.signals.forEach((signal, idx) => {
+  console.log(\`  [\${idx + 1}] \${signal}\`);
+});
+console.log();
+console.log(\`✅ Prepared iteration \${iteration.nextIteration} for \${agentIds.length} agents\`);
+
+// Output JSON for programmatic consumption
+console.log();
+console.log('JSON_OUTPUT:', JSON.stringify({
+  nextIteration: iteration.nextIteration,
+  timestamp: iteration.timestamp,
+  signals: wake.signals
+}));
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/claude-assets/skills/cfn-loop-orchestration/helpers/timeout-calculator-ts.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Timeout Calculator (TypeScript Wrapper)
+# Calculates mode and phase-specific timeouts for agent execution
+#
+# Usage:
+#   timeout-calculator-ts.sh --mode <mvp|standard|enterprise> [--phase <phase-id>]
+#
+# Returns:
+#   Timeout value in seconds (stdout)
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+MODE="standard"
+PHASE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --mode) MODE="$2"; shift 2 ;;
+    --phase) PHASE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Build TypeScript invocation
+TS_CODE="
+import { calculateTimeout } from './timeout-calculator';
+
+const timeout = calculateTimeout({
+  mode: '$MODE',
+  ${PHASE:+phase: '$PHASE'}
+});
+
+console.log(timeout);
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/consensus.ts

@@ -0,0 +1,87 @@
+/**
+ * Consensus Collection and Validation
+ * Collects Loop 2 validator scores and validates against thresholds
+ */
+
+export interface ConsensusResult {
+  scores: number[];
+  average: number;
+  count: number;
+  min: number;
+  max: number;
+}
+
+export interface ConsensusValidation {
+  passed: boolean;
+  average: number;
+  threshold: number;
+  mode: string;
+  gap: number;
+}
+
+export type Mode = 'mvp' | 'standard' | 'enterprise';
+
+const MODE_THRESHOLDS: Record<Mode, number> = {
+  mvp: 0.80,
+  standard: 0.90,
+  enterprise: 0.95
+};
+
+/**
+ * Collects consensus scores from multiple validators
+ * @param scores Array of validator confidence scores (0.0-1.0)
+ * @returns ConsensusResult with statistics
+ */
+export function collectConsensus(scores: number[]): ConsensusResult {
+  if (!scores || scores.length === 0) {
+    throw new Error('No consensus scores provided');
+  }
+
+  // Validate all scores are in valid range
+  for (const score of scores) {
+    if (score < 0 || score > 1.0) {
+      throw new Error(`Invalid consensus score: ${score} (must be 0.0-1.0)`);
+    }
+  }
+
+  // Calculate statistics
+  const sum = scores.reduce((acc, score) => acc + score, 0);
+  const average = sum / scores.length;
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+
+  return {
+    scores,
+    average,
+    count: scores.length,
+    min,
+    max
+  };
+}
+
+/**
+ * Validates consensus against mode-specific threshold
+ * @param params Validation parameters
+ * @returns ConsensusValidation result
+ */
+export function validateConsensus(params: {
+  average: number;
+  threshold?: number;
+  mode: Mode | string;
+}): ConsensusValidation {
+  // Use explicit threshold if provided, otherwise use mode default
+  const threshold = params.threshold !== undefined
+    ? params.threshold
+    : MODE_THRESHOLDS[params.mode as Mode] || 0.90;
+
+  const passed = params.average >= threshold;
+  const gap = params.average - threshold;
+
+  return {
+    passed,
+    average: params.average,
+    threshold,
+    mode: params.mode,
+    gap
+  };
+}

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/deliverable-verifier.ts

@@ -0,0 +1,103 @@
+/**
+ * Deliverable Verifier
+ * Verifies expected deliverables exist (prevents "consensus on vapor")
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export interface VerificationResult {
+  verified: boolean;
+  files: string[];
+  missing: string[];
+  found: string[];
+  typeErrors?: string[];
+  gitChanges?: number;
+  requiresChanges?: boolean;
+  reason?: string;
+}
+
+const IMPLEMENTATION_KEYWORDS = [
+  'create', 'build', 'implement', 'add', 'generate'
+];
+
+/**
+ * Verifies expected deliverables exist
+ * @param params Verification parameters
+ * @returns VerificationResult with detailed verification status
+ */
+export function verifyDeliverables(params: {
+  files: string[];
+  expectedTypes?: string[];
+  requireGitChanges?: boolean;
+  taskType?: string;
+}): VerificationResult {
+  const found: string[] = [];
+  const missing: string[] = [];
+  const typeErrors: string[] = [];
+
+  // Check each file
+  for (const file of params.files) {
+    if (fs.existsSync(file)) {
+      found.push(file);
+
+      // Type validation if expected types specified
+      if (params.expectedTypes && params.expectedTypes.length > 0) {
+        const ext = path.extname(file);
+        if (!params.expectedTypes.includes(ext)) {
+          typeErrors.push(file);
+        }
+      }
+    } else {
+      missing.push(file);
+    }
+  }
+
+  // Git change detection
+  let gitChanges = 0;
+  if (params.requireGitChanges !== undefined) {
+    try {
+      const gitStatus = execSync('git status --short', { encoding: 'utf-8' });
+      gitChanges = gitStatus.trim().split('\n').filter(line => line.length > 0).length;
+    } catch (error) {
+      // Git not available or not a git repo
+      gitChanges = -1;
+    }
+  }
+
+  // Detect if task requires changes (implementation keywords)
+  const requiresChanges = params.taskType
+    ? IMPLEMENTATION_KEYWORDS.some(keyword =>
+        params.taskType!.toLowerCase().includes(keyword)
+      )
+    : false;
+
+  // Check for "consensus on vapor"
+  let verified = missing.length === 0 && typeErrors.length === 0;
+  let reason: string | undefined;
+
+  if (requiresChanges && params.requireGitChanges && gitChanges === 0 && params.files.length === 0) {
+    verified = false;
+    reason = 'Implementation task detected but no deliverables created (consensus on vapor)';
+  }
+
+  const result: VerificationResult = {
+    verified,
+    files: params.files,
+    missing,
+    found,
+    gitChanges,
+    requiresChanges
+  };
+
+  // Add optional properties only if they have values
+  if (typeErrors.length > 0) {
+    result.typeErrors = typeErrors;
+  }
+  if (reason !== undefined) {
+    result.reason = reason;
+  }
+
+  return result;
+}

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/iteration-manager.ts

@@ -0,0 +1,45 @@
+/**
+ * Iteration Manager
+ * Manages CFN Loop iteration transitions and agent wake operations
+ */
+
+export interface IterationPreparation {
+  nextIteration: number;
+  feedback: any;
+  timestamp: string;
+}
+
+export interface WakeResult {
+  signals: string[];
+}
+
+/**
+ * Prepares next iteration with feedback
+ * @param params Current iteration and feedback data
+ * @returns IterationPreparation for next iteration
+ */
+export function prepareIteration(params: {
+  currentIteration: number;
+  feedback: any;
+}): IterationPreparation {
+  return {
+    nextIteration: params.currentIteration + 1,
+    feedback: params.feedback,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * Prepares wake signals for agents
+ * @param agentIds Array of agent IDs to wake
+ * @returns WakeResult with signal identifiers
+ */
+export function wakeAgents(agentIds: string[]): WakeResult {
+  const signals = agentIds.map(agentId => {
+    return `wake:${agentId}:${Date.now()}`;
+  });
+
+  return {
+    signals
+  };
+}

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/timeout-calculator.ts

@@ -0,0 +1,41 @@
+/**
+ * Timeout Calculator
+ * Calculates mode and phase-specific timeouts for agent execution
+ */
+
+export type Mode = 'mvp' | 'standard' | 'enterprise';
+
+const BASE_TIMEOUTS: Record<Mode, number> = {
+  mvp: 1800,       // 30 minutes
+  standard: 3600,  // 60 minutes
+  enterprise: 7200 // 120 minutes
+};
+
+const PHASE_MULTIPLIERS: Record<string, number> = {
+  'phase-1': 1.0,   // Backend work
+  'phase-2': 1.5,   // React components
+  'phase-3': 2.0,   // Advanced components
+  'phase-4': 1.0    // Testing/integration
+};
+
+/**
+ * Calculates timeout based on mode and optional phase
+ * @param params Mode and optional phase identifier
+ * @returns Timeout in seconds
+ */
+export function calculateTimeout(params: {
+  mode: Mode;
+  phase?: string;
+}): number {
+  const baseTimeout = BASE_TIMEOUTS[params.mode] || BASE_TIMEOUTS.standard;
+
+  if (!params.phase) {
+    return baseTimeout;
+  }
+
+  // Normalize phase to lowercase for case-insensitive matching
+  const normalizedPhase = params.phase.toLowerCase();
+  const multiplier = PHASE_MULTIPLIERS[normalizedPhase] || 1.0;
+
+  return Math.floor(baseTimeout * multiplier);
+}

package/claude-assets/skills/cfn-loop-orchestration/tests/consensus.test.ts

@@ -3,7 +3,7 @@
  * Tests for collecting Loop 2 validator scores and checking thresholds
  */
 
-import { collectConsensus, validateConsensus, ConsensusResult, ConsensusValidation } from '../src/helpers/consensus';
+import { collectConsensus, validateConsensus } from '../src/helpers/consensus';
 
 describe('consensus', () => {
   describe('collectConsensus', () => {

package/claude-assets/skills/cfn-loop-orchestration/tests/deliverable-verifier.test.ts

@@ -3,9 +3,7 @@
  * Tests for verifying expected deliverables exist (prevents "consensus on vapor")
  */
 
-import { verifyDeliverables, VerificationResult } from '../src/helpers/deliverable-verifier';
-import * as fs from 'fs';
-import * as path from 'path';
+import { verifyDeliverables } from '../src/helpers/deliverable-verifier';
 
 describe('deliverable-verifier', () => {
   describe('file existence verification', () => {

package/claude-assets/skills/cfn-loop-orchestration/tests/iteration-manager.test.ts

@@ -3,7 +3,7 @@
  * Tests for managing CFN Loop iteration transitions and feedback
  */
 
-import { prepareIteration, wakeAgents, IterationPreparation } from '../src/helpers/iteration-manager';
+import { prepareIteration, wakeAgents } from '../src/helpers/iteration-manager';
 
 describe('iteration-manager', () => {
   describe('prepareIteration', () => {

package/claude-assets/skills/cfn-redis-coordination/report-completion.sh

@@ -2,7 +2,10 @@
 # Report agent completion and confidence to Redis
 # Replaces deprecated invoke-waiting-mode.sh for CFN Loop coordination
 #
-# Usage: report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>]
+# Usage:
+#   report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0>
+#                        [--iteration <n>] [--namespace <ns>] [--result <json>]
+#                        [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]
 
 set -euo pipefail
 
@@ -16,6 +19,10 @@ AGENT_ID=""
 CONFIDENCE=""
 RESULT=""
 ITERATION="1"
+NAMESPACE="swarm"
+TEST_PASS_RATE=""
+TESTS_RUN=""
+TESTS_PASSED=""
 
 while [[ $# -gt 0 ]]; do
     case $1 in
@@ -39,6 +46,22 @@ while [[ $# -gt 0 ]]; do
             ITERATION="$2"
             shift 2
             ;;
+        --namespace)
+            NAMESPACE="$2"
+            shift 2
+            ;;
+        --test-pass-rate)
+            TEST_PASS_RATE="$2"
+            shift 2
+            ;;
+        --tests-run)
+            TESTS_RUN="$2"
+            shift 2
+            ;;
+        --tests-passed)
+            TESTS_PASSED="$2"
+            shift 2
+            ;;
         *)
             echo "Unknown option: $1" >&2
             exit 1
@@ -51,7 +74,9 @@ done
 # Wrapper provides graceful Task mode fallback when Redis unavailable
 if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
     echo "Error: Missing required parameters" >&2
-    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>] [--iteration <n>]" >&2
+    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0>" >&2
+    echo "       [--iteration <n>] [--namespace <ns>] [--result <json>]" >&2
+    echo "       [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]" >&2
     exit 1
 fi
 
@@ -66,24 +91,44 @@ fi
 # Measured improvement: ~62% coordination overhead reduction in standard mode
 {
     echo "MULTI"
-    echo "LPUSH swarm:${TASK_ID}:${AGENT_ID}:done complete"
-    echo "SET swarm:${TASK_ID}:${AGENT_ID}:confidence $CONFIDENCE EX 3600"
+    echo "LPUSH ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done complete"
+    echo "SET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:confidence $CONFIDENCE EX 3600"
+
+    # Build result hash with test metrics if provided
+    RESULT_HASH_ARGS="confidence $CONFIDENCE iteration $ITERATION"
 
     if [ -n "$RESULT" ]; then
-        echo "HSET swarm:${TASK_ID}:${AGENT_ID}:result confidence $CONFIDENCE iteration $ITERATION result $RESULT timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
-    else
-        echo "HSET swarm:${TASK_ID}:${AGENT_ID}:result confidence $CONFIDENCE iteration $ITERATION timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS result $RESULT"
     fi
 
+    if [ -n "$TEST_PASS_RATE" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS test_pass_rate $TEST_PASS_RATE"
+    fi
+
+    if [ -n "$TESTS_RUN" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_run $TESTS_RUN"
+    fi
+
+    if [ -n "$TESTS_PASSED" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_passed $TESTS_PASSED"
+    fi
+
+    RESULT_HASH_ARGS="$RESULT_HASH_ARGS timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+    echo "HSET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result $RESULT_HASH_ARGS"
+
     echo "EXEC"
 } | redis-cli > /dev/null
 
 # Step 4: Add to agent completion list (for orchestrator tracking)
-redis-cli LPUSH "swarm:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
+redis-cli LPUSH "${NAMESPACE}:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
 
 # Step 5: Set TTL on keys (auto-cleanup)
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
+redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
+redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
 
 echo "✅ Reported completion for agent: $AGENT_ID (confidence: $CONFIDENCE)"
+if [ -n "$TEST_PASS_RATE" ]; then
+    echo "   Test pass rate: $TEST_PASS_RATE%"
+fi
 exit 0

package/claude-assets/skills/cfn-redis-coordination/store-context.sh

@@ -4,6 +4,7 @@
 #
 # Usage:
 #   store-context.sh --task-id <id> --key <key> --value <value> [--namespace <ns>]
+#   store-context.sh --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]
 #   store-context.sh <task_id> <context_json> (legacy mode)
 
 set -euo pipefail
@@ -18,6 +19,8 @@ KEY=""
 VALUE=""
 NAMESPACE="swarm"
 CONTEXT=""
+EPIC=""
+MODE=""
 
 # Parse arguments
 while [[ $# -gt 0 ]]; do
@@ -38,6 +41,14 @@ while [[ $# -gt 0 ]]; do
       NAMESPACE="$2"
       shift 2
       ;;
+    --epic)
+      EPIC="$2"
+      shift 2
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
     *)
       # Legacy mode: positional arguments
       if [ -z "$TASK_ID" ]; then
@@ -54,10 +65,29 @@ done
 if [ -z "$TASK_ID" ]; then
     echo "Error: --task-id or TASK_ID required" >&2
     echo "Usage: $0 --task-id <id> --key <key> --value <value> [--namespace <ns>]" >&2
+    echo "   or: $0 --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]" >&2
     echo "   or: $0 <task_id> <context_json> (legacy)" >&2
     exit 1
 fi
 
+# Handle epic+mode mode (new)
+if [ -n "$EPIC" ] && [ -n "$MODE" ]; then
+  # Store epic and mode with task context
+  REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
+
+  redis-cli HSET "$REDIS_KEY" \
+      "epic" "$EPIC" \
+      "mode" "$MODE" \
+      "updated_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+      > /dev/null
+
+  # Set TTL (24 hours)
+  redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
+
+  echo "✅ Context stored: epic=$EPIC, mode=$MODE for task: $TASK_ID"
+  exit 0
+fi
+
 # Handle structured mode (new)
 if [ -n "$KEY" ] && [ -n "$VALUE" ]; then
   # Store structured context with specific key
@@ -89,5 +119,5 @@ if [ -n "$CONTEXT" ]; then
   exit 0
 fi
 
-echo "Error: Either --key/--value or <context_json> required" >&2
+echo "Error: Either --epic/--mode, --key/--value, or <context_json> required" >&2
 exit 1