agileflow 3.3.0 → 3.4.1

package/scripts/lib/model-profiles.js

@@ -0,0 +1,118 @@
+/**
+ * model-profiles.js - Model resolution for audit subagents
+ *
+ * Resolves which model (haiku/sonnet/opus) to use for agent subagents.
+ * Models are specified inline via command arguments (MODEL=opus).
+ *
+ * Resolution order:
+ *   1. Explicit MODEL= argument (highest priority)
+ *   2. Agent frontmatter model (from .md file)
+ *   3. Fallback: 'haiku'
+ *
+ * Usage:
+ *   const { resolveModel, estimateCost } = require('./model-profiles');
+ *   const model = resolveModel('opus', 'haiku');  // returns 'opus'
+ *   const model2 = resolveModel(null, 'sonnet');  // returns 'sonnet'
+ *   const model3 = resolveModel(null, null);       // returns 'haiku'
+ */
+
+const VALID_MODELS = ['haiku', 'sonnet', 'opus'];
+
+/**
+ * Resolve which model to use for a given agent.
+ *
+ * Resolution order:
+ *   1. Explicit model argument (MODEL= from command)
+ *   2. Agent frontmatter model
+ *   3. Fallback: 'haiku'
+ *
+ * @param {string} [explicitModel] - MODEL= argument value
+ * @param {string} [frontmatterModel] - Model from agent .md frontmatter
+ * @returns {string} Model name: 'haiku', 'sonnet', or 'opus'
+ */
+function resolveModel(explicitModel, frontmatterModel) {
+  // 1. Explicit MODEL= argument
+  if (explicitModel && VALID_MODELS.includes(explicitModel.toLowerCase())) {
+    return explicitModel.toLowerCase();
+  }
+
+  // 2. Frontmatter model
+  if (frontmatterModel && VALID_MODELS.includes(frontmatterModel.toLowerCase())) {
+    return frontmatterModel.toLowerCase();
+  }
+
+  // 3. Fallback
+  return 'haiku';
+}
+
+/**
+ * Validate a model name.
+ *
+ * @param {string} model - Model name to validate
+ * @returns {boolean} True if valid
+ */
+function isValidModel(model) {
+  return !!model && VALID_MODELS.includes(model.toLowerCase());
+}
+
+/**
+ * Estimate cost multiplier for a model relative to haiku baseline.
+ *
+ * @param {string} model - Model name
+ * @param {number} [analyzerCount=5] - Number of analyzers
+ * @param {number} [partitions=1] - Number of partitions (extreme mode)
+ * @returns {{ multiplier: number, model: string, perAnalyzerCost: string, totalEstimate: string, partitions?: number, totalSessions?: number }}
+ */
+function estimateCost(model, analyzerCount, partitions) {
+  let MODEL_PRICING;
+  try {
+    MODEL_PRICING = require('./team-events').MODEL_PRICING;
+  } catch (_) {
+    MODEL_PRICING = {
+      haiku: { input: 0.8, output: 4.0 },
+      sonnet: { input: 3.0, output: 15.0 },
+      opus: { input: 15.0, output: 75.0 },
+    };
+  }
+
+  const count = analyzerCount || 5;
+  const partCount = typeof partitions === 'number' && partitions > 1 ? partitions : 1;
+  const resolved = resolveModel(model);
+  const pricing = MODEL_PRICING[resolved] || MODEL_PRICING.haiku;
+  const haikuPricing = MODEL_PRICING.haiku;
+
+  const multiplier = pricing.output / haikuPricing.output;
+  const perAnalyzerCostNum =
+    (pricing.input * 50000) / 1_000_000 + (pricing.output * 10000) / 1_000_000;
+  const perAnalyzer = `$${perAnalyzerCostNum.toFixed(3)}`;
+
+  // For extreme mode: each partition has a coordinator + all analyzers as sub-agents
+  // Estimated cost per partition coordinator session in USD (~10k input + 2k output at haiku rates)
+  const coordinatorCostUSD = 0.05;
+  const totalSessions = partCount * count;
+  const totalCost =
+    partCount > 1
+      ? partCount * coordinatorCostUSD + totalSessions * perAnalyzerCostNum
+      : count * perAnalyzerCostNum;
+
+  const result = {
+    multiplier: Math.round(multiplier * 100) / 100,
+    model: resolved,
+    perAnalyzerCost: perAnalyzer,
+    totalEstimate: `~$${totalCost.toFixed(2)}`,
+  };
+
+  if (partCount > 1) {
+    result.partitions = partCount;
+    result.totalSessions = totalSessions;
+  }
+
+  return result;
+}
+
+module.exports = {
+  VALID_MODELS,
+  resolveModel,
+  isValidModel,
+  estimateCost,
+};

package/scripts/lib/quality-gates.js

@@ -561,6 +561,164 @@ function createValidationReport(gateResults, options = {}) {
   return lines.join('\n');
 }
 
+// ============================================================================
+// CI Feedback Loop
+// ============================================================================
+
+/**
+ * Default CI feedback loop configuration
+ */
+const CI_FEEDBACK_DEFAULTS = {
+  enabled: true,
+  max_rounds: 3,
+};
+
+/**
+ * Load CI feedback loop config from agileflow-metadata.json
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} CI feedback loop config
+ */
+function loadCIFeedbackConfig(projectRoot) {
+  const metadataPath = path.join(projectRoot, 'docs', '00-meta', 'agileflow-metadata.json');
+  try {
+    if (fs.existsSync(metadataPath)) {
+      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+      if (metadata.ci_feedback_loops) {
+        return {
+          ...CI_FEEDBACK_DEFAULTS,
+          ...metadata.ci_feedback_loops,
+        };
+      }
+    }
+  } catch {
+    // Fall through to defaults
+  }
+  return { ...CI_FEEDBACK_DEFAULTS };
+}
+
+/**
+ * Execute a CI feedback loop - runs gates, and if they fail, returns
+ * structured feedback for the agent to retry (up to max_rounds).
+ *
+ * This implements the Stripe "Minions" pattern: deterministic CI check
+ * followed by agent retry, with a hard iteration limit.
+ *
+ * @param {Object[]} gates - Quality gate definitions to check
+ * @param {Object} options - Loop options
+ * @param {string} [options.projectRoot] - Project root directory
+ * @param {number} [options.maxRounds] - Override max retry rounds (default: from config)
+ * @param {number} [options.currentRound] - Current round number (1-based, default: 1)
+ * @param {string} [options.cwd] - Working directory for gate execution
+ * @returns {Object} Loop result with status and agent feedback
+ */
+function executeCIFeedbackLoop(gates, options = {}) {
+  const { projectRoot = process.cwd(), maxRounds, currentRound = 1, cwd } = options;
+
+  const config = loadCIFeedbackConfig(projectRoot);
+
+  if (!config.enabled) {
+    return {
+      status: 'disabled',
+      message: 'CI feedback loops are disabled in agileflow-metadata.json',
+      should_retry: false,
+      round: currentRound,
+      max_rounds: 0,
+    };
+  }
+
+  const effectiveMaxRounds = maxRounds || config.max_rounds || CI_FEEDBACK_DEFAULTS.max_rounds;
+
+  // Execute all gates
+  const gateResults = executeGates(gates, { cwd, stopOnFailure: false });
+
+  if (gateResults.passed) {
+    return {
+      status: 'passed',
+      message: `All ${gateResults.passed_count} gates passed on round ${currentRound}`,
+      should_retry: false,
+      round: currentRound,
+      max_rounds: effectiveMaxRounds,
+      gate_results: gateResults,
+    };
+  }
+
+  // Gates failed - determine if we should retry
+  const hasRoundsLeft = currentRound < effectiveMaxRounds;
+
+  if (!hasRoundsLeft) {
+    return {
+      status: 'exhausted',
+      message: `Gates failed after ${currentRound}/${effectiveMaxRounds} rounds. Escalating to human.`,
+      should_retry: false,
+      round: currentRound,
+      max_rounds: effectiveMaxRounds,
+      gate_results: gateResults,
+      failures: gateResults.results
+        .filter(r => r.status === GATE_STATUS.FAILED || r.status === GATE_STATUS.ERROR)
+        .map(r => ({
+          gate: r.gate,
+          message: r.message,
+          output: r.output,
+          error: r.error,
+        })),
+    };
+  }
+
+  // Build structured feedback for agent retry
+  const failures = gateResults.results.filter(
+    r => r.status === GATE_STATUS.FAILED || r.status === GATE_STATUS.ERROR
+  );
+
+  const feedbackLines = [
+    `## CI Feedback Loop - Round ${currentRound}/${effectiveMaxRounds}`,
+    '',
+    `**${failures.length} gate(s) failed.** ${effectiveMaxRounds - currentRound} retry round(s) remaining.`,
+    '',
+    '### Failures',
+    '',
+  ];
+
+  for (const failure of failures) {
+    feedbackLines.push(`#### ${failure.gate} (${failure.type})`);
+    feedbackLines.push(`- **Status**: ${failure.status}`);
+    feedbackLines.push(`- **Message**: ${failure.message}`);
+    if (failure.output) {
+      feedbackLines.push('- **Output**:');
+      feedbackLines.push('```');
+      feedbackLines.push(failure.output);
+      feedbackLines.push('```');
+    }
+    if (failure.error) {
+      feedbackLines.push('- **Error**:');
+      feedbackLines.push('```');
+      feedbackLines.push(failure.error);
+      feedbackLines.push('```');
+    }
+    feedbackLines.push('');
+  }
+
+  feedbackLines.push('### Action Required');
+  feedbackLines.push('');
+  feedbackLines.push('Fix the failing gates above, then re-run verification.');
+
+  return {
+    status: 'retry',
+    message: `Round ${currentRound}/${effectiveMaxRounds} failed. Agent should fix and retry.`,
+    should_retry: true,
+    round: currentRound,
+    max_rounds: effectiveMaxRounds,
+    next_round: currentRound + 1,
+    gate_results: gateResults,
+    agent_feedback: feedbackLines.join('\n'),
+    failures: failures.map(r => ({
+      gate: r.gate,
+      message: r.message,
+      output: r.output,
+      error: r.error,
+    })),
+  };
+}
+
 // ============================================================================
 // Exports
 // ============================================================================
@@ -595,4 +753,9 @@ module.exports = {
 
   // Reporting
   createValidationReport,
+
+  // CI Feedback Loop
+  CI_FEEDBACK_DEFAULTS,
+  loadCIFeedbackConfig,
+  executeCIFeedbackLoop,
 };

package/scripts/lib/signal-detectors.js

@@ -233,6 +233,24 @@ const FEATURE_DETECTORS = {
     });
   },
 
+  'scale-adaptive': signals => {
+    const { scale } = signals;
+    if (!scale || !scale.tier) return null;
+    // Only trigger when scale info provides actionable guidance
+    const rec = scale.recommendations;
+    if (!rec) return null;
+    // Suggest scale-adaptive workflow when project is not medium (the default)
+    if (scale.tier === 'medium') return null;
+    const label = scale.tier.charAt(0).toUpperCase() + scale.tier.slice(1);
+    return recommend('scale-adaptive', {
+      priority: scale.tier === 'enterprise' || scale.tier === 'large' ? 'medium' : 'low',
+      trigger: `${label} project detected (${scale.metrics.files} files, ${scale.metrics.stories} stories) — ${rec.description}`,
+      action: 'suggest',
+      command: '/agileflow:workflow',
+      phase: 'pre-story',
+    });
+  },
+
   // =========================================================================
   // PLANNING PHASE
   // =========================================================================
@@ -517,6 +535,29 @@ const FEATURE_DETECTORS = {
     });
   },
 
+  'ac-verify': signals => {
+    const { story, tests } = signals;
+    if (!story || story.status !== 'in-progress') return null;
+    if (!tests || tests.passing !== true) return null; // Only after tests pass
+    if (!storyHasAC(story)) return null;
+    // Check if AC already verified (count by index to avoid extra keys)
+    const acStatus = story.ac_status || {};
+    const acList = story.acceptance_criteria || story.ac || [];
+    const verifiedCount = acList.filter(
+      (_, i) =>
+        acStatus[i] === 'verified' || acStatus[i] === 'auto-verified' || acStatus[i] === true
+    ).length;
+    if (verifiedCount === acList.length) return null;
+    const unverifiedCount = acList.length - verifiedCount;
+    return recommend('ac-verify', {
+      priority: 'high',
+      trigger: `Tests pass but ${unverifiedCount}/${acList.length} AC unverified`,
+      action: 'suggest',
+      command: '/agileflow:audit',
+      phase: 'post-impl',
+    });
+  },
+
   // =========================================================================
   // POST-IMPLEMENTATION PHASE
   // =========================================================================
@@ -546,7 +587,7 @@ const FEATURE_DETECTORS = {
       priority: 'medium',
       trigger: `${coreFiles} source files modified - logic audit available`,
       action: 'offer',
-      command: '/agileflow:audit:logic',
+      command: '/agileflow:code:logic',
       phase: 'post-impl',
     });
   },
@@ -704,6 +745,7 @@ const PHASE_MAP = {
     'workflow',
     'template',
     'configure',
+    'scale-adaptive',
   ],
   planning: [
     'impact',
@@ -728,6 +770,7 @@ const PHASE_MAP = {
     'serve',
   ],
   'post-impl': [
+    'ac-verify',
     'review',
     'logic-audit',
     'docs',