agileflow 2.84.2 → 2.86.0

package/scripts/obtain-context.js

@@ -21,10 +21,72 @@ const { execSync } = require('child_process');
 const { c: C, box } = require('../lib/colors');
 const { isValidCommandName } = require('../lib/validate');
 
-const DISPLAY_LIMIT = 30000; // Claude Code's Bash tool display limit
+// Claude Code's Bash tool truncates around 30K chars, but ANSI codes and
+// box-drawing characters (╭╮╰╯─│) are multi-byte UTF-8, so we need buffer.
+// Summary table should be the LAST thing visible before truncation.
+const DISPLAY_LIMIT = 29200;
 
-// Optional: Register command for PreCompact context preservation
+// =============================================================================
+// Progressive Disclosure: Section Activation
+// =============================================================================
+
+/**
+ * Parse command-line arguments and determine which sections to activate.
+ * Sections are conditionally loaded based on parameters like MODE=loop.
+ *
+ * Section mapping:
+ *   - MODE=loop          → activates: loop-mode
+ *   - Multi-session env  → activates: multi-session
+ *   - (Other triggers detected at runtime by the agent)
+ *
+ * @param {string[]} args - Command-line arguments after command name
+ * @returns {Object} { activeSections: string[], params: Object }
+ */
+function parseCommandArgs(args) {
+  const activeSections = [];
+  const params = {};
+
+  for (const arg of args) {
+    // Parse KEY=VALUE arguments
+    const match = arg.match(/^([A-Z_]+)=(.+)$/i);
+    if (match) {
+      const [, key, value] = match;
+      params[key.toUpperCase()] = value;
+    }
+  }
+
+  // Activate sections based on parameters
+  if (params.MODE === 'loop') {
+    activeSections.push('loop-mode');
+  }
+
+  if (params.VISUAL === 'true') {
+    activeSections.push('visual-e2e');
+  }
+
+  // Check for multi-session environment
+  const registryPath = '.agileflow/sessions/registry.json';
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      const sessionCount = Object.keys(registry.sessions || {}).length;
+      if (sessionCount > 1) {
+        activeSections.push('multi-session');
+      }
+    } catch {
+      // Silently ignore registry read errors
+    }
+  }
+
+  return { activeSections, params };
+}
+
+// Parse arguments
 const commandName = process.argv[2];
+const commandArgs = process.argv.slice(3);
+const { activeSections, params: commandParams } = parseCommandArgs(commandArgs);
+
+// Register command for PreCompact context preservation
 if (commandName && isValidCommandName(commandName)) {
   const sessionStatePath = 'docs/09-agents/session-state.json';
   if (fs.existsSync(sessionStatePath)) {
@@ -39,11 +101,13 @@ if (commandName && isValidCommandName(commandName)) {
       // Remove any existing entry for this command (avoid duplicates)
       state.active_commands = state.active_commands.filter(c => c.name !== commandName);
 
-      // Add the new command
+      // Add the new command with active sections for progressive disclosure
       state.active_commands.push({
         name: commandName,
         activated_at: new Date().toISOString(),
         state: {},
+        active_sections: activeSections,
+        params: commandParams,
       });
 
       // Remove legacy active_command field (only use active_commands array now)
@@ -259,6 +323,13 @@ function generateSummary() {
     summary += row('⭐ Up Next', readyStories.slice(0, 3).join(', '), C.skyBlue, C.skyBlue);
   }
 
+  // Progressive disclosure: Show active sections
+  if (activeSections.length > 0) {
+    summary += divider();
+    const sectionList = activeSections.join(', ');
+    summary += row('📖 Sections', sectionList, C.cyan, C.mintGreen);
+  }
+
   summary += divider();
 
   // Key files (using vibrant 256-color palette)
@@ -300,8 +371,6 @@ function generateSummary() {
   );
 
   summary += bottomBorder;
-  summary += '\n';
-  summary += `${C.dim}Full context continues below (Claude sees all)...${C.reset}\n\n`;
 
   return summary;
 }
@@ -317,6 +386,35 @@ function generateFullContent() {
   content += `${C.lavender}${C.bold}${title}${C.reset}\n`;
   content += `${C.dim}Generated: ${new Date().toISOString()}${C.reset}\n`;
 
+  // 0. PROGRESSIVE DISCLOSURE (section activation)
+  if (activeSections.length > 0) {
+    content += `\n${C.cyan}${C.bold}═══ 📖 Progressive Disclosure: Active Sections ═══${C.reset}\n`;
+    content += `${C.dim}The following sections are activated based on command parameters.${C.reset}\n`;
+    content += `${C.dim}Look for <!-- SECTION: name --> markers in the command file.${C.reset}\n\n`;
+
+    activeSections.forEach(section => {
+      content += `  ${C.mintGreen}✓${C.reset} ${C.bold}${section}${C.reset}\n`;
+    });
+
+    // Map sections to their triggers for context
+    const sectionDescriptions = {
+      'loop-mode': 'Autonomous epic execution (MODE=loop)',
+      'multi-session': 'Multi-session coordination detected',
+      'visual-e2e': 'Visual screenshot verification (VISUAL=true)',
+      'delegation': 'Expert spawning patterns (load when spawning)',
+      'stuck': 'Research prompt guidance (load after 2 failures)',
+      'plan-mode': 'Planning workflow details (load when entering plan mode)',
+      'tools': 'Tool usage guidance (load when needed)',
+    };
+
+    content += `\n${C.dim}Section meanings:${C.reset}\n`;
+    activeSections.forEach(section => {
+      const desc = sectionDescriptions[section] || 'Conditional content';
+      content += `  ${C.dim}• ${section}: ${desc}${C.reset}\n`;
+    });
+    content += '\n';
+  }
+
   // 1. GIT STATUS (using vibrant 256-color palette)
   content += `\n${C.skyBlue}${C.bold}═══ Git Status ═══${C.reset}\n`;
   const branch = safeExec('git branch --show-current') || 'unknown';
@@ -375,6 +473,19 @@ function generateFullContent() {
       // Backwards compatibility for old format
       content += `Active command: ${C.skyBlue}${sessionState.active_command.name}${C.reset}\n`;
     }
+
+    // Show batch loop status if active
+    const batchLoop = sessionState.batch_loop;
+    if (batchLoop && batchLoop.enabled) {
+      content += `\n${C.skyBlue}${C.bold}── Batch Loop Active ──${C.reset}\n`;
+      content += `Pattern: ${C.cyan}${batchLoop.pattern}${C.reset}\n`;
+      content += `Action: ${C.cyan}${batchLoop.action}${C.reset}\n`;
+      content += `Current: ${C.lightYellow}${batchLoop.current_item || 'none'}${C.reset}\n`;
+      const summary = batchLoop.summary || {};
+      content += `Progress: ${C.lightGreen}${summary.completed || 0}${C.reset}/${summary.total || 0} `;
+      content += `(${C.lightYellow}${summary.in_progress || 0}${C.reset} in progress)\n`;
+      content += `Iteration: ${batchLoop.iteration || 0}/${batchLoop.max_iterations || 50}\n`;
+    }
   } else {
     content += `${C.dim}No session-state.json found${C.reset}\n`;
   }
@@ -439,9 +550,7 @@ function generateFullContent() {
 
   if (fs.existsSync(storyClaimingPath) || fs.existsSync(altStoryClaimingPath)) {
     try {
-      const claimPath = fs.existsSync(storyClaimingPath)
-        ? storyClaimingPath
-        : altStoryClaimingPath;
+      const claimPath = fs.existsSync(storyClaimingPath) ? storyClaimingPath : altStoryClaimingPath;
       const storyClaiming = require(claimPath);
 
       // Get stories claimed by other sessions
@@ -450,7 +559,9 @@ function generateFullContent() {
         content += `\n${C.amber}${C.bold}═══ 🔒 Claimed Stories ═══${C.reset}\n`;
         content += `${C.dim}Stories locked by other sessions - pick a different one${C.reset}\n`;
         othersResult.stories.forEach(story => {
-          const sessionDir = story.claimedBy?.path ? path.basename(story.claimedBy.path) : 'unknown';
+          const sessionDir = story.claimedBy?.path
+            ? path.basename(story.claimedBy.path)
+            : 'unknown';
           content += `  ${C.coral}🔒${C.reset} ${C.lavender}${story.id}${C.reset} "${story.title}" ${C.dim}→ Session ${story.claimedBy?.session_id || '?'} (${sessionDir})${C.reset}\n`;
         });
         content += '\n';
@@ -476,9 +587,7 @@ function generateFullContent() {
 
   if (fs.existsSync(fileTrackingPath) || fs.existsSync(altFileTrackingPath)) {
     try {
-      const trackPath = fs.existsSync(fileTrackingPath)
-        ? fileTrackingPath
-        : altFileTrackingPath;
+      const trackPath = fs.existsSync(fileTrackingPath) ? fileTrackingPath : altFileTrackingPath;
       const fileTracking = require(trackPath);
 
       // Get file overlaps with other sessions
@@ -487,10 +596,12 @@ function generateFullContent() {
         content += `\n${C.amber}${C.bold}═══ ⚠️  File Overlaps ═══${C.reset}\n`;
         content += `${C.dim}Files also edited by other sessions - conflicts auto-resolved during merge${C.reset}\n`;
         overlapsResult.overlaps.forEach(overlap => {
-          const sessionInfo = overlap.otherSessions.map(s => {
-            const dir = path.basename(s.path);
-            return `Session ${s.id} (${dir})`;
-          }).join(', ');
+          const sessionInfo = overlap.otherSessions
+            .map(s => {
+              const dir = path.basename(s.path);
+              return `Session ${s.id} (${dir})`;
+            })
+            .join(', ');
           content += `  ${C.amber}⚠${C.reset} ${C.lavender}${overlap.file}${C.reset} ${C.dim}→ ${sessionInfo}${C.reset}\n`;
         });
         content += '\n';
@@ -523,7 +634,8 @@ function generateFullContent() {
   // 6. VISUAL E2E STATUS (detect from metadata or filesystem)
   const metadata = safeReadJSON('docs/00-meta/agileflow-metadata.json');
   const visualE2eConfig = metadata?.features?.visual_e2e;
-  const playwrightExists = fs.existsSync('playwright.config.ts') || fs.existsSync('playwright.config.js');
+  const playwrightExists =
+    fs.existsSync('playwright.config.ts') || fs.existsSync('playwright.config.js');
   const screenshotsExists = fs.existsSync('screenshots');
   const testsE2eExists = fs.existsSync('tests/e2e');
 
@@ -706,11 +818,11 @@ if (fullContent.length <= cutoffPoint) {
   console.log(fullContent);
   console.log(summary);
 } else {
-  // Split: content before cutoff + summary + content after cutoff
+  // Output content up to cutoff, then summary as the LAST visible thing.
+  // Don't output contentAfter - it would bleed into visible area before truncation,
+  // and Claude only sees ~30K chars from Bash anyway.
   const contentBefore = fullContent.substring(0, cutoffPoint);
-  const contentAfter = fullContent.substring(cutoffPoint);
 
   console.log(contentBefore);
   console.log(summary);
-  console.log(contentAfter);
 }

package/scripts/session-boundary.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * session-boundary.js - PreToolUse hook for Edit/Write session isolation
+ *
+ * Prevents Claude from editing files outside the active session directory.
+ * Used with PreToolUse:Edit and PreToolUse:Write hooks.
+ *
+ * Exit codes:
+ *   0 = Allow the operation
+ *   2 = Block with message (shown to Claude)
+ *
+ * Input: JSON on stdin with tool_input.file_path
+ * Output: Error message to stderr if blocking
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Inline colors (no external dependency)
+const c = {
+  coral: '\x1b[38;5;203m',
+  dim: '\x1b[2m',
+  reset: '\x1b[0m',
+};
+
+const STDIN_TIMEOUT_MS = 4000;
+
+// Find project root by looking for .agileflow directory
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (fs.existsSync(path.join(dir, '.agileflow'))) {
+      return dir;
+    }
+    if (fs.existsSync(path.join(dir, 'docs', '09-agents'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+const ROOT = findProjectRoot();
+const SESSION_STATE_PATH = path.join(ROOT, 'docs', '09-agents', 'session-state.json');
+
+// Get active session from session-state.json
+function getActiveSession() {
+  try {
+    if (!fs.existsSync(SESSION_STATE_PATH)) {
+      return null;
+    }
+    const data = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    return data.active_session || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Check if filePath is inside sessionPath
+function isInsideSession(filePath, sessionPath) {
+  const normalizedFile = path.resolve(filePath);
+  const normalizedSession = path.resolve(sessionPath);
+
+  return (
+    normalizedFile.startsWith(normalizedSession + path.sep) || normalizedFile === normalizedSession
+  );
+}
+
+// Output blocked message
+function outputBlocked(filePath, activeSession) {
+  const sessionName = activeSession.nickname
+    ? `"${activeSession.nickname}"`
+    : `Session ${activeSession.id}`;
+
+  console.error(`${c.coral}[SESSION BOUNDARY]${c.reset} Edit blocked`);
+  console.error(`${c.dim}File: ${filePath}${c.reset}`);
+  console.error(`${c.dim}Active session: ${sessionName} (${activeSession.path})${c.reset}`);
+  console.error('');
+  console.error(`${c.dim}The file is outside the active session directory.${c.reset}`);
+  console.error(`${c.dim}Use /agileflow:session:resume to switch sessions first.${c.reset}`);
+}
+
+// Main logic - run with stdin events (async)
+function main() {
+  let inputData = '';
+
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', chunk => {
+    inputData += chunk;
+  });
+
+  process.stdin.on('end', () => {
+    try {
+      // Parse tool input from Claude Code
+      const hookData = JSON.parse(inputData);
+      const filePath = hookData?.tool_input?.file_path;
+
+      if (!filePath) {
+        // No file path in input - allow
+        process.exit(0);
+      }
+
+      // Get active session
+      const activeSession = getActiveSession();
+
+      if (!activeSession || !activeSession.path) {
+        // No active session set - allow all (normal behavior)
+        process.exit(0);
+      }
+
+      // Check if file is inside active session
+      if (isInsideSession(filePath, activeSession.path)) {
+        // File is inside active session - allow
+        process.exit(0);
+      }
+
+      // File is OUTSIDE active session - BLOCK
+      outputBlocked(filePath, activeSession);
+      process.exit(2);
+    } catch (e) {
+      // Parse error or other issue - fail open
+      process.exit(0);
+    }
+  });
+
+  // Handle no stdin (direct invocation)
+  process.stdin.on('error', () => {
+    process.exit(0);
+  });
+
+  // Set timeout to prevent hanging
+  setTimeout(() => {
+    process.exit(0);
+  }, STDIN_TIMEOUT_MS);
+}
+
+main();