agileflow 3.4.0 → 3.4.1

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 {