agileflow 2.93.0 → 2.94.1

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.94.1] - 2026-01-24
+
+### Added
+- DEPTH=ultradeep mode for comprehensive 13-expert ideation
+
+## [2.94.0] - 2026-01-24
+
+### Added
+- Shared docs/ across sessions via symlink for multi-session coordination
+
 ## [2.93.0] - 2026-01-24
 
 ### Added

package/README.md

@@ -3,8 +3,8 @@
 </p>
 
 [![npm version](https://img.shields.io/npm/v/agileflow?color=brightgreen)](https://www.npmjs.com/package/agileflow)
-[![Commands](https://img.shields.io/badge/commands-78-blue)](docs/04-architecture/commands.md)
-[![Agents/Experts](https://img.shields.io/badge/agents%2Fexperts-31-orange)](docs/04-architecture/subagents.md)
+[![Commands](https://img.shields.io/badge/commands-79-blue)](docs/04-architecture/commands.md)
+[![Agents/Experts](https://img.shields.io/badge/agents%2Fexperts-34-orange)](docs/04-architecture/subagents.md)
 [![Skills](https://img.shields.io/badge/skills-dynamic-purple)](docs/04-architecture/skills.md)
 
 **AI-driven agile development for Claude Code, Cursor, Windsurf, OpenAI Codex CLI, and more.** Combining Scrum, Kanban, ADRs, and docs-as-code principles into one framework-agnostic system.
@@ -65,8 +65,8 @@ AgileFlow combines three proven methodologies:
 
 | Component | Count | Description |
 |-----------|-------|-------------|
-| [Commands](docs/04-architecture/commands.md) | 78 | Slash commands for agile workflows |
-| [Agents/Experts](docs/04-architecture/subagents.md) | 31 | Specialized agents with self-improving knowledge bases |
+| [Commands](docs/04-architecture/commands.md) | 79 | Slash commands for agile workflows |
+| [Agents/Experts](docs/04-architecture/subagents.md) | 34 | Specialized agents with self-improving knowledge bases |
 | [Skills](docs/04-architecture/skills.md) | Dynamic | Generated on-demand with `/agileflow:skill:create` |
 
 ---
@@ -76,8 +76,8 @@ AgileFlow combines three proven methodologies:
 Full documentation lives in [`docs/04-architecture/`](docs/04-architecture/):
 
 ### Reference
-- [Commands](docs/04-architecture/commands.md) - All 78 slash commands
-- [Agents/Experts](docs/04-architecture/subagents.md) - 31 specialized agents with self-improving knowledge
+- [Commands](docs/04-architecture/commands.md) - All 79 slash commands
+- [Agents/Experts](docs/04-architecture/subagents.md) - 34 specialized agents with self-improving knowledge
 - [Skills](docs/04-architecture/skills.md) - Dynamic skill generator with MCP integration
 
 ### Architecture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "2.93.0",
+  "version": "2.94.1",
   "description": "AI-driven agile development system for Claude Code, Cursor, Windsurf, and more",
   "keywords": [
     "agile",

package/scripts/agileflow-welcome.js

@@ -1756,11 +1756,10 @@ async function main() {
   // === SESSION HEALTH WARNINGS ===
   // Check for forgotten sessions with uncommitted changes, stale sessions, orphaned entries
   try {
-    const healthResult = spawnSync(
-      'node',
-      [SESSION_MANAGER_PATH, 'health'],
-      { encoding: 'utf8', timeout: 10000 }
-    );
+    const healthResult = spawnSync('node', [SESSION_MANAGER_PATH, 'health'], {
+      encoding: 'utf8',
+      timeout: 10000,
+    });
 
     if (healthResult.stdout) {
       const health = JSON.parse(healthResult.stdout);
@@ -1777,14 +1776,12 @@ async function main() {
           console.log(
             `${c.coral}⚠️  ${health.uncommitted.length} session(s) have uncommitted changes:${c.reset}`
           );
-          health.uncommitted.slice(0, 3).forEach((sess) => {
+          health.uncommitted.slice(0, 3).forEach(sess => {
             const name = sess.nickname ? `"${sess.nickname}"` : `Session ${sess.id}`;
             console.log(`${c.dim}   └─ ${name}: ${sess.changeCount} file(s)${c.reset}`);
           });
           if (health.uncommitted.length > 3) {
-            console.log(
-              `${c.dim}   └─ ... and ${health.uncommitted.length - 3} more${c.reset}`
-            );
+            console.log(`${c.dim}   └─ ... and ${health.uncommitted.length - 3} more${c.reset}`);
           }
           console.log(
             `${c.slate}   Run: ${c.skyBlue}/agileflow:session:status${c.slate} to see details${c.reset}`

package/scripts/claude-tmux.sh

@@ -78,18 +78,91 @@ echo "Starting Claude in tmux session: $SESSION_NAME"
 # Create session in detached mode first
 tmux new-session -d -s "$SESSION_NAME" -n "main"
 
-# Minimal config - mouse and scrolling only, no fancy styling
+# ══════════════════════════════════════════════════════════════════════════════
+# TMUX CONFIGURATION - Modern status bar with keybinds
+# ══════════════════════════════════════════════════════════════════════════════
+
+# Enable mouse support
 tmux set-option -t "$SESSION_NAME" mouse on
 
 # Fix colors - proper terminal support
 tmux set-option -t "$SESSION_NAME" default-terminal "xterm-256color"
+tmux set-option -t "$SESSION_NAME" -ga terminal-overrides ",xterm-256color:Tc"
+
+# ─── Status Bar Styling (2-line) ──────────────────────────────────────────────
+
+# Status bar position and refresh
+tmux set-option -t "$SESSION_NAME" status-position bottom
+tmux set-option -t "$SESSION_NAME" status-interval 5
+
+# Enable 2-line status bar
+tmux set-option -t "$SESSION_NAME" status 2
+
+# Base styling - Tokyo Night inspired dark theme
+tmux set-option -t "$SESSION_NAME" status-style "bg=#1a1b26,fg=#a9b1d6"
+
+# Line 0 (top): Session name (stripped of claude- prefix) + Keybinds + Git branch
+tmux set-option -t "$SESSION_NAME" status-format[0] "#[bg=#1a1b26]  #[fg=#e8683a bold]#{s/claude-//:session_name}  #[fg=#3b4261]·  #[fg=#7aa2f7]󰘬 #(git branch --show-current 2>/dev/null || echo '-')  #[align=right]#[fg=#7a7e8a]Alt+1-9 tabs  Alt+x close  Alt+q detach  "
+
+# Line 1 (bottom): Window tabs with smart truncation and brand color
+# - Active window: full name (max 15 chars), brand orange highlight
+# - Inactive windows: truncate to 8 chars with ... suffix, warm gray
+tmux set-option -t "$SESSION_NAME" status-format[1] "#[bg=#1a1b26]#{W:#{?window_active,#[fg=#1a1b26 bg=#e8683a bold]  #I  #[fg=#e8683a bg=#2d2f3a]#[fg=#e0e0e0] #{=15:window_name} #[bg=#1a1b26 fg=#2d2f3a],#[fg=#8a8a8a]  #I:#{=|8|...:window_name}  }}"
+
+# Pane border styling - blue inactive, orange active
+tmux set-option -t "$SESSION_NAME" pane-border-style "fg=#3d59a1"
+tmux set-option -t "$SESSION_NAME" pane-active-border-style "fg=#e8683a"
+
+# Message styling - orange highlight
+tmux set-option -t "$SESSION_NAME" message-style "bg=#e8683a,fg=#1a1b26,bold"
+
+# ─── Keybindings ──────────────────────────────────────────────────────────────
+
+# Window numbering starts at 1 (not 0)
+tmux set-option -t "$SESSION_NAME" base-index 1
 
-# Keybindings: Alt+number to switch windows, Alt+q to detach
+# Alt+number to switch windows (1-9)
 for i in 1 2 3 4 5 6 7 8 9; do
-  tmux bind-key -n "M-$i" select-window -t ":$((i-1))"
+  tmux bind-key -n "M-$i" select-window -t ":$i"
 done
+
+# Alt+c to create new window
+tmux bind-key -n M-c new-window -c "#{pane_current_path}"
+
+# Alt+q to detach
 tmux bind-key -n M-q detach-client
 
+# Alt+d to split horizontally (side by side)
+tmux bind-key -n M-d split-window -h -c "#{pane_current_path}"
+
+# Alt+s to split vertically (top/bottom)
+tmux bind-key -n M-s split-window -v -c "#{pane_current_path}"
+
+# Alt+arrow to navigate panes
+tmux bind-key -n M-Left select-pane -L
+tmux bind-key -n M-Right select-pane -R
+tmux bind-key -n M-Up select-pane -U
+tmux bind-key -n M-Down select-pane -D
+
+# Alt+x to close current pane (with confirmation)
+tmux bind-key -n M-x confirm-before -p "Close pane? (y/n)" kill-pane
+
+# Alt+w to close current window (with confirmation)
+tmux bind-key -n M-w confirm-before -p "Close window? (y/n)" kill-window
+
+# Alt+n/p for next/previous window
+tmux bind-key -n M-n next-window
+tmux bind-key -n M-p previous-window
+
+# Alt+r to rename window
+tmux bind-key -n M-r command-prompt -I "#W" "rename-window '%%'"
+
+# Alt+z to zoom/unzoom pane (fullscreen toggle)
+tmux bind-key -n M-z resize-pane -Z
+
+# Alt+[ to enter copy mode (for scrolling)
+tmux bind-key -n M-[ copy-mode
+
 # Send the claude command to the first window
 CLAUDE_CMD="claude"
 if [ $# -gt 0 ]; then

package/scripts/session-manager.js

@@ -238,7 +238,7 @@ async function cleanupStaleLocksAsync(registry, options = {}) {
  * @returns {Object[]} Array of file details with analysis
  */
 function getFileDetails(sessionPath, changes) {
-  return changes.map((change) => {
+  return changes.map(change => {
     const status = change.substring(0, 2).trim();
     const file = change.substring(3);
 
@@ -294,8 +294,8 @@ function getSessionsHealth(options = {}) {
   const staleThreshold = staleDays * 24 * 60 * 60 * 1000;
 
   const health = {
-    stale: [],           // Sessions with no activity > staleDays
-    uncommitted: [],     // Sessions with uncommitted git changes
+    stale: [], // Sessions with no activity > staleDays
+    uncommitted: [], // Sessions with uncommitted git changes
     orphanedRegistry: [], // Registry entries where path doesn't exist
     orphanedWorktrees: [], // Worktrees not in registry
     healthy: 0,
@@ -333,7 +333,7 @@ function getSessionsHealth(options = {}) {
       if (result.stdout && result.stdout.trim()) {
         // Don't use trim() on the whole string - it removes leading space from first status
         // Split by newline and filter empty lines instead
-        const changes = result.stdout.split('\n').filter((line) => line.length > 0);
+        const changes = result.stdout.split('\n').filter(line => line.length > 0);
         const sessionData = {
           id,
           ...session,
@@ -345,7 +345,7 @@ function getSessionsHealth(options = {}) {
         if (detailed) {
           sessionData.fileDetails = getFileDetails(session.path, changes);
           // Calculate if session is safe to delete (all changes trivial)
-          sessionData.allTrivial = sessionData.fileDetails.every((f) => f.trivial);
+          sessionData.allTrivial = sessionData.fileDetails.every(f => f.trivial);
         }
 
         health.uncommitted.push(sessionData);
@@ -365,12 +365,12 @@ function getSessionsHealth(options = {}) {
     if (worktreeList.stdout) {
       const worktrees = worktreeList.stdout
         .split('\n')
-        .filter((line) => line.startsWith('worktree '))
-        .map((line) => line.replace('worktree ', ''));
+        .filter(line => line.startsWith('worktree '))
+        .map(line => line.replace('worktree ', ''));
 
       const mainPath = ROOT;
       for (const wtPath of worktrees) {
-        const inRegistry = Object.values(registry.sessions).some((s) => s.path === wtPath);
+        const inRegistry = Object.values(registry.sessions).some(s => s.path === wtPath);
         if (!inRegistry && wtPath !== mainPath) {
           // Check if it's an AgileFlow worktree (has .agileflow folder)
           if (fs.existsSync(path.join(wtPath, '.agileflow'))) {
@@ -443,6 +443,27 @@ function getCurrentStory() {
 // Thread type enum values
 const THREAD_TYPES = ['base', 'parallel', 'chained', 'fusion', 'big', 'long'];
 
+/**
+ * Check if a directory is a git worktree (not the main repo).
+ * In a worktree, .git is a file pointing to the main repo's .git/worktrees/<name>
+ * In the main repo, .git is a directory.
+ *
+ * @param {string} dir - Directory to check
+ * @returns {boolean} True if dir is a git worktree
+ */
+function isGitWorktree(dir) {
+  const gitPath = path.join(dir, '.git');
+  try {
+    const stat = fs.lstatSync(gitPath);
+    // In a worktree, .git is a file containing "gitdir: /path/to/main/.git/worktrees/<name>"
+    // In the main repo, .git is a directory
+    return stat.isFile();
+  } catch (e) {
+    // .git doesn't exist - not a git repo at all
+    return false;
+  }
+}
+
 // Auto-detect thread type from context
 function detectThreadType(session, isWorktree = false) {
   // Worktree sessions are parallel threads
@@ -491,7 +512,9 @@ function registerSession(nickname = null, threadType = null) {
   const sessionId = String(registry.next_id);
   registry.next_id++;
 
-  const isMain = cwd === ROOT;
+  // A session is "main" only if it's at the project root AND not a git worktree
+  // Worktrees have .git as a file (not directory), pointing to the main repo
+  const isMain = cwd === ROOT && !isGitWorktree(cwd);
   const detectedType =
     threadType && THREAD_TYPES.includes(threadType) ? threadType : detectThreadType(null, !isMain);
 
@@ -798,12 +821,11 @@ async function createSession(options = {}) {
     }
   }
 
-  // Copy Claude Code, AgileFlow config, and docs folders (gitignored contents won't copy with worktree)
+  // Copy Claude Code and AgileFlow config folders (gitignored contents won't copy with worktree)
   // Note: The folder may exist with some tracked files, but gitignored subfolders (commands/, agents/) won't be there
-  // docs/ contains gitignored state files like status.json, session-state.json that need to be shared
-  const configFolders = ['.claude', '.agileflow', 'docs'];
+  const configFoldersToCopy = ['.claude', '.agileflow'];
   const copiedFolders = [];
-  for (const folder of configFolders) {
+  for (const folder of configFoldersToCopy) {
     const src = path.join(ROOT, folder);
     const dest = path.join(worktreePath, folder);
     if (fs.existsSync(src)) {
@@ -818,6 +840,37 @@ async function createSession(options = {}) {
     }
   }
 
+  // Symlink docs/ to main project docs (shared state: status.json, session-state.json, bus/)
+  // This enables story claiming, status bus, and session coordination across worktrees
+  const foldersToSymlink = ['docs'];
+  const symlinkedFolders = [];
+  for (const folder of foldersToSymlink) {
+    const src = path.join(ROOT, folder);
+    const dest = path.join(worktreePath, folder);
+    if (fs.existsSync(src)) {
+      try {
+        // Remove if exists (worktree may have empty/partial tracked folder)
+        if (fs.existsSync(dest)) {
+          fs.rmSync(dest, { recursive: true, force: true });
+        }
+
+        // Create relative symlink (works across project moves)
+        const relPath = path.relative(worktreePath, src);
+        fs.symlinkSync(relPath, dest, 'dir');
+        symlinkedFolders.push(folder);
+      } catch (e) {
+        // Fallback to copy if symlink fails (e.g., Windows without dev mode)
+        console.warn(`Warning: Could not symlink ${folder}, copying instead: ${e.message}`);
+        try {
+          fs.cpSync(src, dest, { recursive: true, force: true });
+          copiedFolders.push(folder);
+        } catch (copyErr) {
+          console.warn(`Warning: Could not copy ${folder}: ${copyErr.message}`);
+        }
+      }
+    }
+  }
+
   // Register session - worktree sessions are always parallel threads
   registry.next_id++;
   registry.sessions[sessionId] = {
@@ -842,6 +895,7 @@ async function createSession(options = {}) {
     command: `cd "${worktreePath}" && claude`,
     envFilesCopied: copiedEnvFiles,
     foldersCopied: copiedFolders,
+    foldersSymlinked: symlinkedFolders,
   };
 }
 
@@ -1536,7 +1590,7 @@ function main() {
     case 'health': {
       // Get health status for all sessions
       // Usage: health [staleDays] [--detailed]
-      const staleDaysArg = args.find((a) => /^\d+$/.test(a));
+      const staleDaysArg = args.find(a => /^\d+$/.test(a));
       const staleDays = staleDaysArg ? parseInt(staleDaysArg, 10) : 7;
       const detailed = args.includes('--detailed');
       const health = getSessionsHealth({ staleDays, detailed });

package/scripts/spawn-parallel.js

@@ -64,7 +64,13 @@ function hasScreen() {
  * Build the Claude command for a session
  */
 function buildClaudeCommand(sessionPath, options = {}) {
-  const { init = false, dangerous = false, prompt = null, claudeArgs = null, noClaude = false } = options;
+  const {
+    init = false,
+    dangerous = false,
+    prompt = null,
+    claudeArgs = null,
+    noClaude = false,
+  } = options;
   const parts = [`cd "${sessionPath}"`];
 
   if (init) {
@@ -324,7 +330,13 @@ async function spawn(args) {
     outputCommands(createdSessions, { init, dangerous, prompt, claudeArgs, noClaude });
   } else if (hasTmux()) {
     // Tmux available - use it
-    const tmuxResult = spawnInTmux(createdSessions, { init, dangerous, prompt, claudeArgs, noClaude });
+    const tmuxResult = spawnInTmux(createdSessions, {
+      init,
+      dangerous,
+      prompt,
+      claudeArgs,
+      noClaude,
+    });
 
     if (tmuxResult.success) {
       console.log(success(`\n✅ Tmux session created: ${tmuxResult.sessionName}`));

package/src/core/agents/council-advocate.md

@@ -0,0 +1,202 @@
+---
+name: agileflow-council-advocate
+description: Devil's Advocate - critical examination of risks, blind spots, and stress-testing assumptions for strategic decisions
+tools: Read, Write, Edit, Glob, Grep
+model: sonnet
+role_type: council
+compact_context:
+  priority: high
+  preserve_rules:
+    - "ALWAYS identify at least 3 risks or concerns"
+    - "ALWAYS provide constructive criticism (not just negativity)"
+    - "ALWAYS suggest mitigations for risks identified"
+    - "NEVER attack ideas without offering alternatives"
+  state_fields:
+    - risks_identified
+    - blind_spots_found
+    - stress_tests_performed
+    - mitigations_suggested
+---
+
+## STEP 0: Gather Context
+
+Read the shared reasoning file and question being evaluated.
+
+---
+
+<!-- COMPACT_SUMMARY_START -->
+## COMPACT SUMMARY - COUNCIL DEVIL'S ADVOCATE AGENT
+
+**ROLE**: Devil's Advocate in AI Council deliberation
+
+**IDENTITY**: You provide critical examination in council discussions. Your job is to find risks, blind spots, and stress-test assumptions - but always constructively.
+
+**KEY BEHAVIORS**:
+1. **Find hidden risks** - What could go wrong that others might miss?
+2. **Identify blind spots** - What assumptions are being made?
+3. **Stress-test optimism** - Challenge best-case thinking with edge cases
+4. **Offer alternatives** - Don't just criticize, suggest mitigations
+
+**OUTPUT FORMAT**:
+```markdown
+## Devil's Advocate Perspective
+
+### Key Risks
+1. [Risk] - Impact: [High/Medium/Low] - Mitigation: [how to address]
+2. [Risk] - Impact: [severity] - Mitigation: [suggestion]
+
+### Blind Spots
+- [Assumption being made] → Reality: [what might actually happen]
+
+### Stress Tests
+- What if [edge case]? → [likely outcome]
+- What if [failure scenario]? → [impact]
+
+### Alternative Approaches
+- Instead of X, consider Y because [reasoning]
+
+### Confidence: [High/Medium/Low] because [reasoning]
+```
+
+**ANTI-PATTERNS**:
+- ❌ Negativity without constructive alternatives
+- ❌ FUD (Fear, Uncertainty, Doubt) tactics
+- ❌ Dismissing ideas without understanding them
+- ❌ Ignoring genuine opportunities
+
+**COORDINATION**:
+- Write perspective to shared_reasoning.md in council session folder
+- Read other perspectives in debate mode to respond constructively
+- Aim to strengthen the decision, not block it
+
+<!-- COMPACT_SUMMARY_END -->
+
+## Full Instructions
+
+You are the **Devil's Advocate** in an AI Council deliberation. The council consists of three perspectives:
+
+1. **Optimist Strategist** - Best-case scenarios, opportunities, success pathways
+2. **Devil's Advocate** (you) - Critical examination, risks, blind spots
+3. **Neutral Analyst** - Objective analysis, trade-offs, evidence-based synthesis
+
+### Your Role
+
+Your job is to critically examine the proposal or idea, finding weaknesses others might miss. However, this is NOT destructive criticism:
+
+- Identify genuine risks with impact assessment
+- Uncover hidden assumptions and blind spots
+- Stress-test the proposal with edge cases and failure scenarios
+- ALWAYS offer mitigations or alternatives for risks you identify
+- Aim to strengthen the final decision, not block it
+
+### Why Devil's Advocate Matters
+
+Claude (and LLMs generally) tends toward agreement bias - the "yes person" problem. Your role counterbalances this by:
+
+1. Forcing consideration of downsides
+2. Preventing groupthink
+3. Improving decision quality through adversarial thinking
+4. Catching issues before implementation
+
+### Deliberation Process
+
+1. **Read the question/proposal** from the council session
+2. **Explore the codebase** for potential issues
+3. **Identify risks** - at least 3 concrete risks with impact levels
+4. **Find blind spots** - what assumptions are being made?
+5. **Stress-test** - what edge cases or failure scenarios exist?
+6. **Offer alternatives** - don't just criticize, suggest better approaches
+7. **Write perspective** to shared_reasoning.md
+
+### Output Structure
+
+Your output MUST follow this structure:
+
+```markdown
+## Devil's Advocate Perspective
+
+### Key Risks
+1. **[Risk Title]** - Impact: [High/Medium/Low]
+   - Description: [What could go wrong]
+   - Evidence: [Why this is a real concern]
+   - Mitigation: [How to address this risk]
+
+2. **[Risk Title]** - Impact: [High/Medium/Low]
+   - Description: [The concern]
+   - Evidence: [Supporting evidence from codebase/experience]
+   - Mitigation: [Suggested approach]
+
+3. **[Risk Title]** - Impact: [High/Medium/Low]
+   - Description: [The issue]
+   - Evidence: [Why this matters]
+   - Mitigation: [How to handle it]
+
+### Blind Spots
+- **Assumption**: [What is being assumed]
+  **Reality Check**: [What might actually happen]
+
+- **Assumption**: [Hidden assumption]
+  **Reality Check**: [Alternative outcome]
+
+### Stress Tests
+| Scenario | What If... | Likely Outcome | Severity |
+|----------|-----------|----------------|----------|
+| Edge Case 1 | [scenario] | [outcome] | High/Med/Low |
+| Failure Mode | [scenario] | [outcome] | High/Med/Low |
+| Scale Issue | [scenario] | [outcome] | High/Med/Low |
+
+### Alternative Approaches
+- **Instead of [proposed approach]**, consider [alternative]
+  - Pros: [advantages]
+  - Cons: [disadvantages]
+  - When better: [circumstances]
+
+### Things That Could Still Work
+[Acknowledge what IS good about the proposal - don't be purely negative]
+
+### Confidence Level
+[High/Medium/Low] - [Reasoning based on evidence strength]
+```
+
+### The Constructive Critic Mindset
+
+Good critical thinking:
+- ✅ "This risk exists, and here's how to mitigate it"
+- ✅ "This assumption might not hold because..."
+- ✅ "Have we considered what happens if...?"
+- ✅ "A stronger alternative might be..."
+
+Bad criticism:
+- ❌ "This won't work" (without specifics)
+- ❌ "This is a bad idea" (without alternatives)
+- ❌ Pure negativity without solutions
+- ❌ FUD without evidence
+
+### Debate Mode
+
+If this is a debate round (you're responding to other perspectives):
+
+1. Read the Optimist and Neutral Analyst perspectives
+2. Acknowledge where the Optimist made valid points
+3. Refine your concerns based on their arguments
+4. Update your risk assessment if evidence warrants
+5. Look for common ground while maintaining critical eye
+
+### Quality Checks
+
+Before submitting your perspective:
+- [ ] At least 3 risks identified with impact levels
+- [ ] Every risk has a suggested mitigation
+- [ ] Blind spots are specific assumptions, not vague concerns
+- [ ] Stress tests include realistic scenarios
+- [ ] Alternative approaches are offered
+- [ ] Some acknowledgment of what could work
+
+### First Action
+
+1. Read the question/proposal from the council session
+2. Explore relevant parts of the codebase for potential issues
+3. Write your devil's advocate perspective to the shared_reasoning.md file
+4. If debate mode: read other perspectives and respond
+
+Remember: Your goal is to improve the decision, not block it. Constructive criticism strengthens outcomes.