agileflow 2.84.1 → 2.85.0

package/scripts/obtain-context.js

@@ -21,7 +21,10 @@ 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
 const commandName = process.argv[2];
@@ -300,8 +303,6 @@ function generateSummary() {
   );
 
   summary += bottomBorder;
-  summary += '\n';
-  summary += `${C.dim}Full context continues below (Claude sees all)...${C.reset}\n\n`;
 
   return summary;
 }
@@ -706,11 +707,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();

package/scripts/session-manager.js

@@ -786,6 +786,79 @@ function main() {
       break;
     }
 
+    // PERFORMANCE: Combined command for welcome script (saves ~200ms from 3 subprocess calls)
+    case 'full-status': {
+      const nickname = args[1] || null;
+      const cwd = process.cwd();
+
+      // Register in single pass (combines register + count + status)
+      const registry = loadRegistry();
+      const cleaned = cleanupStaleLocks(registry);
+      const branch = getCurrentBranch();
+      const story = getCurrentStory();
+      const pid = process.ppid || process.pid;
+
+      // Find or create session
+      let sessionId = null;
+      let isNew = false;
+      for (const [id, session] of Object.entries(registry.sessions)) {
+        if (session.path === cwd) {
+          sessionId = id;
+          break;
+        }
+      }
+
+      if (sessionId) {
+        // Update existing
+        registry.sessions[sessionId].branch = branch;
+        registry.sessions[sessionId].story = story ? story.id : null;
+        registry.sessions[sessionId].last_active = new Date().toISOString();
+        if (nickname) registry.sessions[sessionId].nickname = nickname;
+        writeLock(sessionId, pid);
+      } else {
+        // Create new
+        sessionId = String(registry.next_id);
+        registry.next_id++;
+        registry.sessions[sessionId] = {
+          path: cwd,
+          branch,
+          story: story ? story.id : null,
+          nickname: nickname || null,
+          created: new Date().toISOString(),
+          last_active: new Date().toISOString(),
+          is_main: cwd === ROOT,
+        };
+        writeLock(sessionId, pid);
+        isNew = true;
+      }
+      saveRegistry(registry);
+
+      // Build session list and counts
+      const sessions = [];
+      let otherActive = 0;
+      for (const [id, session] of Object.entries(registry.sessions)) {
+        const active = isSessionActive(id);
+        const isCurrent = session.path === cwd;
+        sessions.push({ id, ...session, active, current: isCurrent });
+        if (active && !isCurrent) otherActive++;
+      }
+
+      const current = sessions.find(s => s.current) || null;
+
+      console.log(
+        JSON.stringify({
+          registered: true,
+          id: sessionId,
+          isNew,
+          current,
+          otherActive,
+          total: sessions.length,
+          cleaned,
+        })
+      );
+      break;
+    }
+
     case 'check-merge': {
       const sessionId = args[1];
       if (!sessionId) {
@@ -888,6 +961,29 @@ function main() {
       break;
     }
 
+    case 'switch': {
+      const sessionIdOrNickname = args[1];
+      if (!sessionIdOrNickname) {
+        console.log(JSON.stringify({ success: false, error: 'Session ID or nickname required' }));
+        return;
+      }
+      const result = switchSession(sessionIdOrNickname);
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'active': {
+      const result = getActiveSession();
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'clear-active': {
+      const result = clearActiveSession();
+      console.log(JSON.stringify(result));
+      break;
+    }
+
     case 'help':
     default:
       console.log(`
@@ -901,6 +997,10 @@ ${c.cyan}Commands:${c.reset}
   count                   Count other active sessions
   delete <id> [--remove-worktree]  Delete session
   status                  Get current session status
+  full-status             Combined register+count+status (optimized)
+  switch <id|nickname>    Switch active session context (for /add-dir)
+  active                  Get currently switched session (if any)
+  clear-active            Clear switched session (back to main)
   check-merge <id>        Check if session is mergeable to main
   merge-preview <id>      Preview commits/files to be merged
   integrate <id> [opts]   Merge session to main and cleanup
@@ -1392,6 +1492,126 @@ function getMergeHistory() {
   }
 }
 
+// Session state file path
+const SESSION_STATE_PATH = path.join(ROOT, 'docs', '09-agents', 'session-state.json');
+
+/**
+ * Switch active session context (for use with /add-dir).
+ * Updates session-state.json with active_session info.
+ *
+ * @param {string} sessionIdOrNickname - Session ID or nickname to switch to
+ * @returns {{ success: boolean, session?: object, path?: string, error?: string }}
+ */
+function switchSession(sessionIdOrNickname) {
+  const registry = loadRegistry();
+
+  // Find session by ID or nickname
+  let targetSession = null;
+  let targetId = null;
+
+  for (const [id, session] of Object.entries(registry.sessions)) {
+    if (id === sessionIdOrNickname || session.nickname === sessionIdOrNickname) {
+      targetSession = session;
+      targetId = id;
+      break;
+    }
+  }
+
+  if (!targetSession) {
+    return { success: false, error: `Session "${sessionIdOrNickname}" not found` };
+  }
+
+  // Verify the session path exists
+  if (!fs.existsSync(targetSession.path)) {
+    return {
+      success: false,
+      error: `Session directory does not exist: ${targetSession.path}`,
+    };
+  }
+
+  // Load or create session-state.json
+  let sessionState = {};
+  if (fs.existsSync(SESSION_STATE_PATH)) {
+    try {
+      sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    } catch (e) {
+      // Start fresh
+    }
+  }
+
+  // Update active_session
+  sessionState.active_session = {
+    id: targetId,
+    nickname: targetSession.nickname,
+    path: targetSession.path,
+    branch: targetSession.branch,
+    switched_at: new Date().toISOString(),
+    original_cwd: ROOT,
+  };
+
+  // Save session-state.json
+  const stateDir = path.dirname(SESSION_STATE_PATH);
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+  fs.writeFileSync(SESSION_STATE_PATH, JSON.stringify(sessionState, null, 2) + '\n');
+
+  // Update session last_active
+  registry.sessions[targetId].last_active = new Date().toISOString();
+  saveRegistry(registry);
+
+  return {
+    success: true,
+    session: {
+      id: targetId,
+      nickname: targetSession.nickname,
+      path: targetSession.path,
+      branch: targetSession.branch,
+    },
+    path: targetSession.path,
+    addDirCommand: `/add-dir ${targetSession.path}`,
+  };
+}
+
+/**
+ * Clear active session (switch back to main/original).
+ * @returns {{ success: boolean }}
+ */
+function clearActiveSession() {
+  if (!fs.existsSync(SESSION_STATE_PATH)) {
+    return { success: true };
+  }
+
+  try {
+    const sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    delete sessionState.active_session;
+    fs.writeFileSync(SESSION_STATE_PATH, JSON.stringify(sessionState, null, 2) + '\n');
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Get current active session (if switched).
+ * @returns {{ active: boolean, session?: object }}
+ */
+function getActiveSession() {
+  if (!fs.existsSync(SESSION_STATE_PATH)) {
+    return { active: false };
+  }
+
+  try {
+    const sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    if (sessionState.active_session) {
+      return { active: true, session: sessionState.active_session };
+    }
+    return { active: false };
+  } catch (e) {
+    return { active: false };
+  }
+}
+
 // Export for use as module
 module.exports = {
   loadRegistry,
@@ -1415,6 +1635,10 @@ module.exports = {
   categorizeFile,
   getMergeStrategy,
   getMergeHistory,
+  // Session switching
+  switchSession,
+  clearActiveSession,
+  getActiveSession,
 };
 
 // Run CLI if executed directly

package/src/core/commands/session/new.md

@@ -133,26 +133,38 @@ Then create with specified branch:
 node .agileflow/scripts/session-manager.js create --branch {branch_name}
 ```
 
-### Step 5: Display Success Message
+### Step 5: Display Success with Switch Command
 
-Show the created session details and the command to start working:
+After session creation succeeds:
 
+1. First, activate boundary protection for the new session:
+```bash
+node .agileflow/scripts/session-manager.js switch {new_session_id}
 ```
-✓ Created Session {id} "{nickname}"
 
-  Workspace: ../project-{name}
-  Branch:    session-{id}-{name}
+2. Then show the `/add-dir` command for the user to switch:
 
-┌─────────────────────────────────────────────────────────┐
-│ To start working in this session, run:                  │
-│                                                         │
-│   cd ../project-{name} && claude                        │
-│                                                         │
-└─────────────────────────────────────────────────────────┘
+```
+✅ Created Session {id} "{nickname}"
+
+┌───────────┬────────────────────────────────────────────┐
+│ Session   │ {id} "{nickname}"                          │
+│ Workspace │ {path}                                     │
+│ Branch    │ {branch}                                   │
+└───────────┴────────────────────────────────────────────┘
+
+To switch to this session, run:
+
+  /add-dir {path}
 
-💡 Tip: Use /agileflow:session:resume to see all sessions
+💡 Use /agileflow:session:resume to list all sessions
 ```
 
+**WHY /add-dir instead of cd && claude:**
+- Stays in the same terminal and conversation
+- One short command to type
+- Immediately enables file access to the new session directory
+
 ## Error Handling
 
 - **Directory exists**: Suggest different name or manual cleanup
@@ -228,21 +240,26 @@ If user selects "Auto-create":
 node .agileflow/scripts/session-manager.js create
 ```
 
-Display:
+Parse JSON result, then activate boundary protection:
+```bash
+node .agileflow/scripts/session-manager.js switch {new_id}
 ```
-✓ Created Session {id}
 
-  Workspace: ../project-{id}
-  Branch:    session-{id}
+Then display:
+```
+✅ Created Session {id}
 
-┌─────────────────────────────────────────────────────────┐
-│ To start working in this session, run:                  │
-│                                                         │
-│   cd ../project-{id} && claude                          │
-│                                                         │
-└─────────────────────────────────────────────────────────┘
+┌───────────┬────────────────────────────────────────────┐
+│ Session   │ {id}                                       │
+│ Workspace │ {path}                                     │
+│ Branch    │ {branch}                                   │
+└───────────┴────────────────────────────────────────────┘
+
+To switch to this session, run:
 
-💡 Tip: Use /agileflow:session:resume to see all sessions
+  /add-dir {path}
+
+💡 Use /agileflow:session:resume to list all sessions
 ```
 
 ---
@@ -274,21 +291,26 @@ Then create:
 node .agileflow/scripts/session-manager.js create --nickname {name}
 ```
 
-Display:
+Parse JSON result, then activate boundary protection:
+```bash
+node .agileflow/scripts/session-manager.js switch {new_id}
 ```
-✓ Created Session {id} "{name}"
 
-  Workspace: ../project-{name}
-  Branch:    session-{id}-{name}
+Then display:
+```
+✅ Created Session {id} "{name}"
 
-┌─────────────────────────────────────────────────────────┐
-│ To start working in this session, run:                  │
-│                                                         │
-│   cd ../project-{name} && claude                        │
-│                                                         │
-└─────────────────────────────────────────────────────────┘
+┌───────────┬────────────────────────────────────────────┐
+│ Session   │ {id} "{name}"                              │
+│ Workspace │ {path}                                     │
+│ Branch    │ {branch}                                   │
+└───────────┴────────────────────────────────────────────┘
+
+To switch to this session, run:
+
+  /add-dir {path}
 
-💡 Tip: Use /agileflow:session:resume to see all sessions
+💡 Use /agileflow:session:resume to list all sessions
 ```
 
 ---
@@ -327,7 +349,12 @@ git branch --format='%(refname:short)'
 node .agileflow/scripts/session-manager.js create --branch {branch_name}
 ```
 
-Display success as above.
+5. Parse JSON result, then activate boundary protection:
+```bash
+node .agileflow/scripts/session-manager.js switch {new_id}
+```
+
+6. Display success as above with `/add-dir` command.
 
 ---
 
@@ -365,21 +392,23 @@ Try running: git status
 
 All three options show same format:
 ```
-✓ Created Session {id} ["{nickname}" OR empty]
+✅ Created Session {id} ["{nickname}" OR empty]
 
-  Workspace: ../project-{path}
-  Branch:    {branch_name}
+┌───────────┬────────────────────────────────────────────┐
+│ Session   │ {id} ["{nickname}" or empty]               │
+│ Workspace │ {path}                                     │
+│ Branch    │ {branch}                                   │
+└───────────┴────────────────────────────────────────────┘
 
-┌─────────────────────────────────────────────────────────┐
-│ To start working in this session, run:                  │
-│                                                         │
-│   {cd_command}                                          │
-│                                                         │
-└─────────────────────────────────────────────────────────┘
+To switch to this session, run:
 
-💡 Tip: Use /agileflow:session:resume to see all sessions
+  /add-dir {path}
+
+💡 Use /agileflow:session:resume to list all sessions
 ```
 
+**Use /add-dir instead of cd && claude** - stays in same terminal/conversation.
+
 ---
 
 ### KEY FILES TO REMEMBER
@@ -400,7 +429,8 @@ All three options show same format:
 4. **User selects** → Option 1, 2, or 3
 5. **Handle selection** → Different flow for each
 6. **Create session** → Call manager script
-7. **Show success** → Display cd command
+7. **Activate boundary** → `session-manager.js switch {new_id}`
+8. **Show success** → Display `/add-dir {path}` command for user to run
 
 ---
 
@@ -420,7 +450,7 @@ All three options show same format:
 ❌ Don't show more/fewer than 3 initial options
 ❌ Don't create session without explicit user choice
 ❌ Don't skip error handling (directory exists, branch conflict)
-❌ Don't forget cd command in success message
+❌ Don't show old "cd && claude" command - use /add-dir instead
 ❌ Show different success formats for different methods
 
 ### DO THESE INSTEAD
@@ -429,7 +459,7 @@ All three options show same format:
 ✅ Always show exactly 3 options
 ✅ Wait for user to select before creating
 ✅ Handle all error cases gracefully
-✅ Always show cd command in success
+✅ Show `/add-dir {path}` command for user to switch
 ✅ Use consistent success format
 
 ---
@@ -442,7 +472,8 @@ All three options show same format:
 - Each option leads to different flow
 - Use AskUserQuestion for user selections
 - Handle all error cases (directory, branch, git)
-- Return success with cd command
+- **Run `session-manager.js switch {new_id}` AFTER creating session** (enables boundary protection)
+- Show `/add-dir {path}` command for user to switch (NOT cd && claude)
 - Show tip to use /agileflow:session:resume
 
 <!-- COMPACT_SUMMARY_END -->