agileflow 2.99.0 → 2.99.1

package/scripts/spawn-parallel.js

@@ -31,6 +31,7 @@ const { c, success, warning, error, dim, bold } = require('../lib/colors');
 const { getProjectRoot, getStatusPath } = require('../lib/paths');
 const { safeReadJSON } = require('../lib/errors');
 const { getInheritedFlags, detectParentSessionFlags } = require('../lib/flag-detection');
+const { feedback } = require('../lib/feedback');
 
 // Import session manager functions
 const sessionManager = require('./session-manager');
@@ -319,15 +320,19 @@ async function spawn(args) {
     console.log('');
   }
 
+  const task = feedback.task('Creating parallel sessions', sessionsToCreate.length);
   const createdSessions = [];
   for (const sessionSpec of sessionsToCreate) {
+    const spinner = feedback.spinner(`Creating session: ${sessionSpec.nickname}`);
+    spinner.start();
+
     const result = await sessionManager.createSession({
       nickname: sessionSpec.nickname,
       branch: sessionSpec.branch,
     });
 
     if (!result.success) {
-      console.error(error(`Failed to create session ${sessionSpec.nickname}: ${result.error}`));
+      spinner.fail(`Failed: ${sessionSpec.nickname} - ${result.error}`);
       continue;
     }
 
@@ -343,8 +348,10 @@ async function spawn(args) {
     // Show what was copied
     const copied = [...(result.envFilesCopied || []), ...(result.foldersCopied || [])];
     const copyInfo = copied.length ? dim(` (copied: ${copied.join(', ')})`) : '';
-    console.log(success(`  ✓ Session ${result.sessionId}: ${sessionSpec.nickname}${copyInfo}`));
+    spinner.succeed(`Session ${result.sessionId}: ${sessionSpec.nickname}${copyInfo}`);
+    task.step(`${sessionSpec.nickname}`);
   }
+  task.complete(`Created ${createdSessions.length} sessions`);
 
   if (createdSessions.length === 0) {
     console.error(error('\nNo sessions were created.'));
@@ -520,17 +527,14 @@ async function addWindow(args) {
   // Get window number
   let windowIndex;
   try {
-    windowIndex = execFileSync(
-      'tmux',
-      ['list-windows', '-t', currentSession, '-F', '#I:#W'],
-      {
+    windowIndex =
+      execFileSync('tmux', ['list-windows', '-t', currentSession, '-F', '#I:#W'], {
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe'],
-      }
-    )
-      .split('\n')
-      .find(line => line.endsWith(`:${windowName}`))
-      ?.split(':')[0] || '?';
+      })
+        .split('\n')
+        .find(line => line.endsWith(`:${windowName}`))
+        ?.split(':')[0] || '?';
   } catch {
     windowIndex = '?';
   }

package/src/core/commands/configure.md

@@ -443,6 +443,61 @@ When creating new sessions with /agileflow:session:new, this will be the
 recommended option. You can still choose a different mode per-session.
 ```
 
+**If user selected "Skip permissions" or "Accept edits only"**, offer Claude settings integration:
+
+```xml
+<invoke name="AskUserQuestion">
+<parameter name="questions">[{
+  "question": "Also configure Claude to default to this mode?",
+  "header": "Claude settings",
+  "multiSelect": false,
+  "options": [
+    {"label": "af wrapper only (Recommended)", "description": "The 'af' command already uses this setting. No other changes needed."},
+    {"label": "Also add shell alias", "description": "Add alias to your shell profile so 'claude' also uses this mode"},
+    {"label": "No thanks", "description": "Keep current setup"}
+  ]
+}]</parameter>
+</invoke>
+```
+
+**If "Also add shell alias" selected:**
+
+Determine the flag based on the selected mode:
+- `skip-permissions` → `--dangerously-skip-permissions`
+- `accept-edits` → `--permission-mode acceptEdits`
+
+```bash
+# Detect shell config file
+SHELL_RC="$HOME/.bashrc"
+[ -f "$HOME/.zshrc" ] && SHELL_RC="$HOME/.zshrc"
+
+# Check if alias already exists
+grep -q 'alias claude=' "$SHELL_RC" 2>/dev/null
+```
+
+If alias doesn't exist, add it using the Edit tool on the shell RC file:
+```bash
+# Append alias (idempotent - only if not already present)
+# For skip-permissions:
+echo 'alias claude="claude --dangerously-skip-permissions"' >> "$SHELL_RC"
+# For accept-edits:
+echo 'alias claude="claude --permission-mode acceptEdits"' >> "$SHELL_RC"
+```
+
+Display:
+```
+✅ Shell alias added to {SHELL_RC}
+Run `source {SHELL_RC}` or open a new terminal for the alias to take effect.
+
+To remove later: edit {SHELL_RC} and remove the 'alias claude=' line.
+```
+
+**If "af wrapper only" or "No thanks" selected:**
+```
+The 'af' command already reads the configured startup mode automatically.
+No additional changes needed.
+```
+
 ---
 
 ### If "Infrastructure" selected

package/src/core/commands/serve.md

@@ -0,0 +1,127 @@
+---
+description: Start Dashboard WebSocket server for real-time UI communication
+argument-hint: "[OPTIONS: --port 8765 --api-key KEY --tunnel]"
+compact_context:
+  priority: medium
+  preserve_rules:
+    - "ACTIVE COMMAND: /agileflow:serve - Dashboard WebSocket server"
+    - "Server provides real-time communication for Cloud Dashboard"
+    - "Default port: 8765, binds to 0.0.0.0"
+  state_fields:
+    - server_running
+    - server_port
+    - tunnel_url
+---
+
+# serve
+
+Start the AgileFlow Dashboard WebSocket server for real-time communication with the Cloud Dashboard UI.
+
+---
+
+## Overview
+
+The serve command starts a WebSocket server that the AgileFlow Dashboard connects to for real-time features: chat streaming, git operations, terminal access, and automation management.
+
+**Key Features**:
+- **WebSocket protocol**: Real-time bidirectional communication with dashboard
+- **Claude CLI bridge**: Streaming text deltas and tool call forwarding
+- **Git integration**: Status, diff, commit, branch operations via WebSocket
+- **Terminal channels**: Remote terminal sessions scoped to project directory
+- **Automation runner**: Trigger and monitor automations from the dashboard
+- **Auth support**: Optional API key authentication for secure connections
+- **Tunnel support**: ngrok integration for remote access
+
+---
+
+## Usage
+
+### Start with Default Settings
+
+```
+/agileflow:serve
+```
+
+Starts the WebSocket server on port 8765, binding to 0.0.0.0.
+
+### Start with Custom Port and Auth
+
+```
+/agileflow:serve --port 9000 --api-key agf_secret123
+```
+
+### Start with Tunnel for Remote Access
+
+```
+/agileflow:serve --tunnel
+```
+
+Starts ngrok tunnel for remote dashboard connections (requires ngrok installed).
+
+---
+
+## Options
+
+| Option | Short | Default | Description |
+|--------|-------|---------|-------------|
+| `--port` | `-p` | `8765` | Port to listen on |
+| `--host` | `-h` | `0.0.0.0` | Host to bind to |
+| `--api-key` | `-k` | none | API key for authentication |
+| `--require-auth` | | `false` | Require API key for connections |
+| `--tunnel` | `-t` | `false` | Start ngrok tunnel |
+
+---
+
+## Prompt
+
+ROLE: Dashboard Server Manager
+
+Run the dashboard WebSocket server using the installed script:
+
+```bash
+node .agileflow/scripts/dashboard-serve.js [OPTIONS]
+```
+
+**Pass through any user-provided options** (--port, --api-key, --tunnel, etc.) directly to the script.
+
+WORKFLOW:
+
+1. **Start the server**:
+   ```bash
+   node .agileflow/scripts/dashboard-serve.js --port 8765
+   ```
+
+2. **Report the connection URL** to the user:
+   - Local: `ws://localhost:<port>`
+   - If tunnel enabled: the ngrok URL
+
+3. **Keep the server running** - it runs in the foreground. The user can stop it with Ctrl+C.
+
+4. If the user specifies `--api-key`, pass it through:
+   ```bash
+   node .agileflow/scripts/dashboard-serve.js --port 8765 --api-key agf_secret123
+   ```
+
+5. If the user specifies `--tunnel`, pass it through:
+   ```bash
+   node .agileflow/scripts/dashboard-serve.js --tunnel
+   ```
+
+---
+
+## Dashboard Connection
+
+Once the server is running, the Cloud Dashboard connects via WebSocket:
+
+1. Open the AgileFlow Dashboard
+2. Enter the connection URL: `ws://localhost:8765` (or tunnel URL)
+3. If auth is enabled, provide the API key
+4. Dashboard receives real-time updates for chat, git, terminal, and automations
+
+---
+
+## Related Commands
+
+- `/agileflow:api` - REST API server (read-only state exposure)
+- `/agileflow:session:status` - View current session state
+- `/agileflow:board` - Visual kanban board

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

@@ -224,22 +224,33 @@ Continue to **Merge Step 2**.
 
 #### If "Commit with custom message" selected:
 
-First, ask for the commit message:
+First, analyze changes to suggest a meaningful commit message:
+
+```bash
+# Get changed files summary for commit message suggestion
+git diff --stat HEAD
+```
+
+Based on the files changed, generate 2-3 contextual commit message suggestions:
+- Examine which directories/files changed to determine the type (feat/fix/chore/docs)
+- Read the diff summary to understand what was modified
+- Suggest messages that describe the "why" not just the "what"
+
 ```
 AskUserQuestion:
-  question: "Enter your commit message:"
+  question: "Choose or customize your commit message:"
   header: "Commit message"
   multiSelect: false
   options:
-    - label: "feat: ..."
-      description: "New feature"
-    - label: "fix: ..."
-      description: "Bug fix"
-    - label: "chore: ..."
-      description: "Maintenance/cleanup"
+    # 2-3 suggestions based on git diff analysis. Examples:
+    # - label: "feat: add OAuth support for session auth"
+    #   description: "Based on changes to auth/ files"
+    # - label: "fix: resolve merge conflict in config"
+    #   description: "Based on config file changes"
+    # Always include at least one option. User can select "Other" for custom.
 ```
 
-The user will select "Other" to enter a custom message. Then:
+The user will select a suggestion or "Other" to enter a custom message. Then:
 
 ```bash
 node .agileflow/scripts/session-manager.js commit-changes {session_id} --message="{user_message}"
@@ -342,26 +353,42 @@ From the `check-merge` response, check `hasConflicts`:
 
 If `hasConflicts: true`:
 
+First, get detailed conflict info:
+```bash
+# Get list of files that conflict (without actually merging)
+git merge --no-commit --no-ff {branchName} 2>&1 || true
+git diff --name-only --diff-filter=U
+git merge --abort
+```
+
+Display specific files with context:
 ```
-⚠️ Merge conflicts detected!
+⚠️ Merge conflicts detected in {N} file(s):
 
-This branch has conflicts with {mainBranch}. Smart merge can attempt automatic resolution.
+  {file1} - Both branches modified
+  {file2} - Conflicting changes
+  {file3} - Both added content (likely auto-resolvable)
 ```
 
-Then show conflict options:
+Analyze the conflicting files to make a smart recommendation:
+- If ALL conflicts are in docs/config files → recommend "Auto-resolve"
+- If conflicts include source code → recommend "Review first, then auto-resolve"
+- Count files by category (docs, tests, config, source) for the description
+
+Then present AI-recommended options:
 
 ```
 AskUserQuestion:
-  question: "How would you like to proceed?"
-  header: "Merge conflicts"
+  question: "How to handle {N} conflicting file(s)?"
+  header: "Conflicts"
   multiSelect: false
   options:
-    - label: "Auto-resolve conflicts (Recommended)"
-      description: "Smart merge will resolve based on file types automatically"
-    - label: "Resolve manually"
-      description: "Keep session active and resolve conflicts yourself"
-    - label: "End session without merging"
-      description: "Keep worktree for later resolution"
+    - label: "{AI recommended option} (Recommended)"
+      description: "{reason based on conflict analysis - e.g., 'All conflicts are in docs/config - safe to auto-resolve'}"
+    - label: "Auto-resolve all"
+      description: "Smart merge resolves by file type (docs=accept_both, source=theirs, config=ours)"
+    - label: "Keep session, resolve manually"
+      description: "Stay in session and fix conflicts yourself"
     - label: "Cancel"
       description: "Keep session as-is"
 ```
@@ -490,6 +517,29 @@ Summary:
 💡 To push your changes: git push
 ```
 
+### Post-Merge: Notify Other Sessions
+
+After successful merge, check if in tmux and send notification:
+
+```bash
+# Check if in tmux
+echo $TMUX
+```
+
+If in tmux:
+```bash
+# Send visible notification to all windows
+tmux display-message -d 5000 "Session {id} merged to {mainBranch} - changes are live"
+```
+
+Display to user:
+```
+The main branch working directory ({mainPath}) now has your merged changes.
+If you have a Claude session on main, its files are already updated.
+
+To push to remote: git push
+```
+
 Then proceed to **Step 4: Offer to Close Tab**.
 
 If failed:
@@ -613,7 +663,7 @@ If `reason: "uncommitted_changes"` → Show inline options (5 choices):
 
 **Step 1a: Handle uncommitted choice**
 - "Commit all": `node .agileflow/scripts/session-manager.js commit-changes {id}` → continue
-- "Commit custom": Ask for message → `commit-changes {id} --message="..."` → continue
+- "Commit custom": Analyze `git diff --stat`, suggest 2-3 contextual messages → `commit-changes {id} --message="..."` → continue
 - "Stash": `node .agileflow/scripts/session-manager.js stash {id}` → continue (unstash after merge)
 - "Discard": `node .agileflow/scripts/session-manager.js discard-changes {id}` → continue
 - "Cancel": EXIT
@@ -625,7 +675,11 @@ node .agileflow/scripts/session-manager.js merge-preview {session_id}
 Display commits and files to be merged.
 
 **Step 3: Check conflicts**
-If `hasConflicts: true` → Show conflict options (auto-resolve/manual/end/cancel)
+If `hasConflicts: true`:
+- Get detailed file list: `git merge --no-commit --no-ff {branch}`, `git diff --name-only --diff-filter=U`, `git merge --abort`
+- Display per-file conflict details
+- Analyze file types to recommend best option (docs/config → auto-resolve, source → review)
+- Show conflict options with AI recommendation first (auto-resolve/manual/cancel)
 
 **Step 3a: If auto-resolve selected**
 ```bash
@@ -681,6 +735,12 @@ node .agileflow/scripts/session-manager.js integrate {id} --strategy={squash|mer
 💡 To push: git push
 ```
 
+**Step 7a: Notify other sessions (if in tmux)**
+```bash
+tmux display-message -d 5000 "Session {id} merged to {mainBranch} - changes are live"
+```
+Display: "Main branch working directory now has your merged changes."
+
 ---
 
 ### 🚨 RULE #4: HANDLE OTHER OPTIONS
@@ -761,6 +821,7 @@ tmux kill-window
    g. Execute integrate
    h. If stash was used → unstash on main
    i. Show success with cd command
+   j. If in tmux → notify other sessions via tmux display-message
 5. If end/delete → Execute and show result
 6. If in tmux → Offer to close tab
 ```