claude-flow-novice 2.15.7 → 2.15.9

package/.claude/cfn-extras/agents/google-sheets/google-sheets-coordinator.md

@@ -100,7 +100,7 @@ npx claude-flow-novice cfn-spawn cfn-v3-coordinator \
 
 **Agent Communication Pattern:**
 - Coordinator receives broadcast messages via coordination layer
-- Agents signal completion via `report-completion.sh`
+- Agents signal completion via Redis coordination (CLI mode only)
 - Validators wait for gate pass signal before starting
 - Product Owner receives summary and makes decision
 

package/.claude/cfn-extras/docs/GOOGLE_SHEETS_CFN_LOOP.md

@@ -318,12 +318,15 @@ automation_001 (depends on all above)
 # 3. Signal completion
 coordination-signal "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 
-# 4. Report results
-./.claude/skills/cfn-coordination/report-completion.sh \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.95 \
-  --result '{"deliverables": ["sheet_created"], "tests_passed": 5, "tests_total": 5}'
+# 4. Report results (CLI Mode - uses Redis coordination)
+# Task Mode: Simply return structured JSON output instead
+if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+  redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
+    confidence 0.95 \
+    deliverables '["sheet_created"]' \
+    tests_passed 5 \
+    tests_total 5
+fi
 ```
 
 ### Loop 2 Validation
@@ -336,11 +339,10 @@ coordination-wait "swarm:${TASK_ID}:gate-passed"
   --sprint-id "$SPRINT_ID" \
   --validation-type comprehensive
 
-# 3. Report confidence score
-./.claude/skills/cfn-coordination/report-completion.sh \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.92
+# 3. Report confidence score (CLI Mode)
+if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+  redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" confidence 0.92
+fi
 ```
 
 ## API Quota Management

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

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Consensus Checker (TypeScript Wrapper)
+# Collects and validates Loop 2 consensus scores
+#
+# Usage:
+#   consensus-ts.sh --scores <score1,score2,...> \
+#                   --threshold <0.0-1.0> \
+#                   --mode <mvp|standard|enterprise>
+#
+# Returns:
+#   Exit 0: Consensus reached
+#   Exit 1: Consensus failed
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+SCORES=""
+THRESHOLD=""
+MODE="standard"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --scores) SCORES="$2"; shift 2 ;;
+    --threshold) THRESHOLD="$2"; shift 2 ;;
+    --mode) MODE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$SCORES" ]; then
+  echo "Error: Missing required parameter --scores" >&2
+  exit 1
+fi
+
+# Convert comma-separated scores to JSON array
+IFS=',' read -ra SCORE_ARRAY <<< "$SCORES"
+SCORES_JSON="["
+for i in "${!SCORE_ARRAY[@]}"; do
+  if [ $i -gt 0 ]; then
+    SCORES_JSON+=","
+  fi
+  SCORES_JSON+="${SCORE_ARRAY[$i]}"
+done
+SCORES_JSON+="]"
+
+# Build TypeScript invocation
+TS_CODE="
+import { collectConsensus, validateConsensus } from './consensus';
+
+const scores = $SCORES_JSON;
+const mode = '$MODE';
+const threshold = ${THRESHOLD:-null};
+
+try {
+  const consensus = collectConsensus(scores);
+  console.log(\`Consensus Statistics:\`);
+  console.log(\`  Count: \${consensus.count}\`);
+  console.log(\`  Average: \${consensus.average.toFixed(3)}\`);
+  console.log(\`  Min: \${consensus.min.toFixed(3)}\`);
+  console.log(\`  Max: \${consensus.max.toFixed(3)}\`);
+  console.log();
+
+  const validationParams: any = {
+    average: consensus.average,
+    mode
+  };
+  if (threshold !== null) {
+    validationParams.threshold = threshold;
+  }
+  const validation = validateConsensus(validationParams);
+
+  console.log(\`Consensus Validation:\`);
+  console.log(\`  Mode: \${validation.mode}\`);
+  console.log(\`  Threshold: \${validation.threshold.toFixed(2)}\`);
+  console.log(\`  Average: \${validation.average.toFixed(3)}\`);
+  console.log(\`  Gap: \${validation.gap >= 0 ? '+' : ''}\${validation.gap.toFixed(3)}\`);
+  console.log(\`  Passed: \${validation.passed}\`);
+  console.log();
+
+  if (validation.passed) {
+    console.log('✅ Consensus REACHED - Loop 2 validation successful');
+    process.exit(0);
+  } else {
+    console.log('❌ Consensus FAILED - Iteration required');
+    process.exit(1);
+  }
+} catch (error: any) {
+  console.error('Error:', error.message);
+  process.exit(2);
+}
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

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

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Deliverable Verifier (TypeScript Wrapper)
+# Verifies expected deliverables exist (prevents "consensus on vapor")
+#
+# Usage:
+#   deliverable-verifier-ts.sh --files <file1,file2,...> \
+#                              [--expected-types <.ext1,.ext2,...>] \
+#                              [--task-type <description>] \
+#                              [--require-git-changes]
+#
+# Returns:
+#   Exit 0: Deliverables verified
+#   Exit 1: Missing deliverables or validation failed
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+FILES=""
+EXPECTED_TYPES=""
+TASK_TYPE=""
+REQUIRE_GIT_CHANGES="false"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --files) FILES="$2"; shift 2 ;;
+    --expected-types) EXPECTED_TYPES="$2"; shift 2 ;;
+    --task-type) TASK_TYPE="$2"; shift 2 ;;
+    --require-git-changes) REQUIRE_GIT_CHANGES="true"; shift 1 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Convert comma-separated files to JSON array
+if [ -n "$FILES" ]; then
+  IFS=',' read -ra FILE_ARRAY <<< "$FILES"
+  FILES_JSON="["
+  for i in "${!FILE_ARRAY[@]}"; do
+    if [ $i -gt 0 ]; then
+      FILES_JSON+=","
+    fi
+    FILES_JSON+="\"${FILE_ARRAY[$i]}\""
+  done
+  FILES_JSON+="]"
+else
+  FILES_JSON="[]"
+fi
+
+# Convert comma-separated types to JSON array
+if [ -n "$EXPECTED_TYPES" ]; then
+  IFS=',' read -ra TYPE_ARRAY <<< "$EXPECTED_TYPES"
+  TYPES_JSON="["
+  for i in "${!TYPE_ARRAY[@]}"; do
+    if [ $i -gt 0 ]; then
+      TYPES_JSON+=","
+    fi
+    TYPES_JSON+="\"${TYPE_ARRAY[$i]}\""
+  done
+  TYPES_JSON+="]"
+else
+  TYPES_JSON="undefined"
+fi
+
+# Build TypeScript invocation
+TS_CODE="
+import { verifyDeliverables } from './deliverable-verifier';
+
+const result = verifyDeliverables({
+  files: $FILES_JSON,
+  ${EXPECTED_TYPES:+expectedTypes: $TYPES_JSON,}
+  ${TASK_TYPE:+taskType: '$TASK_TYPE',}
+  requireGitChanges: $REQUIRE_GIT_CHANGES
+});
+
+console.log('Deliverable Verification:');
+console.log(\`  Files checked: \${result.files.length}\`);
+console.log(\`  Found: \${result.found.length}\`);
+console.log(\`  Missing: \${result.missing.length}\`);
+if (result.gitChanges !== undefined) {
+  console.log(\`  Git changes: \${result.gitChanges}\`);
+}
+console.log();
+
+if (result.found.length > 0) {
+  console.log('Found files:');
+  result.found.forEach(file => console.log(\`  ✅ \${file}\`));
+  console.log();
+}
+
+if (result.missing.length > 0) {
+  console.log('Missing files:');
+  result.missing.forEach(file => console.log(\`  ❌ \${file}\`));
+  console.log();
+}
+
+if (result.typeErrors && result.typeErrors.length > 0) {
+  console.log('Type errors:');
+  result.typeErrors.forEach(file => console.log(\`  ⚠️  \${file}\`));
+  console.log();
+}
+
+if (result.verified) {
+  console.log('✅ Deliverable verification PASSED');
+  process.exit(0);
+} else {
+  console.log('❌ Deliverable verification FAILED');
+  if (result.reason) {
+    console.log(\`   Reason: \${result.reason}\`);
+  }
+  process.exit(1);
+}
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/.claude/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/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/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/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/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/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/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/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', () => {