claude-code-workflow 6.3.53 → 7.0.0

package/.claude/agents/code-developer.md

@@ -26,12 +26,19 @@ You are a code execution specialist focused on implementing high-quality, produc
 
 ## Execution Process
 
+### 0. Task Status: Mark In Progress
+```bash
+jq --arg ts "$(date -Iseconds)" '.status="in_progress" | .status_history += [{"from":.status,"to":"in_progress","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
+```
+
 ### 1. Context Assessment
 **Input Sources**:
 - User-provided task description and context
 - Existing documentation and code examples
 - Project CLAUDE.md standards
 - **context-package.json** (when available in workflow tasks)
+- **project-tech.json** (if exists) → tech_stack, architecture, key_components
+- **specs/*.md** (if exists) → conventions, constraints, quality_rules
 
 **Context Package** :
 `context-package.json` provides artifact paths - read using Read tool or ccw session:
@@ -44,26 +51,22 @@ Read(.workflow/active/${SESSION_ID}/.process/context-package.json)
 **Task JSON Parsing** (when task JSON path provided):
 Read task JSON and extract structured context:
 ```
-Task JSON Fields:
-├── context.requirements[]     → What to implement (list of requirements)
-├── context.acceptance[]       → How to verify (validation commands)
-├── context.focus_paths[]      → Where to focus (directories/files)
-├── context.shared_context     → Tech stack and conventions
-│   ├── tech_stack[]          → Technologies used (skip auto-detection if present)
-│   └── conventions[]         → Coding conventions to follow
-├── context.artifacts[]        → Additional context sources
-└── flow_control               → Execution instructions
-    ├── pre_analysis[]        → Context gathering steps (execute first)
-    ├── implementation_approach[] → Implementation steps (execute sequentially)
-    └── target_files[]        → Files to create/modify
+Task JSON Fields (unified flat structure):
+├── description                → What to implement (goal + requirements)
+├── convergence.criteria[]     → How to verify (validation commands)
+├── focus_paths[]              → Where to focus (directories/files)
+├── artifacts[]                → Additional context sources
+├── pre_analysis[]             → Context gathering steps (execute first)
+├── implementation[]           → Implementation steps (execute sequentially)
+└── files[]                    → Files to create/modify (files[].path)
 ```
 
 **Parsing Priority**:
 1. Read task JSON from provided path
-2. Extract `context.requirements` as implementation goals
-3. Extract `context.acceptance` as verification criteria
-4. If `context.shared_context.tech_stack` exists → skip auto-detection, use provided stack
-5. Process `flow_control` if present
+2. Extract `description` as implementation goals
+3. Extract `convergence.criteria` as verification criteria
+4. Read plan.json from session dir → extract `shared_context.tech_stack` and `shared_context.conventions` (skip auto-detection if present)
+5. Process `pre_analysis` and `implementation` if present
 
 **Pre-Analysis: Smart Tech Stack Loading**:
 ```bash
@@ -72,24 +75,24 @@ if [[ -n "$TASK_JSON_TECH_STACK" ]]; then
     # Map tech stack names to guideline files
     # e.g., ["FastAPI", "SQLAlchemy"] → python-dev.md
     case "$TASK_JSON_TECH_STACK" in
-        *FastAPI*|*Django*|*SQLAlchemy*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md) ;;
-        *React*|*Next*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md) ;;
-        *TypeScript*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md) ;;
+        *FastAPI*|*Django*|*SQLAlchemy*) TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/python-dev.md) ;;
+        *React*|*Next*) TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/react-dev.md) ;;
+        *TypeScript*) TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/typescript-dev.md) ;;
     esac
 # Priority 2: Auto-detect from file extensions (fallback)
 elif [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
     if ls *.ts *.tsx 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/typescript-dev.md)
     elif grep -q "react" package.json 2>/dev/null; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/react-dev.md)
     elif ls *.py requirements.txt 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/python-dev.md)
     elif ls *.java pom.xml build.gradle 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/java-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/java-dev.md)
     elif ls *.go go.mod 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/go-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/go-dev.md)
     elif ls *.js package.json 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/javascript-dev.md)
+        TECH_GUIDELINES=$(cat ~/.ccw/workflows/cli-templates/tech-stacks/javascript-dev.md)
     fi
 fi
 ```
@@ -99,20 +102,20 @@ fi
 STEP 1: Parse Task JSON (if path provided)
     → Read task JSON file from provided path
     → Extract and store in memory:
-      • [requirements] ← context.requirements[]
-      • [acceptance_criteria] ← context.acceptance[]
-      • [tech_stack] ← context.shared_context.tech_stack[] (skip auto-detection if present)
-      • [conventions] ← context.shared_context.conventions[]
-      • [focus_paths] ← context.focus_paths[]
+      • [requirements] ← description
+      • [acceptance_criteria] ← convergence.criteria[]
+      • [tech_stack] ← plan.json shared_context.tech_stack[] (skip auto-detection if present)
+      • [conventions] ← plan.json shared_context.conventions[]
+      • [focus_paths] ← focus_paths[]
 
-STEP 2: Execute Pre-Analysis (if flow_control.pre_analysis exists in Task JSON)
+STEP 2: Execute Pre-Analysis (if pre_analysis exists in Task JSON)
     → Execute each pre_analysis step sequentially
     → Store each step's output in memory using output_to variable name
     → These variables are available for STEP 3
 
 STEP 3: Execute Implementation (choose one path)
-    IF flow_control.implementation_approach exists:
-        → Follow implementation_approach steps sequentially
+    IF implementation[] exists:
+        → Follow implementation steps sequentially
         → Substitute [variable_name] placeholders with stored values BEFORE execution
     ELSE:
         → Use [requirements] as implementation goals
@@ -121,7 +124,7 @@ STEP 3: Execute Implementation (choose one path)
         → Verify against [acceptance_criteria] on completion
 ```
 
-**Pre-Analysis Execution** (flow_control.pre_analysis):
+**Pre-Analysis Execution** (pre_analysis):
 ```
 For each step in pre_analysis[]:
   step.step      → Step identifier (string name)
@@ -170,7 +173,7 @@ Example Parsing:
 - Content search: `rg -i "authentication" src/ -C 3`
 
 **Implementation Approach Execution**:
-When task JSON contains `flow_control.implementation_approach` array:
+When task JSON contains `implementation` array:
 
 **Step Structure**:
 ```
@@ -192,39 +195,23 @@ const cliTool = task.meta?.execution_config?.cli_tool || getDefaultCliTool();  /
 
 // Phase 1: Execute pre_analysis (always by Agent)
 const preAnalysisResults = {};
-for (const step of task.flow_control.pre_analysis || []) {
+for (const step of task.pre_analysis || []) {
   const result = executePreAnalysisStep(step);
   preAnalysisResults[step.output_to] = result;
 }
 
-// Phase 2: Determine execution mode
-const hasLegacyCommands = task.flow_control.implementation_approach
-  .some(step => step.command);
-
-IF hasLegacyCommands:
-  // Backward compatibility: Old mode with step.command fields
-  FOR each step in implementation_approach[]:
-    IF step.command exists:
-      → Execute via Bash: Bash({ command: step.command, timeout: 3600000 })
-    ELSE:
-      → Agent direct implementation
+// Phase 2: Determine execution mode (based on task.meta.execution_config.method)
+// Two modes: 'cli' (call CLI tool) or 'agent' (execute directly)
 
-ELSE IF executionMethod === 'cli':
-  // New mode: CLI Handoff
-  → const cliPrompt = buildCliHandoffPrompt(preAnalysisResults, task)
+IF executionMethod === 'cli':
+  // CLI Handoff: Full context passed to CLI via buildCliHandoffPrompt
+  → const cliPrompt = buildCliHandoffPrompt(preAnalysisResults, task, taskJsonPath)
   → const cliCommand = buildCliCommand(task, cliTool, cliPrompt)
   → Bash({ command: cliCommand, run_in_background: false, timeout: 3600000 })
 
-ELSE IF executionMethod === 'hybrid':
-  // Hybrid mode: Agent decides based on task complexity
-  → IF task is complex (multiple files, complex logic):
-      Use CLI Handoff (same as cli mode)
-    ELSE:
-      Use Agent direct implementation
-
 ELSE (executionMethod === 'agent'):
-  // Default: Agent direct implementation
-  FOR each step in implementation_approach[]:
+  // Execute implementation steps directly
+  FOR each step in implementation[]:
     1. Variable Substitution: Replace [variable_name] with preAnalysisResults
     2. Read modification_points[] as files to create/modify
     3. Read logic_flow[] as implementation sequence
@@ -248,44 +235,41 @@ function getDefaultCliTool() {
 }
 
 // Build CLI prompt from pre-analysis results and task
-function buildCliHandoffPrompt(preAnalysisResults, task) {
+function buildCliHandoffPrompt(preAnalysisResults, task, taskJsonPath) {
   const contextSection = Object.entries(preAnalysisResults)
     .map(([key, value]) => `### ${key}\n${value}`)
     .join('\n\n');
 
-  const approachSection = task.flow_control.implementation_approach
-    .map((step, i) => `
-### Step ${step.step}: ${step.title}
-${step.description}
-
-**Modification Points**:
-${step.modification_points?.map(m => `- ${m}`).join('\n') || 'N/A'}
-
-**Logic Flow**:
-${step.logic_flow?.map((l, j) => `${j + 1}. ${l}`).join('\n') || 'Follow modification points'}
-`).join('\n');
+  const conventions = plan?.shared_context?.conventions?.join(' | ') || '';
+  const constraints = `Follow existing patterns | No breaking changes${conventions ? ' | ' + conventions : ''}`;
 
   return `
 PURPOSE: ${task.title}
-Complete implementation based on pre-analyzed context.
+Complete implementation based on pre-analyzed context and task JSON.
+
+## TASK JSON
+Read full task definition: ${taskJsonPath}
+
+## TECH STACK
+${plan?.shared_context?.tech_stack?.map(t => `- ${t}`).join('\n') || 'Auto-detect from project files'}
 
 ## PRE-ANALYSIS CONTEXT
 ${contextSection}
 
 ## REQUIREMENTS
-${task.context.requirements?.map(r => `- ${r}`).join('\n') || task.context.requirements}
-
-## IMPLEMENTATION APPROACH
-${approachSection}
+${task.description || 'See task JSON'}
 
 ## ACCEPTANCE CRITERIA
-${task.context.acceptance?.map(a => `- ${a}`).join('\n') || task.context.acceptance}
+${task.convergence?.criteria?.map(a => `- ${a}`).join('\n') || 'See task JSON'}
 
 ## TARGET FILES
-${task.flow_control.target_files?.map(f => `- ${f}`).join('\n') || 'See modification points above'}
+${task.files?.map(f => `- ${f.path || f}`).join('\n') || 'See task JSON'}
+
+## FOCUS PATHS
+${task.focus_paths?.map(p => `- ${p}`).join('\n') || 'See task JSON'}
 
 MODE: write
-CONSTRAINTS: Follow existing patterns | No breaking changes
+CONSTRAINTS: ${constraints}
 `.trim();
 }
 
@@ -297,13 +281,13 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 
   switch (cli.strategy) {
     case 'new':
-      return `${baseCmd} --tool ${cliTool} --mode write --id ${task.cli_execution_id}`;
+      return `${baseCmd} --tool ${cliTool} --mode write --id ${task.cli_execution.id}`;
     case 'resume':
       return `${baseCmd} --resume ${cli.resume_from} --tool ${cliTool} --mode write`;
     case 'fork':
-      return `${baseCmd} --resume ${cli.resume_from} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+      return `${baseCmd} --resume ${cli.resume_from} --id ${task.cli_execution.id} --tool ${cliTool} --mode write`;
     case 'merge_fork':
-      return `${baseCmd} --resume ${cli.merge_from.join(',')} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+      return `${baseCmd} --resume ${cli.merge_from.join(',')} --id ${task.cli_execution.id} --tool ${cliTool} --mode write`;
     default:
       // Fallback: no resume, no id
       return `${baseCmd} --tool ${cliTool} --mode write`;
@@ -314,7 +298,7 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 **Execution Config Reference** (from task.meta.execution_config):
 | Field | Values | Description |
 |-------|--------|-------------|
-| `method` | `agent` / `cli` / `hybrid` | Execution mode (default: agent) |
+| `method` | `agent` / `cli` | Execution mode (default: agent) |
 | `cli_tool` | See `~/.claude/cli-tools.json` | CLI tool preference (first enabled tool as default) |
 | `enable_resume` | `true` / `false` | Enable CLI session resume |
 
@@ -363,12 +347,18 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 
 **Upon completing any task:**
 
-1. **Verify Implementation**: 
+1. **Verify Implementation**:
    - Code compiles and runs
    - All tests pass
    - Functionality works as specified
 
-2. **Update TODO List**: 
+2. **Update Task JSON Status**:
+   ```bash
+   # Mark task as completed (run in task directory)
+   jq --arg ts "$(date -Iseconds)" '.status="completed" | .status_history += [{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
+   ```
+
+3. **Update TODO List**: 
    - Update TODO_LIST.md in workflow directory provided in session context
    - Mark completed tasks with [x] and add summary links
    - Update task progress based on JSON files in .task/ directory

package/.claude/agents/conceptual-planning-agent.md

@@ -70,7 +70,7 @@ def handle_brainstorm_assignment(prompt):
 
             # Execute role template loading via $(cat template)
             if step_name == "load_role_template":
-                processed_command = f"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/{role}.md))"
+                processed_command = f"bash($(cat ~/.ccw/workflows/cli-templates/planning-roles/{role}.md))"
             else:
                 processed_command = process_context_variables(command, context_vars)
 
@@ -106,7 +106,7 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 
 2. **load_role_template**
    - Action: Load role-specific planning template
-   - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
+   - Command: bash($(cat "~/.ccw/workflows/cli-templates/planning-roles/{role}.md"))
    - Output: role_template
 
 3. **load_session_metadata**
@@ -157,7 +157,7 @@ When called, you receive:
 - **User Context**: Specific requirements, constraints, and expectations from user discussion
 - **Output Location**: Directory path for generated analysis files
 - **Role Hint** (optional): Suggested role or role selection guidance
-- **context-package.json** (CCW Workflow): Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
+- **context-package.json** : Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
 - **ASSIGNED_ROLE** (optional): Specific role assignment
 - **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
 
@@ -165,7 +165,7 @@ When called, you receive:
 **Auto Brainstorm Integration**: Role assignment comes from auto.md workflow:
 1. **Role Pre-Assignment**: Auto brainstorm workflow assigns specific single role before agent execution
 2. **Validation**: Agent validates exactly one role assigned - no multi-role assignments allowed
-3. **Template Loading**: Use `$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)` for role template
+3. **Template Loading**: Use `$(cat ~/.ccw/workflows/cli-templates/planning-roles/<assigned-role>.md)` for role template
 4. **Output Directory**: Use designated `.brainstorming/[role]/` directory for role-specific outputs
 
 ### Role Options Include:
@@ -190,7 +190,7 @@ When called, you receive:
 ### Role Template Integration
 Documentation formats and structures are defined in role-specific templates loaded via:
 ```bash
-$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)
+$(cat ~/.ccw/workflows/cli-templates/planning-roles/<assigned-role>.md)
 ```
 
 Each planning role template contains:
@@ -220,23 +220,35 @@ Generate documents according to loaded role template specifications:
 
 **Output Location**: `.workflow/WFS-[session]/.brainstorming/[assigned-role]/`
 
-**Output Files**:
-- **analysis.md**: Index document with overview (optionally with `@` references to sub-documents)
+**Output Files** (feature-point organization when `feature_list` available):
+- **analysis.md**: Role overview index document with feature point listing and cross-cutting summary (< 1500 words)
+  - Contains: role perspective overview, feature point index with `@` references, cross-cutting summary
   - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
-- **analysis-{slug}.md**: Section content documents (slug from section heading: lowercase, hyphens)
-  - Maximum 5 sub-documents (merge related sections if needed)
-- **Content**: Analysis AND recommendations sections
-
-**File Structure Example**:
+- **analysis-cross-cutting.md**: Cross-feature architectural decisions, technology choices, shared patterns (< 2000 words)
+  - Contains: decisions/patterns that span multiple features, shared constraints, role-wide recommendations
+- **analysis-F-{id}-{slug}.md**: Per-feature analysis documents (< 2000 words each)
+  - `{id}` and `{slug}` come from `guidance-specification.md` Feature Decomposition table
+  - Example: `analysis-F-001-real-time-sync.md`, `analysis-F-002-user-auth.md`
+  - Contains: role-specific analysis, recommendations, and considerations for that feature
+  - Generate one sub-document per feature in the feature list
+
+**Backward Compatibility** (when `feature_list` is NOT available):
+- Fall back to existing organization: `analysis-{slug}.md` with arbitrary topic slugs
+- Maximum 5 sub-documents (merge related sections if needed)
+- analysis.md remains the main document with overview
+
+**File Structure Example** (feature-point mode):
 ```
 .workflow/WFS-[session]/.brainstorming/system-architect/
-├── analysis.md                         # Index with overview + @references
-├── analysis-architecture-assessment.md # Section content
-├── analysis-technology-evaluation.md   # Section content
-├── analysis-integration-strategy.md    # Section content
-└── analysis-recommendations.md         # Section content (max 5 sub-docs total)
-
-NOTE: ALL files MUST start with 'analysis' prefix. Max 5 sub-documents.
+├── analysis.md                           # Role overview index (< 1500 words)
+├── analysis-cross-cutting.md             # Cross-feature decisions (< 2000 words)
+├── analysis-F-001-real-time-sync.md      # Per-feature analysis (< 2000 words)
+├── analysis-F-002-user-auth.md           # Per-feature analysis (< 2000 words)
+└── analysis-F-003-data-pipeline.md       # Per-feature analysis (< 2000 words)
+
+NOTE: ALL files MUST start with 'analysis' prefix.
+Feature-point mode: 1 index + 1 cross-cutting + N feature docs (N = feature count, max 8).
+Fallback mode: 1 index + max 5 arbitrary sub-docs.
 ```
 
 ## Role-Specific Planning Process
@@ -256,6 +268,16 @@ NOTE: ALL files MUST start with 'analysis' prefix. Max 5 sub-documents.
 - **Validate Against Template**: Ensure analysis meets role template requirements and standards
 
 ### 3. Brainstorming Documentation Phase
+
+**Feature-point mode** (when `feature_list` is available from guidance-specification.md):
+- **Read Feature List**: Extract Feature Decomposition table from guidance-specification.md
+- **Create analysis.md**: Role overview index (< 1500 words) with feature point listing and `@` references to sub-documents
+- **Create analysis-cross-cutting.md**: Cross-feature decisions, shared patterns, role-wide recommendations (< 2000 words)
+- **Create analysis-F-{id}-{slug}.md**: One per feature point, using ID and slug from feature list (< 2000 words each)
+- **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
+- **Naming Validation**: Verify ALL files start with `analysis` prefix, feature docs match `analysis-F-{id}-{slug}.md` pattern
+
+**Fallback mode** (when `feature_list` is NOT available):
 - **Create analysis.md**: Main document with overview (optionally with `@` references)
 - **Create sub-documents**: `analysis-{slug}.md` for major sections (max 5)
 - **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
@@ -311,6 +333,14 @@ When analysis is complete, ensure:
 ## Output Size Limits
 
 **Per-role limits** (prevent context overflow):
+
+**Feature-point mode** (when `feature_list` available):
+- `analysis.md` (index): < 1500 words
+- `analysis-cross-cutting.md`: < 2000 words
+- `analysis-F-{id}-{slug}.md`: < 2000 words each (one per feature, max 8 features)
+- Total: < 15000 words per role
+
+**Fallback mode** (when `feature_list` NOT available):
 - `analysis.md`: < 3000 words
 - `analysis-*.md`: < 2000 words each (max 5 sub-documents)
 - Total: < 15000 words per role

package/.claude/agents/context-search-agent.md

@@ -75,6 +75,20 @@ if (file_exists(contextPackagePath)) {
 }
 ```
 
+**1.1b Project Context Loading** (MANDATORY):
+```javascript
+// Load project-level context (from spec system)
+// These provide foundational constraints for ALL context gathering
+const projectSpecs = Bash('ccw spec load --category "exploration architecture" --stdin');
+const projectTech = projectSpecs?.tech_stack ? projectSpecs : null;
+const projectGuidelines = projectSpecs?.coding_conventions ? projectSpecs : null;
+
+// Usage:
+// - projectTech → Populate project_context fields (tech_stack, architecture_patterns)
+// - projectGuidelines → Apply as constraints during relevance scoring and conflict detection
+// - If missing: Proceed with fresh analysis (discover from codebase)
+```
+
 **1.2 Foundation Setup**:
 ```javascript
 // 1. Initialize CodexLens (if available)
@@ -165,12 +179,16 @@ if (file_exists(manifestPath)) {
 }
 
 // Synthesis helper functions (conceptual)
+// NOTE: relevant_files items are now structured objects:
+//   {path, relevance, rationale, role, discovery_source?, key_symbols?}
 function synthesizeCriticalFiles(allRelevantFiles) {
-  // 1. Group by path
+  // 1. Group by path (files are objects with .path property)
   // 2. Count mentions across angles
   // 3. Average relevance scores
-  // 4. Rank by: (mention_count * 0.6) + (avg_relevance * 0.4)
-  // 5. Return top 10-15 with mentioned_by_angles attribution
+  // 4. Merge rationales from different angles (join with "; ")
+  // 5. Collect unique roles and key_symbols across angles
+  // 6. Rank by: (mention_count * 0.6) + (avg_relevance * 0.4)
+  // 7. Return top 10-15 with: path, relevance, rationale, role, mentioned_by_angles, key_symbols
 }
 
 function synthesizeConflictIndicators(explorationData) {
@@ -271,6 +289,10 @@ score = (0.4 × direct_match) +      // Filename/path match
         (0.1 × dependency_link)      // Connection strength
 
 // Filter: Include only score > 0.5
+
+// Apply projectGuidelines constraints (from 1.1b) when available:
+// - Boost files matching projectGuidelines.quality_gates patterns
+// - Penalize files matching projectGuidelines.forbidden_patterns
 ```
 
 **3.2 Dependency Graph**
@@ -288,19 +310,23 @@ Merge with conflict resolution:
 
 ```javascript
 const context = {
-  // Priority: Project docs > Existing code > Web examples
-  architecture: ref_docs.patterns || code.structure,
+  // Priority: projectTech/projectGuidelines (1.1b) > Project docs > Existing code > Web examples
+  architecture: projectTech?.architecture_type || ref_docs.patterns || code.structure,
 
   conventions: {
-    naming: ref_docs.standards || code.actual_patterns,
-    error_handling: ref_docs.standards || code.patterns || web.best_practices
+    naming: projectGuidelines?.naming_rules || ref_docs.standards || code.actual_patterns,
+    error_handling: ref_docs.standards || code.patterns || web.best_practices,
+    forbidden_patterns: projectGuidelines?.forbidden_patterns || [],
+    quality_gates: projectGuidelines?.quality_gates || []
   },
 
   tech_stack: {
-    // Actual (package.json) takes precedence
-    language: code.actual.language,
-    frameworks: merge_unique([ref_docs.declared, code.actual]),
-    libraries: code.actual.libraries
+    // projectTech provides authoritative baseline; actual (package.json) fills gaps
+    language: projectTech?.tech_stack?.language || code.actual.language,
+    frameworks: merge_unique([projectTech?.tech_stack?.frameworks, ref_docs.declared, code.actual]),
+    libraries: merge_unique([projectTech?.tech_stack?.libraries, code.actual.libraries]),
+    build_system: projectTech?.build_system || code.actual.build_system,
+    test_framework: projectTech?.test_framework || code.actual.test_framework
   },
 
   // Web examples fill gaps
@@ -310,9 +336,9 @@ const context = {
 ```
 
 **Conflict Resolution**:
-1. Architecture: Docs > Code > Web
-2. Conventions: Declared > Actual > Industry
-3. Tech Stack: Actual (package.json) > Declared
+1. Architecture: projectTech > Docs > Code > Web
+2. Conventions: projectGuidelines > Declared > Actual > Industry
+3. Tech Stack: projectTech > Actual (package.json) > Declared
 4. Missing: Use web examples
 
 **3.5 Brainstorm Artifacts Integration**
@@ -338,8 +364,35 @@ if (dir_exists(brainstormDir)) {
     synthesis_output: {
       path: `${brainstormDir}/synthesis-specification.md`,
       exists: file_exists(`${brainstormDir}/synthesis-specification.md`),
-      content: Read(`${brainstormDir}/synthesis-specification.md`) || null
-    }
+      content: Read(`${brainstormDir}/synthesis-specification.md`) || null,
+      // New feature-driven artifacts (preferred over legacy synthesis-specification.md)
+      feature_driven: dir_exists(`${brainstormDir}/feature-specs`) ? {
+        feature_index: `${brainstormDir}/feature-specs/feature-index.json`,
+        feature_specs_dir: `${brainstormDir}/feature-specs/`
+      } : undefined
+    },
+    // Feature index (optional - top level, matches action-planning-agent expected access pattern)
+    feature_index: file_exists(`${brainstormDir}/feature-specs/feature-index.json`) ? {
+      path: `${brainstormDir}/feature-specs/feature-index.json`,
+      exists: true,
+      content: Read(`${brainstormDir}/feature-specs/feature-index.json`) || null
+    } : undefined,
+    // Convenience: direct path to feature-index.json (avoids hardcoding in task-generate-agent)
+    feature_index_path: file_exists(`${brainstormDir}/feature-specs/feature-index.json`)
+      ? `${brainstormDir}/feature-specs/feature-index.json`
+      : undefined,
+    // Feature spec files (optional - individual feature specifications)
+    feature_specs: dir_exists(`${brainstormDir}/feature-specs`)
+      ? glob(`${brainstormDir}/feature-specs/F-*-*.md`).map(file => ({
+          path: file,
+          content: Read(file)
+        }))
+      : undefined,
+    // Cross-cutting specs (optional - cross-cutting concern analyses from roles)
+    cross_cutting_specs: glob(`${brainstormDir}/*/analysis-cross-cutting.md`).map(file => ({
+      path: file,
+      content: Read(file)
+    }))
   };
 }
 ```
@@ -350,6 +403,8 @@ Calculate risk level based on:
 - Existing file count (<5: low, 5-15: medium, >15: high)
 - API/architecture/data model changes
 - Breaking changes identification
+- Violations of projectGuidelines.forbidden_patterns (from 1.1b, if available)
+- Deviations from projectGuidelines.coding_conventions (from 1.1b, if available)
 
 **3.7 Context Packaging & Output**
 
@@ -461,8 +516,30 @@ Calculate risk level based on:
     "synthesis_output": {
       "path": ".workflow/WFS-xxx/.brainstorming/synthesis-specification.md",
       "exists": true,
-      "content": "# Synthesis Specification\n\n## Cross-Role Integration\n..."
-    }
+      "content": "# Synthesis Specification\n\n## Cross-Role Integration\n...",
+      "feature_driven": {
+        "feature_index": ".workflow/WFS-xxx/.brainstorming/feature-specs/feature-index.json",
+        "feature_specs_dir": ".workflow/WFS-xxx/.brainstorming/feature-specs/"
+      }
+    },
+    "feature_index": {
+      "path": ".workflow/WFS-xxx/.brainstorming/feature-specs/feature-index.json",
+      "exists": true,
+      "content": "{\"version\":\"1.0\",\"features\":[...]}"
+    },
+    "feature_index_path": ".workflow/WFS-xxx/.brainstorming/feature-specs/feature-index.json",
+    "feature_specs": [
+      {
+        "path": ".workflow/WFS-xxx/.brainstorming/feature-specs/F-001-auth.md",
+        "content": "# Feature Spec: F-001 - Auth\n..."
+      }
+    ],
+    "cross_cutting_specs": [
+      {
+        "path": ".workflow/WFS-xxx/.brainstorming/system-architect/analysis-cross-cutting.md",
+        "content": "# Cross-Cutting: Architecture Decisions\n..."
+      }
+    ]
   },
   "conflict_detection": {
     "risk_level": "medium",
@@ -495,7 +572,7 @@ Calculate risk level based on:
       }
     ],
     "aggregated_insights": {
-      "critical_files": [{"path": "src/auth/AuthService.ts", "relevance": 0.95, "mentioned_by_angles": ["architecture"]}],
+      "critical_files": [{"path": "src/auth/AuthService.ts", "relevance": 0.95, "rationale": "Contains login/register/verifyToken - core auth entry points", "role": "modify_target", "mentioned_by_angles": ["architecture"], "key_symbols": ["AuthService", "login", "verifyToken"]}],
       "conflict_indicators": [{"type": "pattern_mismatch", "description": "...", "source_angle": "architecture", "severity": "medium"}],
       "clarification_needs": [{"question": "...", "context": "...", "options": [], "source_angle": "architecture"}],
       "constraints": [{"constraint": "Must follow existing DI pattern", "source_angle": "architecture"}],