agileflow 3.3.0 → 3.4.1

package/scripts/messaging-bridge.js

@@ -49,6 +49,18 @@ function getFeatureFlags() {
   return _featureFlags;
 }
 
+let _teamEvents;
+function getTeamEvents() {
+  if (!_teamEvents) {
+    try {
+      _teamEvents = require('./lib/team-events');
+    } catch (e) {
+      return null;
+    }
+  }
+  return _teamEvents;
+}
+
 let _busUtils;
 function getBusUtils() {
   if (!_busUtils) {
@@ -277,6 +289,168 @@ function sendPlanDecision(rootDir, from, to, taskId, approved, reason, traceId)
   return sendMessage(rootDir, msg);
 }
 
+/**
+ * Send an inter-agent team message to the JSONL bus.
+ * Logs communication between teammates with optional trace_id for correlation.
+ *
+ * @param {string} rootDir - Project root
+ * @param {string} from - Sending agent name
+ * @param {string} to - Receiving agent name
+ * @param {string} content - Message content
+ * @param {string} [traceId] - Trace ID for team lifecycle correlation
+ * @returns {{ ok: boolean, native?: boolean }}
+ */
+function sendTeamMessage(rootDir, from, to, content, traceId) {
+  const msg = { from, to, type: 'team_message', content };
+  if (traceId) msg.trace_id = traceId;
+  const result = sendMessage(rootDir, msg);
+
+  // Always track in session-state for observability parity (both native and subagent modes)
+  try {
+    const teamEvents = getTeamEvents();
+    if (teamEvents) {
+      teamEvents.trackEvent(rootDir, 'team_message', {
+        from,
+        to,
+        trace_id: traceId,
+      });
+    }
+  } catch (e) {
+    // Non-critical
+  }
+
+  return result;
+}
+
+/**
+ * Send a team_completed event to the JSONL bus.
+ * Signals that a team run has finished all work.
+ *
+ * @param {string} rootDir - Project root
+ * @param {string} templateName - Team template name
+ * @param {string} [traceId] - Trace ID for team lifecycle correlation
+ * @param {object} [summary] - Optional summary data (duration_ms, tasks_completed, etc.)
+ * @returns {{ ok: boolean, native?: boolean }}
+ */
+function sendTeamCompleted(rootDir, templateName, traceId, summary) {
+  const msg = {
+    from: 'team-manager',
+    to: 'system',
+    type: 'team_completed',
+    template: templateName,
+    ...summary,
+  };
+  if (traceId) msg.trace_id = traceId;
+  return sendMessage(rootDir, msg);
+}
+
+/**
+ * Log a native SendMessage tool call to the JSONL bus.
+ * Used by agents to record native API calls for observability parity.
+ *
+ * @param {string} rootDir - Project root
+ * @param {string} from - Sending agent name
+ * @param {string} to - Receiving agent name
+ * @param {string} content - Message content
+ * @param {string} [traceId] - Trace ID for correlation
+ * @returns {{ ok: boolean }}
+ */
+function logNativeSend(rootDir, from, to, content, traceId) {
+  const msg = { from, to, type: 'native_send', content };
+  if (traceId) msg.trace_id = traceId;
+  const result = sendMessage(rootDir, msg);
+
+  try {
+    const teamEvents = getTeamEvents();
+    if (teamEvents) {
+      teamEvents.trackEvent(rootDir, 'team_message', {
+        from,
+        to,
+        trace_id: traceId,
+        native: true,
+      });
+    }
+  } catch (e) {
+    // Non-critical
+  }
+
+  return { ok: result.ok };
+}
+
+/**
+ * Log a native TeamCreate tool call to the JSONL bus.
+ *
+ * @param {string} rootDir - Project root
+ * @param {string} templateName - Team template name
+ * @param {string} [traceId] - Trace ID for correlation
+ * @param {number} [teammateCount] - Number of teammates created
+ * @returns {{ ok: boolean }}
+ */
+function logNativeTeamCreate(rootDir, templateName, traceId, teammateCount) {
+  const msg = {
+    from: 'team-manager',
+    to: 'system',
+    type: 'native_team_create',
+    template: templateName,
+  };
+  if (traceId) msg.trace_id = traceId;
+  if (typeof teammateCount === 'number') msg.teammate_count = teammateCount;
+  const result = sendMessage(rootDir, msg);
+
+  try {
+    const teamEvents = getTeamEvents();
+    if (teamEvents) {
+      teamEvents.trackEvent(rootDir, 'team_created', {
+        template: templateName,
+        trace_id: traceId,
+        teammate_count: teammateCount,
+        native: true,
+      });
+    }
+  } catch (e) {
+    // Non-critical
+  }
+
+  return { ok: result.ok };
+}
+
+/**
+ * Log a native team completion to the JSONL bus.
+ *
+ * @param {string} rootDir - Project root
+ * @param {string} templateName - Team template name
+ * @param {string} [traceId] - Trace ID for correlation
+ * @param {string} [summary] - Summary of completed work
+ * @returns {{ ok: boolean }}
+ */
+function logNativeTeamCompleted(rootDir, templateName, traceId, summary) {
+  const msg = {
+    from: 'team-manager',
+    to: 'system',
+    type: 'native_team_completed',
+    template: templateName,
+  };
+  if (traceId) msg.trace_id = traceId;
+  if (summary) msg.summary = summary;
+  const result = sendMessage(rootDir, msg);
+
+  try {
+    const teamEvents = getTeamEvents();
+    if (teamEvents) {
+      teamEvents.trackEvent(rootDir, 'team_completed', {
+        template: templateName,
+        trace_id: traceId,
+        summary,
+        native: true,
+      });
+    }
+  } catch (e) {
+    // Non-critical
+  }
+
+  return { ok: result.ok };
+}
+
 /**
  * Send a validation result message.
  */
@@ -324,10 +498,39 @@ function main() {
       break;
     }
 
+    case 'log-native-send': {
+      const [, from, to, ...contentParts] = args;
+      const content = contentParts.filter(p => !p.startsWith('--')).join(' ');
+      const traceArg = args.find(a => a.startsWith('--trace-id='));
+      const traceId = traceArg ? traceArg.slice(11) : undefined;
+      result = logNativeSend(rootDir, from, to, content, traceId);
+      break;
+    }
+
+    case 'log-native-create': {
+      const [, templateName] = args;
+      const traceArg = args.find(a => a.startsWith('--trace-id='));
+      const traceId = traceArg ? traceArg.slice(11) : undefined;
+      const countArg = args.find(a => a.startsWith('--count='));
+      const teammateCount = countArg ? parseInt(countArg.slice(8), 10) : undefined;
+      result = logNativeTeamCreate(rootDir, templateName, traceId, teammateCount);
+      break;
+    }
+
+    case 'log-native-completed': {
+      const [, templateName] = args;
+      const traceArg = args.find(a => a.startsWith('--trace-id='));
+      const traceId = traceArg ? traceArg.slice(11) : undefined;
+      const summaryArg = args.find(a => a.startsWith('--summary='));
+      const summary = summaryArg ? summaryArg.slice(10) : undefined;
+      result = logNativeTeamCompleted(rootDir, templateName, traceId, summary);
+      break;
+    }
+
     default:
       result = {
         ok: false,
-        error: `Unknown command: ${command}\nUsage: messaging-bridge.js <send|read|context>`,
+        error: `Unknown command: ${command}\nUsage: messaging-bridge.js <send|read|context|log-native-send|log-native-create|log-native-completed>`,
       };
   }
 
@@ -343,7 +546,12 @@ module.exports = {
   sendTaskAssignment,
   sendPlanProposal,
   sendPlanDecision,
+  sendTeamMessage,
+  sendTeamCompleted,
   sendValidationResult,
+  logNativeSend,
+  logNativeTeamCreate,
+  logNativeTeamCompleted,
   getBusLogPath,
   formatForNative,
 };

package/scripts/native-team-observer.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * native-team-observer.js - PostToolUse hook for native Agent Teams observability
+ *
+ * Logs native TeamCreate, SendMessage, and ListTeams tool calls to the
+ * AgileFlow JSONL bus so that native mode has observability parity with
+ * subagent mode (where team-manager.js handles dual-write).
+ *
+ * Exit codes:
+ *   0 - Always (observability hook, never blocks)
+ *
+ * Usage: Configured as PostToolUse hook in .claude/settings.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Tools this hook observes
+const NATIVE_TEAM_TOOLS = ['TeamCreate', 'SendMessage', 'ListTeams'];
+
+// Lazy-load modules to minimize startup cost
+let _featureFlags;
+function getFeatureFlags() {
+  if (!_featureFlags) {
+    const candidates = [
+      path.join(__dirname, '..', 'lib', 'feature-flags.js'),
+      path.join(__dirname, 'lib', 'feature-flags.js'),
+      path.join(process.cwd(), '.agileflow', 'lib', 'feature-flags.js'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate)) {
+          _featureFlags = require(candidate);
+          return _featureFlags;
+        }
+      } catch (e) {
+        // Try next
+      }
+    }
+    return null;
+  }
+  return _featureFlags;
+}
+
+let _paths;
+function getPaths() {
+  if (!_paths) {
+    const candidates = [
+      path.join(__dirname, '..', 'lib', 'paths.js'),
+      path.join(__dirname, 'lib', 'paths.js'),
+      path.join(process.cwd(), '.agileflow', 'lib', 'paths.js'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate)) {
+          _paths = require(candidate);
+          return _paths;
+        }
+      } catch (e) {
+        // Try next
+      }
+    }
+    return null;
+  }
+  return _paths;
+}
+
+let _messagingBridge;
+function getMessagingBridge() {
+  if (!_messagingBridge) {
+    const candidates = [
+      path.join(__dirname, 'messaging-bridge.js'),
+      path.join(process.cwd(), '.agileflow', 'scripts', 'messaging-bridge.js'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate)) {
+          _messagingBridge = require(candidate);
+          return _messagingBridge;
+        }
+      } catch (e) {
+        // Try next
+      }
+    }
+    return null;
+  }
+  return _messagingBridge;
+}
+
+/**
+ * Read trace_id from session-state.json active_team.
+ * Returns undefined if not available.
+ */
+function getTraceId(rootDir) {
+  try {
+    const paths = getPaths();
+    if (!paths) return undefined;
+    const sessionStatePath = paths.getSessionStatePath(rootDir);
+    if (!fs.existsSync(sessionStatePath)) return undefined;
+    const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+    return state.active_team?.trace_id;
+  } catch (e) {
+    return undefined;
+  }
+}
+
+/**
+ * Get the active_team template name from session-state.json.
+ */
+function getActiveTeamTemplate(rootDir) {
+  try {
+    const paths = getPaths();
+    if (!paths) return undefined;
+    const sessionStatePath = paths.getSessionStatePath(rootDir);
+    if (!fs.existsSync(sessionStatePath)) return undefined;
+    const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+    return state.active_team?.template;
+  } catch (e) {
+    return undefined;
+  }
+}
+
+/**
+ * Check if session-state has an active_team.
+ */
+function hasActiveTeam(rootDir) {
+  try {
+    const paths = getPaths();
+    if (!paths) return false;
+    const sessionStatePath = paths.getSessionStatePath(rootDir);
+    if (!fs.existsSync(sessionStatePath)) return false;
+    const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+    return !!state.active_team;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Read stdin and process
+let input = '';
+process.stdin.on('data', chunk => (input += chunk));
+process.stdin.on('end', () => {
+  try {
+    const context = JSON.parse(input);
+    const toolName = context.tool_name;
+
+    // Skip non-matching tools
+    if (!NATIVE_TEAM_TOOLS.includes(toolName)) {
+      process.exit(0);
+    }
+
+    // Check if native Agent Teams is enabled
+    const featureFlags = getFeatureFlags();
+    if (!featureFlags || !featureFlags.isAgentTeamsEnabled({ rootDir: process.cwd() })) {
+      process.exit(0);
+    }
+
+    const rootDir = process.cwd();
+    const bridge = getMessagingBridge();
+    if (!bridge) {
+      process.exit(0);
+    }
+
+    const traceId = getTraceId(rootDir);
+    const toolInput = context.tool_input || {};
+    const toolOutput = context.tool_output;
+
+    switch (toolName) {
+      case 'TeamCreate': {
+        const teamName = toolInput.name || 'unknown';
+        const teammateCount = Array.isArray(toolInput.teammates)
+          ? toolInput.teammates.length
+          : undefined;
+        bridge.logNativeTeamCreate(rootDir, teamName, traceId, teammateCount);
+        break;
+      }
+
+      case 'SendMessage': {
+        const to = toolInput.to || 'unknown';
+        const content = toolInput.message || toolInput.content || '';
+        bridge.logNativeSend(rootDir, 'lead', to, content, traceId);
+        break;
+      }
+
+      case 'ListTeams': {
+        // Detect team completion: ListTeams returns no active teams but
+        // session-state still has an active_team
+        if (hasActiveTeam(rootDir)) {
+          let noActiveTeams = false;
+          try {
+            if (typeof toolOutput === 'string') {
+              const parsed = JSON.parse(toolOutput);
+              noActiveTeams = Array.isArray(parsed) ? parsed.length === 0 : !parsed.teams?.length;
+            } else if (typeof toolOutput === 'object' && toolOutput !== null) {
+              noActiveTeams = Array.isArray(toolOutput)
+                ? toolOutput.length === 0
+                : !toolOutput.teams?.length;
+            }
+          } catch (e) {
+            // Can't parse output - skip completion detection
+          }
+
+          if (noActiveTeams) {
+            const template = getActiveTeamTemplate(rootDir) || 'unknown';
+            bridge.logNativeTeamCompleted(rootDir, template, traceId, 'completed');
+          }
+        }
+        break;
+      }
+    }
+  } catch (e) {
+    // Fail-open: observability hook should never block
+  }
+
+  process.exit(0);
+});
+
+// Handle empty stdin (timeout safety)
+setTimeout(() => process.exit(0), 4000);

package/scripts/obtain-context.js

@@ -158,6 +158,20 @@ function executeQueryMode(query) {
 // =============================================================================
 
 async function main() {
+  // Guard: Check .agileflow directory exists (covers all 94+ commands)
+  if (!fs.existsSync('.agileflow') && !fs.existsSync('docs/09-agents/status.json')) {
+    const red = '\x1b[38;5;203m';
+    const bold = '\x1b[1m';
+    const reset = '\x1b[0m';
+    const dim = '\x1b[2m';
+    console.error(`${red}${bold}AgileFlow is not initialized in this directory.${reset}`);
+    console.error(`${dim}Run: ${reset}${bold}npx agileflow setup${reset}`);
+    console.error(
+      `${dim}This will create the .agileflow/ directory with commands, hooks, and configuration.${reset}`
+    );
+    process.exit(1);
+  }
+
   // Register command for PreCompact
   registerCommand();
 

package/scripts/ralph-loop.js

@@ -279,16 +279,41 @@ const DISCRETION_CONDITIONS = {
     if (!Array.isArray(ac) || ac.length === 0) {
       return { passed: true, message: 'No AC defined (assuming complete)' };
     }
-    // Check for ac_status field or assume AC are verified if tests pass
+    // Check for ac_status field (supports auto-verified and likely-covered from ac-test-matcher)
     const acStatus = story.ac_status || {};
-    const allVerified = ac.every((_, i) => acStatus[i] === 'verified' || acStatus[i] === true);
+    const verifiedStatuses = ['verified', 'auto-verified', 'likely-covered'];
+    const verifiedCount = ac.filter(
+      (_, i) => verifiedStatuses.includes(acStatus[i]) || acStatus[i] === true
+    ).length;
+    const allVerified = verifiedCount === ac.length;
     return {
       passed: allVerified,
-      message: allVerified
-        ? 'All AC verified'
-        : `${Object.values(acStatus).filter(v => v === 'verified' || v === true).length}/${ac.length} AC verified`,
+      message: allVerified ? 'All AC verified' : `${verifiedCount}/${ac.length} AC verified`,
     };
   },
+
+  // AC test coverage condition (uses ac-test-matcher for automated checks)
+  'ac test coverage sufficient': (rootDir, ctx) => {
+    const storyId = ctx.currentStoryId;
+    if (!storyId) {
+      return { passed: false, message: 'No story ID in context' };
+    }
+    try {
+      const { matchACToTests } = require(path.join(__dirname, 'lib', 'ac-test-matcher'));
+      const result = matchACToTests(storyId, rootDir);
+      if (result.error) {
+        return { passed: false, message: result.error };
+      }
+      const threshold = ctx.coverageThreshold || 0.5;
+      const passed = result.coverage >= threshold;
+      return {
+        passed,
+        message: `AC test coverage: ${Math.round(result.coverage * 100)}% (${result.matched.length}/${result.total} matched, threshold: ${Math.round(threshold * 100)}%)`,
+      };
+    } catch (e) {
+      return { passed: false, message: `AC matcher error: ${e.message}` };
+    }
+  },
 };
 
 /**

package/scripts/smart-detect.js

@@ -24,6 +24,7 @@ const path = require('path');
 const { detectLifecyclePhase, getRelevantPhases } = require('./lib/lifecycle-detector');
 const { runDetectorsForPhases } = require('./lib/signal-detectors');
 const { buildCatalogWithStatus } = require('./lib/feature-catalog');
+const { detectScale, getScaleRecommendations } = require('./lib/scale-detector');
 
 let safeReadJSON, safeWriteJSON, tryOptional;
 try {
@@ -158,6 +159,24 @@ function extractSignals(prefetched, sessionState, metadata) {
   // Thresholds from metadata
   const thresholds = metadata?.smart_detect?.thresholds || {};
 
+  // Scale detection (cached, <200ms)
+  let scale = null;
+  try {
+    const scaleResult = detectScale({
+      rootDir: process.cwd(),
+      statusJson,
+      sessionState,
+    });
+    scale = {
+      tier: scaleResult.scale,
+      metrics: scaleResult.metrics,
+      recommendations: getScaleRecommendations(scaleResult.scale),
+      fromCache: scaleResult.fromCache,
+    };
+  } catch {
+    // Scale detection failure is non-critical
+  }
+
   return {
     statusJson,
     sessionState,
@@ -178,6 +197,7 @@ function extractSignals(prefetched, sessionState, metadata) {
     counts,
     storyCount,
     thresholds,
+    scale,
     session: {
       planModeActive,
       activeCommands: sessionState?.active_commands || [],
@@ -300,6 +320,7 @@ function analyze(prefetched, sessionState, metadata) {
     tests_passing: signals.tests.passing,
     on_feature_branch: signals.git.onFeatureBranch,
     story_counts: signals.counts,
+    scale: signals.scale ? signals.scale.tier : null,
   };
 
   return {