wogiflow 2.9.0 → 2.10.0

package/lib/workspace-gates.js

@@ -69,6 +69,18 @@ const WORKSPACE_GATES = [
     description: 'Verify changes are committed and pushed before handoff to downstream workers',
     phase: 'post',
     severity: 'error'
+  },
+  {
+    name: 'crossRepoEnumVerification',
+    description: 'Verify type/enum mappings between repos by grepping BOTH repos for actual values',
+    phase: 'pre',
+    severity: 'error'
+  },
+  {
+    name: 'dispatchVerification',
+    description: 'Verify dispatch claims have corresponding tool calls — prevents narrate-without-execute',
+    phase: 'post',
+    severity: 'error'
   }
 ];
 
@@ -538,6 +550,12 @@ function runWorkspaceGate(gateName, workspaceRoot, context, taskMeta = {}) {
     case 'deploymentReadiness':
       return gateDeploymentReadiness(workspaceRoot, context, taskMeta);
 
+    case 'crossRepoEnumVerification':
+      return gateCrossRepoEnumVerification(workspaceRoot, context, taskMeta);
+
+    case 'dispatchVerification':
+      return gateDispatchVerification(context, taskMeta);
+
     default:
       return { passed: true, message: `Unknown gate: ${gateName}`, severity: 'warning' };
   }
@@ -800,6 +818,137 @@ function runAllWorkspaceGates(workspaceRoot, context, taskMeta = {}) {
   };
 }
 
+/**
+ * Gate: dispatchVerification
+ * After task completion in workspace manager mode, verify that any response
+ * claiming to have dispatched/sent/forwarded work to a worker actually
+ * contains corresponding tool calls (Bash with dispatch URL, Agent with
+ * worker target, etc.).
+ *
+ * Prevents the 'narrate without execute' failure class where the manager
+ * describes sending work but never actually sends it.
+ *
+ * Source: Manager mistake #1 (~15K tokens wasted on phantom dispatch).
+ */
+function gateDispatchVerification(context, taskMeta) {
+  const gate = WORKSPACE_GATES.find(g => g.name === 'dispatchVerification');
+
+  // Only meaningful in manager mode
+  if (!context.currentMember || context.currentMember.role !== 'manager') {
+    return { passed: true, message: 'Not in manager mode, dispatch verification skipped', severity: gate.severity };
+  }
+
+  // Check if the task output contains dispatch-claim keywords
+  const dispatchKeywords = [
+    /\bdispatched\b/i,
+    /\bsent to worker\b/i,
+    /\bforwarded to\b/i,
+    /\bdelegated to\b/i,
+    /\brouted to worker\b/i,
+    /\bspawned.*agent\b/i
+  ];
+
+  const taskOutput = taskMeta.taskOutput ?? '';
+  const hasDispatchClaim = dispatchKeywords.some(kw => kw.test(taskOutput));
+
+  if (!hasDispatchClaim) {
+    return { passed: true, message: 'No dispatch claims in task output', severity: gate.severity };
+  }
+
+  // If dispatch was claimed, verify tool calls exist
+  const toolCalls = taskMeta.toolCalls ?? [];
+
+  // Graceful degradation: if tool call tracking is not wired up yet, skip
+  if (toolCalls.length === 0 && !taskMeta.toolCallsTracked) {
+    return { passed: true, message: 'Tool call tracking not available — dispatch verification skipped', severity: 'warning' };
+  }
+
+  const hasDispatchToolCall = toolCalls.some(tc =>
+    (tc.tool === 'Bash' && /dispatch|curl.*channel|http.*localhost.*task/i.test(tc.input ?? '')) ||
+    (tc.tool === 'Agent' && tc.input) ||
+    (tc.tool === 'Bash' && /node.*workspace-routing/i.test(tc.input ?? ''))
+  );
+
+  if (hasDispatchToolCall) {
+    return { passed: true, message: 'Dispatch claims verified — tool calls found', severity: gate.severity };
+  }
+
+  // Dispatch claimed but no matching tool call found
+  return {
+    passed: false,
+    message: `Response contains dispatch claims ("dispatched", "sent to worker", etc.) ` +
+      `but NO corresponding tool call was found. ` +
+      `This is the "narrate without execute" failure — the manager described sending work ` +
+      `but never actually sent it. Execute the dispatch before marking complete.`,
+    severity: gate.severity,
+    action: 'Find the dispatch claim, execute the actual dispatch tool call, then re-verify.'
+  };
+}
+
+/**
+ * Gate: crossRepoEnumVerification
+ * When a decision involves type/enum mapping between repos (frontend↔backend),
+ * mandate grep/read to BOTH repos for actual values, display side-by-side,
+ * THEN present the mapping to the owner.
+ *
+ * Detects keywords: 'maps to', 'rename to', 'corresponds to', 'enum', 'type mapping'.
+ * Source: Manager mistake #5 (DECISION-7 axis mismatch — payment cadence vs compensation model).
+ */
+function gateCrossRepoEnumVerification(workspaceRoot, context, taskMeta) {
+  const gate = WORKSPACE_GATES.find(g => g.name === 'crossRepoEnumVerification');
+
+  // Only activate when workspace is active and has multiple members
+  if (!context.config?.members || Object.keys(context.config.members).length < 2) {
+    return { passed: true, message: 'Single-repo workspace, enum verification skipped', severity: gate.severity };
+  }
+
+  // Check if the task description or decisions contain cross-repo type mapping keywords
+  const mappingKeywords = [
+    /\bmaps?\s*to\b/i,
+    /\brename[sd]?\s*to\b/i,
+    /\bcorresponds?\s*to\b/i,
+    /\benum\s+mapping/i,
+    /\btype\s+mapping/i,
+    /\bfrontend.*backend.*(?:type|enum|interface)/i,
+    /\bbackend.*frontend.*(?:type|enum|interface)/i,
+    /\bclient.*server.*(?:type|enum|interface)/i
+  ];
+
+  const taskText = [
+    taskMeta.taskTitle ?? '',
+    taskMeta.taskDescription ?? '',
+    ...(taskMeta.decisions ?? [])
+  ].join(' ');
+
+  const hasMappingDecision = mappingKeywords.some(kw => kw.test(taskText));
+
+  if (!hasMappingDecision) {
+    return { passed: true, message: 'No cross-repo type/enum mapping detected', severity: gate.severity };
+  }
+
+  // If mapping decision detected, check if verification was performed
+  if (taskMeta.enumVerificationPerformed) {
+    return { passed: true, message: 'Cross-repo enum values verified in both repos', severity: gate.severity };
+  }
+
+  // Build the list of member repos for the error message
+  const memberNames = Object.keys(context.config.members);
+
+  return {
+    passed: false,
+    message: `Cross-repo type/enum mapping detected but not verified. ` +
+      `Before presenting a mapping decision, grep BOTH repos (${memberNames.join(', ')}) ` +
+      `for actual enum/type values and display them side-by-side. ` +
+      `Never allow 'A maps to B' without verified evidence of both A and B.`,
+    severity: gate.severity,
+    action: 'Dispatch a grep/read to BOTH repos for actual enum values, display side-by-side, THEN present the mapping.',
+    memberRepos: memberNames.map(name => ({
+      name,
+      path: path.resolve(workspaceRoot, context.config.members[name].path)
+    }))
+  };
+}
+
 // ============================================================
 // Exports
 // ============================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow-config-defaults.js

@@ -187,7 +187,13 @@ const CONFIG_DEFAULTS = {
     implementationGate: { enabled: true },
     todoWriteGate: { enabled: true, blockImplementationWithoutTask: true },
     routingGate: { enabled: true },
-    loopEnforcement: { enabled: true }
+    loopEnforcement: { enabled: true },
+    hypothesisGate: {
+      enabled: true,
+      _comment_hypothesisGate: 'Blocks premature "fixed"/"should work" claims during bug investigation until hypothesis is verified. Pattern: hypothesis → verify → confirm → communicate.',
+      blockedPhrases: ['fixed', 'should work', 'go try', 'go refresh'],
+      requireExplicitVerification: true
+    }
   },
 
   // --- Execution ---

package/scripts/flow-context-estimator.js

@@ -167,10 +167,12 @@ function extractCriteriaCount(specContent) {
 
   let count = 0;
 
-  // Count Given/When/Then patterns (use [\s\S] to match across newlines)
-  const gwtMatches = specContent.match(/\bGiven\b[\s\S]*?\bWhen\b[\s\S]*?\bThen\b/gi);
-  if (gwtMatches) {
-    count += gwtMatches.length;
+  // Count Given/When/Then by individual keyword minimum (avoids ReDoS from nested [\s\S]*?)
+  const givenCount = (specContent.match(/\bGiven\b/gi) || []).length;
+  const whenCount = (specContent.match(/\bWhen\b/gi) || []).length;
+  const thenCount = (specContent.match(/\bThen\b/gi) || []).length;
+  if (givenCount > 0 && whenCount > 0 && thenCount > 0) {
+    count += Math.min(givenCount, whenCount, thenCount);
   }
 
   // Count numbered acceptance criteria
@@ -284,6 +286,26 @@ function estimateTaskContextNeeds(task, configOverride = null) {
     estimate += est.refactorBuffer;
   }
 
+  // Blast-radius buffer — factor in consumer impact from explore phase
+  // Validate task ID before path construction (security rule #4)
+  if (task.id && validateTaskId(task.id).valid) {
+    const blastRadiusPath = path.join(PATHS.state, `blast-radius-${task.id}.json`);
+    try {
+      const blastRadius = safeJsonParse(blastRadiusPath, null);
+      if (blastRadius && blastRadius.breakingCount > 0) {
+        factors.blastRadius = blastRadius.breakingCount;
+        // Each breaking consumer adds ~1% context (for reading + updating)
+        estimate += blastRadius.breakingCount * 0.01;
+        if (blastRadius.risk === 'HIGH') {
+          // HIGH risk (10+ breaking) adds extra buffer for phased migration planning
+          estimate += 0.05;
+        }
+      }
+    } catch (_err) {
+      // No blast-radius file — that's fine, proceed without it
+    }
+  }
+
   // Parent task: scale by subtask count
   if (task.type === 'parent' && task.subTasks && task.subTasks.length > 0) {
     factors.parentMultiplier = 1 + (task.subTasks.length * 0.3);

package/scripts/flow-decision-authority.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Decision Authority Framework
+ *
+ * Config-driven classification of decisions into authority levels.
+ * Prevents question flooding by classifying engineering vs product decisions
+ * and routing them to either agent-decides or owner-decides.
+ *
+ * Source: Retrospective — manager mistake #4 (12-question flooding),
+ * process gap #4 (no framework for engineering vs product authority).
+ *
+ * Usage:
+ *   node flow-decision-authority.js classify <decision-text>
+ *   node flow-decision-authority.js batch <json-array-of-decisions>
+ *   node flow-decision-authority.js update-category <category> <authority>
+ *
+ * Programmatic:
+ *   const { classifyDecision, batchClassify, getAuthorityConfig } = require('./flow-decision-authority');
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { PATHS, getConfig, safeJsonParse } = require('./flow-utils');
+
+// ============================================================
+// Constants
+// ============================================================
+
+const AUTHORITY_LEVELS = {
+  'agent-decides': 'Agent decides autonomously, reports in completion summary',
+  'agent-decides-report-after': 'Agent decides, explicitly reports the decision after',
+  'owner-decides': 'Present to user, wait for answer before proceeding',
+  'auto-fix-report-after': 'Agent fixes automatically, reports what was fixed'
+};
+
+const DEFAULT_AUTHORITY_CONFIG = {
+  engineering: 'agent-decides',
+  infrastructure: 'agent-decides-report-after',
+  productBehavior: 'owner-decides',
+  security: 'auto-fix-report-after',
+  ux: 'owner-decides',
+  naming: 'agent-decides',
+  performance: 'agent-decides-report-after',
+  maxOwnerQuestionsPerBatch: 5
+};
+
+/**
+ * Keywords and patterns for classifying decisions into categories.
+ * Each category has patterns that match against the decision text.
+ * IMPORTANT: Do NOT add the /g flag — these are used with .test() in a loop.
+ * Patterns use compound terms to avoid false positives from common single words.
+ */
+const CATEGORY_PATTERNS = {
+  engineering: [
+    /\b(refactor|extract|inline|rename|move file|split|merge|consolidat)\w*/i,
+    /\b(import|export|module structure|dependency|circular)\b/i,
+    /\b(error handling|try.catch|fallback|retry|timeout)\b/i,
+    /\b(lint|format|code style|indentation|semicolons?)\b/i,
+    /\b(type system|type annotation|type hierarchy|interface|generic|abstract|class hierarchy)\b/i,
+    /\b(cache strategy|memoiz|lazy load|bundle|tree.shak)\w*/i
+  ],
+  infrastructure: [
+    /\b(docker|kubernetes|ci\/cd|pipeline|deploy|build)\b/i,
+    /\b(database|migration|schema|index|query optimiz)\w*/i,
+    /\b(aws|gcp|azure|cloud|server|hosting)\b/i,
+    /\b(environment|env var|config file|secret|credential)\b/i,
+    /\b(monitoring|logging|alerting|metrics|observability)\b/i
+  ],
+  productBehavior: [
+    /\b(user.facing|user experience|product behavior|workflow)\b/i,
+    /\b(default value|default behavior|fallback behavior)\b/i,
+    /\b(business logic|business rule|domain)\b/i,
+    /\b(permission|role|access control|authorization)\b/i,
+    /\b(notification|email|alert to user)\b/i,
+    /\b(pricing|billing|subscription|plan|tier)\b/i,
+    /\b(feature flag|feature toggle|product feature)\b/i
+  ],
+  security: [
+    /\b(security|vulnerabilit|exploit|injection|xss|csrf)\w*/i,
+    /\b(authentication|auth|token|session|password|hash)\b/i,
+    /\b(sanitiz|escap|validat|whitelist|blocklist)\w*/i,
+    /\b(cors|csp|header|ssl|tls|certificate)\b/i,
+    /\b(rate.limit|brute.force|ddos|firewall)\b/i
+  ],
+  ux: [
+    /\b(layout|design|color|font|spacing|margin|padding)\b/i,
+    /\b(animation|transition|hover|focus|accessibility)\b/i,
+    /\b(copy text|label|placeholder|tooltip|user message)\b/i,
+    /\b(navigation|menu|sidebar|header|footer)\b/i,
+    /\b(responsive|mobile|breakpoint|viewport)\b/i
+  ],
+  naming: [
+    /\b(naming convention|naming pattern|rename)\b/i,
+    /\b(variable name|function name|file name|class name)\b/i,
+    /\b(camelCase|snake_case|PascalCase|kebab-case)\b/i,
+    /\b(prefix|suffix|abbreviat)\w*/i
+  ],
+  performance: [
+    /\b(performance|speed|latency|throughput|benchmark)\b/i,
+    /\b(memory leak|garbage|allocation|buffer)\b/i,
+    /\b(batch|chunk|stream|pagina)\w*/i,
+    /\b(optimize|optimis|efficient|bottleneck)\w*/i
+  ]
+};
+
+// ============================================================
+// Core Functions
+// ============================================================
+
+/**
+ * Get the decision authority config, merging defaults with user overrides
+ * @returns {Object} Authority config
+ */
+function getAuthorityConfig() {
+  const config = getConfig();
+  const userConfig = config.decisionAuthority ?? {};
+  return {
+    ...DEFAULT_AUTHORITY_CONFIG,
+    ...userConfig
+  };
+}
+
+/**
+ * Classify a decision text into a category
+ * @param {string} decisionText - The decision to classify
+ * @returns {{ category: string, authority: string, confidence: string }}
+ */
+function classifyDecision(decisionText) {
+  const authorityConfig = getAuthorityConfig();
+  // Patterns already use /i flag, no need for toLowerCase()
+  const text = decisionText;
+
+  // Score each category
+  const scores = {};
+  for (const [category, patterns] of Object.entries(CATEGORY_PATTERNS)) {
+    scores[category] = 0;
+    for (const pattern of patterns) {
+      if (pattern.test(text)) {
+        scores[category]++;
+      }
+    }
+  }
+
+  // Find highest scoring category
+  let bestCategory = 'productBehavior'; // Default to owner-decides (safest)
+  let bestScore = 0;
+
+  for (const [category, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = category;
+    }
+  }
+
+  // Determine confidence
+  const totalMatches = Object.values(scores).reduce((a, b) => a + b, 0);
+  let confidence = 'low';
+  if (bestScore >= 3) confidence = 'high';
+  else if (bestScore >= 2) confidence = 'medium';
+  else if (bestScore === 1 && totalMatches <= 2) confidence = 'medium';
+
+  // Low-confidence decisions default to owner-decides for safety
+  const authority = confidence === 'low'
+    ? 'owner-decides'
+    : (authorityConfig[bestCategory] ?? 'owner-decides');
+
+  return {
+    category: bestCategory,
+    authority,
+    confidence,
+    score: bestScore,
+    description: AUTHORITY_LEVELS[authority] ?? 'Unknown authority level'
+  };
+}
+
+/**
+ * Classify a batch of decisions and enforce maxOwnerQuestionsPerBatch
+ * @param {string[]} decisions - Array of decision texts
+ * @returns {{ classified: Object[], ownerQuestions: Object[], agentDecisions: Object[], truncated: boolean }}
+ */
+function batchClassify(decisions) {
+  const authorityConfig = getAuthorityConfig();
+  const maxOwner = authorityConfig.maxOwnerQuestionsPerBatch ?? 5;
+
+  const classified = decisions.map((text, idx) => ({
+    index: idx,
+    text,
+    ...classifyDecision(text)
+  }));
+
+  // Separate owner-decides from agent-decides
+  const ownerQuestions = classified.filter(d => d.authority === 'owner-decides');
+  const agentDecisions = classified.filter(d => d.authority !== 'owner-decides');
+
+  // Enforce max owner questions — overflow becomes agent-decides-report-after
+  let truncated = false;
+  if (ownerQuestions.length > maxOwner) {
+    truncated = true;
+    // Keep the first maxOwner, downgrade the rest
+    const overflow = ownerQuestions.splice(maxOwner);
+    for (const decision of overflow) {
+      decision.authority = 'agent-decides-report-after';
+      decision.description = AUTHORITY_LEVELS['agent-decides-report-after'];
+      decision.downgraded = true;
+      decision.downgradeReason = `Exceeded maxOwnerQuestionsPerBatch (${maxOwner})`;
+      agentDecisions.push(decision);
+    }
+  }
+
+  return {
+    classified,
+    ownerQuestions,
+    agentDecisions,
+    truncated,
+    maxOwner,
+    stats: {
+      total: decisions.length,
+      ownerDecides: ownerQuestions.length,
+      agentDecides: agentDecisions.length,
+      downgraded: truncated ? agentDecisions.filter(d => d.downgraded).length : 0
+    }
+  };
+}
+
+/**
+ * Update a category's authority level in config.json
+ * @param {string} category - Category name
+ * @param {string} authority - New authority level
+ * @returns {{ success: boolean, message: string }}
+ */
+function updateCategoryAuthority(category, authority) {
+  if (!CATEGORY_PATTERNS[category] && category !== 'maxOwnerQuestionsPerBatch') {
+    return { success: false, message: `Unknown category: ${category}. Valid: ${Object.keys(CATEGORY_PATTERNS).join(', ')}` };
+  }
+  if (category !== 'maxOwnerQuestionsPerBatch' && !AUTHORITY_LEVELS[authority]) {
+    return { success: false, message: `Unknown authority: ${authority}. Valid: ${Object.keys(AUTHORITY_LEVELS).join(', ')}` };
+  }
+
+  try {
+    const configPath = path.join(PATHS.workflow, 'config.json');
+    const config = safeJsonParse(configPath, {});
+
+    if (!config.decisionAuthority) {
+      config.decisionAuthority = {};
+    }
+
+    if (category === 'maxOwnerQuestionsPerBatch') {
+      const num = parseInt(authority, 10);
+      if (isNaN(num) || num < 1 || num > 20) {
+        return { success: false, message: 'maxOwnerQuestionsPerBatch must be a number between 1 and 20' };
+      }
+      config.decisionAuthority.maxOwnerQuestionsPerBatch = num;
+    } else {
+      config.decisionAuthority[category] = authority;
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return { success: true, message: `Updated ${category} → ${authority}` };
+  } catch (err) {
+    return { success: false, message: `Failed to update config: ${err.message}` };
+  }
+}
+
+// ============================================================
+// CLI Interface
+// ============================================================
+
+function main() {
+  const [,, command, ...args] = process.argv;
+
+  switch (command) {
+    case 'classify': {
+      const text = args.join(' ');
+      if (!text) {
+        console.error('Usage: flow-decision-authority.js classify <decision-text>');
+        process.exit(1);
+      }
+      const result = classifyDecision(text);
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'batch': {
+      const jsonInput = args[0];
+      if (!jsonInput) {
+        console.error('Usage: flow-decision-authority.js batch <json-array>');
+        process.exit(1);
+      }
+      try {
+        const decisions = JSON.parse(jsonInput);
+        if (!Array.isArray(decisions)) {
+          console.error('Input must be a JSON array of decision strings');
+          process.exit(1);
+        }
+        const result = batchClassify(decisions);
+        console.log(JSON.stringify(result, null, 2));
+      } catch (err) {
+        console.error(`Invalid JSON: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'update-category': {
+      const [category, authority] = args;
+      if (!category || !authority) {
+        console.error('Usage: flow-decision-authority.js update-category <category> <authority>');
+        process.exit(1);
+      }
+      const result = updateCategoryAuthority(category, authority);
+      if (result.success) {
+        console.log(result.message);
+      } else {
+        console.error(result.message);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'config': {
+      const config = getAuthorityConfig();
+      console.log(JSON.stringify(config, null, 2));
+      break;
+    }
+
+    default:
+      console.log('Wogi Flow - Decision Authority Framework');
+      console.log('');
+      console.log('Commands:');
+      console.log('  classify <text>                  Classify a decision');
+      console.log('  batch <json-array>               Classify multiple decisions');
+      console.log('  update-category <cat> <authority> Update a category authority');
+      console.log('  config                           Show current config');
+      console.log('');
+      console.log('Authority levels:');
+      for (const [level, desc] of Object.entries(AUTHORITY_LEVELS)) {
+        console.log(`  ${level}: ${desc}`);
+      }
+  }
+}
+
+// ============================================================
+// Exports
+// ============================================================
+
+module.exports = {
+  classifyDecision,
+  batchClassify,
+  getAuthorityConfig,
+  updateCategoryAuthority,
+  AUTHORITY_LEVELS,
+  DEFAULT_AUTHORITY_CONFIG,
+  CATEGORY_PATTERNS
+};
+
+if (require.main === module) {
+  main();
+}