prjct-cli 0.30.0 → 0.30.2

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [0.30.2] - 2026-01-13
+
+### Feature: PM Expert Auto-Enrichment
+
+**Problem:** Claude could start coding without properly understanding the task, leading to solutions that didn't match user intent.
+
+**Solution:** PM Expert enrichment now runs AUTOMATICALLY in `p. task` and `p. bug`:
+
+**`p. task` - 5-Phase Enrichment:**
+1. Intelligent Classification (type, priority, complexity)
+2. Technical Analysis (affected files, existing patterns)
+3. Dependency Detection (code, API, blockers)
+4. User Story + AC Generation
+5. Verify Understanding (ask if unclear)
+
+**`p. bug` - Quick Technical Analysis:**
+- Finds related files and recent commits
+- Assesses complexity (simple/medium/complex)
+- Suggests approach before auto-starting
+- For complex bugs, offers full PM Expert enrichment
+
+### Fix: Statusline Installation Issues
+
+- **IFS Restoration**: Fixed bash associative array iteration breaking after `read`
+- **Bash 4+ Detection**: Auto re-exec to Homebrew bash on macOS (ships with bash 3.2)
+- **VERSION Patching**: All 3 installation paths now correctly patch CLI_VERSION
+- **jq Boolean Fix**: `enabled: false` now correctly parsed (was treating as null)
+
+**Files:**
+- `templates/commands/task.md` - Added Step 3: PM Expert Enrichment
+- `templates/commands/bug.md` - Added Step 4.5: Quick Technical Analysis
+- `assets/statusline/lib/*.sh` - IFS restoration
+- `assets/statusline/statusline.sh` - Bash 4+ detection, VERSION placeholder
+- `scripts/postinstall.js` - VERSION patching
+- `bin/prjct` - VERSION patching in self-healing
+
+---
+
 ## [0.30.0] - 2026-01-12
 
 ### Fix: Distribution System Overhaul (CRITICAL)

package/assets/statusline/components/context.sh

@@ -1,31 +1,25 @@
 #!/bin/bash
 # prjct statusline - Context component
-# Displays context window usage progress bar
+# Displays context window usage (minimal - only when it matters)
 
 component_context() {
   component_enabled "context" || return
 
   # CTX_PERCENT is set by parse_stdin in cache.sh
-  local bar_width="${CONFIG_CONTEXT_BAR_WIDTH:-10}"
-  local filled=$((CTX_PERCENT * bar_width / 100))
-  local empty=$((bar_width - filled))
+  local min_percent="${CONFIG_CONTEXT_MIN_PERCENT:-30}"
+
+  # Only show when usage is significant
+  [[ "$CTX_PERCENT" -lt "$min_percent" ]] && return
 
   # Determine color based on usage
-  local bar_color
+  local color
   if [[ "$CTX_PERCENT" -ge 80 ]]; then
-    bar_color="$ERROR"
+    color="$ERROR"
   elif [[ "$CTX_PERCENT" -ge 50 ]]; then
-    bar_color="$ACCENT"
+    color="$ACCENT"
   else
-    bar_color="$SUCCESS"
+    color="$MUTED"
   fi
 
-  # Build progress bar
-  local bar="${bar_color}"
-  for ((i=0; i<filled; i++)); do bar+="█"; done
-  bar+="${MUTED}"
-  for ((i=0; i<empty; i++)); do bar+="░"; done
-  bar+="${NC}"
-
-  echo -e "${MUTED}ctx${NC} ${bar} ${MUTED}${CTX_PERCENT}%${NC}"
+  echo -e "${color}${CTX_PERCENT}%${NC}"
 }

package/assets/statusline/components/dir.sh

@@ -7,5 +7,5 @@ component_dir() {
 
   local dir_name=$(basename "$CWD")
 
-  echo -e "${ACCENT}${ICON_DIR} ${dir_name}${NC}"
+  echo -e "${ACCENT}${dir_name}${NC}"
 }

package/assets/statusline/components/git.sh

@@ -41,5 +41,5 @@ component_git() {
 
   [[ -z "$branch" ]] && return
 
-  echo -e "${SECONDARY}${ICON_GIT} ${branch}${dirty}${NC}"
+  echo -e "${SECONDARY}${branch}${dirty}${NC}"
 }

package/assets/statusline/default-config.json

@@ -36,10 +36,11 @@
     "context": {
       "enabled": true,
       "position": 6,
-      "barWidth": 10
+      "barWidth": 10,
+      "minPercent": 30
     },
     "model": {
-      "enabled": true,
+      "enabled": false,
       "position": 7
     }
   }

package/assets/statusline/lib/cache.sh

@@ -76,8 +76,10 @@ parse_stdin() {
     ] | @tsv
   ' 2>/dev/null)
 
-  # Parse tab-separated values
+  # Parse tab-separated values (save/restore IFS to avoid breaking associative arrays)
+  local old_ifs="$IFS"
   IFS=$'\t' read -r MODEL CWD ADDED REMOVED CTX_SIZE INPUT_TOKENS CACHE_CREATE CACHE_READ <<< "$parsed"
+  IFS="$old_ifs"
 
   # Set defaults if parsing failed
   MODEL="${MODEL:-Claude}"

package/assets/statusline/lib/config.sh

@@ -11,7 +11,7 @@ DEFAULT_CACHE_TTL_PRJCT=30
 DEFAULT_CACHE_TTL_GIT=5
 DEFAULT_CACHE_TTL_LINEAR=60
 DEFAULT_TASK_MAX_LENGTH=25
-DEFAULT_CONTEXT_BAR_WIDTH=10
+DEFAULT_CONTEXT_MIN_PERCENT=30
 
 # Component configuration (will be populated by load_config)
 declare -A COMPONENT_ENABLED
@@ -26,7 +26,7 @@ load_config() {
   CONFIG_CACHE_TTL_GIT="$DEFAULT_CACHE_TTL_GIT"
   CONFIG_CACHE_TTL_LINEAR="$DEFAULT_CACHE_TTL_LINEAR"
   CONFIG_TASK_MAX_LENGTH="$DEFAULT_TASK_MAX_LENGTH"
-  CONFIG_CONTEXT_BAR_WIDTH="$DEFAULT_CONTEXT_BAR_WIDTH"
+  CONFIG_CONTEXT_MIN_PERCENT="$DEFAULT_CONTEXT_MIN_PERCENT"
   CONFIG_LINEAR_ENABLED="true"
   CONFIG_LINEAR_SHOW_PRIORITY="true"
 
@@ -53,6 +53,7 @@ load_config() {
   [[ ! -f "$CONFIG_FILE" ]] && return
 
   # Parse config in a single jq call
+  # Note: Use "if .x == null then default else .x end" for booleans since // treats false as null
   local config_data
   config_data=$(jq -r '
     [
@@ -61,16 +62,16 @@ load_config() {
       (.cacheTTL.git // 5),
       (.cacheTTL.linear // 60),
       (.components.task.maxLength // 25),
-      (.components.context.barWidth // 10),
-      (.components.linear.showPriority // true),
-      (.components.prjct_icon.enabled // true),
-      (.components.task.enabled // true),
-      (.components.linear.enabled // true),
-      (.components.dir.enabled // true),
-      (.components.git.enabled // true),
-      (.components.changes.enabled // true),
-      (.components.context.enabled // true),
-      (.components.model.enabled // true),
+      (.components.context.minPercent // 30),
+      (if .components.linear.showPriority == null then true else .components.linear.showPriority end),
+      (if .components.prjct_icon.enabled == null then true else .components.prjct_icon.enabled end),
+      (if .components.task.enabled == null then true else .components.task.enabled end),
+      (if .components.linear.enabled == null then true else .components.linear.enabled end),
+      (if .components.dir.enabled == null then true else .components.dir.enabled end),
+      (if .components.git.enabled == null then true else .components.git.enabled end),
+      (if .components.changes.enabled == null then true else .components.changes.enabled end),
+      (if .components.context.enabled == null then true else .components.context.enabled end),
+      (if .components.model.enabled == null then false else .components.model.enabled end),
       (.components.prjct_icon.position // 0),
       (.components.task.position // 1),
       (.components.linear.position // 2),
@@ -84,14 +85,16 @@ load_config() {
 
   [[ -z "$config_data" ]] && return
 
-  # Parse tab-separated values
+  # Parse tab-separated values (save/restore IFS to avoid breaking associative arrays)
+  local old_ifs="$IFS"
   IFS=$'\t' read -r \
     CONFIG_THEME \
     CONFIG_CACHE_TTL_PRJCT CONFIG_CACHE_TTL_GIT CONFIG_CACHE_TTL_LINEAR \
-    CONFIG_TASK_MAX_LENGTH CONFIG_CONTEXT_BAR_WIDTH CONFIG_LINEAR_SHOW_PRIORITY \
+    CONFIG_TASK_MAX_LENGTH CONFIG_CONTEXT_MIN_PERCENT CONFIG_LINEAR_SHOW_PRIORITY \
     E_PRJCT_ICON E_TASK E_LINEAR E_DIR E_GIT E_CHANGES E_CONTEXT E_MODEL \
     P_PRJCT_ICON P_TASK P_LINEAR P_DIR P_GIT P_CHANGES P_CONTEXT P_MODEL \
     <<< "$config_data"
+  IFS="$old_ifs"
 
   # Set component enabled states
   COMPONENT_ENABLED["prjct_icon"]="$E_PRJCT_ICON"

package/assets/statusline/lib/theme.sh

@@ -89,11 +89,13 @@ load_theme() {
     return
   fi
 
-  # Parse theme data
+  # Parse theme data (save/restore IFS to avoid breaking associative arrays)
+  local old_ifs="$IFS"
   IFS=$'\t' read -r \
     C_PRIMARY C_ACCENT C_SECONDARY C_MUTED C_SUCCESS C_ERROR C_WARNING C_PURPLE \
     ICON_PRJCT ICON_DIR ICON_GIT ICON_SEPARATOR ICON_OPUS ICON_SONNET ICON_HAIKU ICON_DEFAULT ICON_PRIORITY_URGENT ICON_PRIORITY_HIGH ICON_PRIORITY_MEDIUM \
     <<< "$theme_data"
+  IFS="$old_ifs"
 
   # Convert color codes to escape sequences
   PRIMARY=$(color_to_escape "$C_PRIMARY")

package/assets/statusline/statusline.sh

@@ -1,11 +1,24 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # ============================================================================
 # prjct statusline v2 for Claude Code
 # Modular component system with graceful degradation
 # ============================================================================
 
-# Current CLI version (updated by postinstall/sync)
-CLI_VERSION="0.29.0"
+# Require bash 4.0+ for associative arrays
+if [[ ${BASH_VERSINFO[0]} -lt 4 ]]; then
+  # Try to find a modern bash and re-exec
+  for bash_path in /opt/homebrew/bin/bash /usr/local/bin/bash; do
+    if [[ -x "$bash_path" ]] && "$bash_path" -c '[[ ${BASH_VERSINFO[0]} -ge 4 ]]' 2>/dev/null; then
+      exec "$bash_path" "$0" "$@"
+    fi
+  done
+  # Fallback: simple output without components
+  echo "prjct"
+  exit 0
+fi
+
+# Current CLI version (replaced by postinstall/setup with actual version)
+CLI_VERSION="__VERSION__"
 
 # Base paths
 STATUSLINE_DIR="${HOME}/.prjct-cli/statusline"
@@ -56,7 +69,7 @@ parse_stdin "$INPUT"
 # ============================================================================
 build_statusline() {
   local line=""
-  local sep=" ${MUTED}${ICON_SEPARATOR}${NC} "
+  local sep=" ${MUTED}│${NC} "
   local first=true
 
   # Get sorted list of enabled components

package/assets/statusline/themes/default.json

@@ -2,17 +2,17 @@
   "name": "prjct-default",
   "description": "Default prjct theme for Claude Code statusline",
   "colors": {
-    "primary": "51",
-    "accent": "220",
-    "secondary": "147",
-    "muted": "242",
-    "success": "114",
-    "error": "204",
-    "warning": "214",
-    "purple": "183"
+    "primary": "75",
+    "accent": "252",
+    "secondary": "248",
+    "muted": "245",
+    "success": "108",
+    "error": "174",
+    "warning": "180",
+    "purple": "182"
   },
   "icons": {
-    "prjct": "⚡",
+    "prjct": "p/",
     "dir": "󰉋",
     "git": "",
     "separator": "│",

package/bin/prjct

@@ -5,7 +5,9 @@
 # Detects available runtime (bun preferred, node fallback)
 # and executes the appropriate entry point.
 #
-# @version 1.1.0
+# CRITICAL: Also ensures p.md is installed (self-healing)
+#
+# @version 1.2.0
 
 # Resolve symlinks to get the actual script location
 resolve_symlink() {
@@ -41,6 +43,63 @@ SCRIPT_PATH="$(resolve_symlink "$0")"
 SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
 ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
+# CRITICAL: Ensure p.md is installed (self-healing)
+# This runs EVERY time prjct is called, ensuring setup even if postinstall failed
+ensure_setup() {
+  CLAUDE_COMMANDS="$HOME/.claude/commands"
+  PMD_SRC="$ROOT_DIR/templates/commands/p.md"
+  PMD_DEST="$CLAUDE_COMMANDS/p.md"
+
+  # Create dir if needed
+  if [ ! -d "$CLAUDE_COMMANDS" ]; then
+    mkdir -p "$CLAUDE_COMMANDS" 2>/dev/null
+  fi
+
+  # Copy p.md if source exists and dest doesn't OR dest is older
+  if [ -f "$PMD_SRC" ]; then
+    if [ ! -f "$PMD_DEST" ]; then
+      cp "$PMD_SRC" "$PMD_DEST" 2>/dev/null
+    elif [ "$PMD_SRC" -nt "$PMD_DEST" ]; then
+      # Source is newer, update
+      cp "$PMD_SRC" "$PMD_DEST" 2>/dev/null
+    fi
+  fi
+
+  # Also ensure statusline (best effort)
+  STATUSLINE_SRC="$ROOT_DIR/assets/statusline/statusline.sh"
+  STATUSLINE_DIR="$HOME/.prjct-cli/statusline"
+  STATUSLINE_DEST="$STATUSLINE_DIR/statusline.sh"
+  CLAUDE_STATUSLINE="$HOME/.claude/prjct-statusline.sh"
+
+  if [ -f "$STATUSLINE_SRC" ]; then
+    mkdir -p "$STATUSLINE_DIR" 2>/dev/null
+    if [ ! -f "$STATUSLINE_DEST" ] || [ "$STATUSLINE_SRC" -nt "$STATUSLINE_DEST" ]; then
+      cp "$STATUSLINE_SRC" "$STATUSLINE_DEST" 2>/dev/null
+      chmod +x "$STATUSLINE_DEST" 2>/dev/null
+
+      # Patch CLI_VERSION with actual version from package.json
+      PKG_VERSION=$(grep '"version"' "$ROOT_DIR/package.json" 2>/dev/null | head -1 | sed 's/.*"version": *"\([^"]*\)".*/\1/')
+      if [ -n "$PKG_VERSION" ]; then
+        sed -i.bak "s/CLI_VERSION=\"[^\"]*\"/CLI_VERSION=\"$PKG_VERSION\"/" "$STATUSLINE_DEST" 2>/dev/null
+        rm -f "$STATUSLINE_DEST.bak" 2>/dev/null
+      fi
+
+      # Copy lib, components, themes
+      for subdir in lib components themes; do
+        if [ -d "$ROOT_DIR/assets/statusline/$subdir" ]; then
+          mkdir -p "$STATUSLINE_DIR/$subdir" 2>/dev/null
+          cp "$ROOT_DIR/assets/statusline/$subdir"/* "$STATUSLINE_DIR/$subdir/" 2>/dev/null
+        fi
+      done
+
+      # Symlink to ~/.claude
+      rm -f "$CLAUDE_STATUSLINE" 2>/dev/null
+      ln -s "$STATUSLINE_DEST" "$CLAUDE_STATUSLINE" 2>/dev/null || cp "$STATUSLINE_DEST" "$CLAUDE_STATUSLINE" 2>/dev/null
+      chmod +x "$CLAUDE_STATUSLINE" 2>/dev/null
+    fi
+  fi
+}
+
 # Check if bun is available
 check_bun() {
   command -v bun >/dev/null 2>&1
@@ -74,6 +133,9 @@ run_with_node() {
 
 # Main execution
 main() {
+  # ALWAYS ensure setup first (self-healing)
+  ensure_setup
+
   # Prefer bun if available (faster, native TS support)
   if check_bun; then
     run_with_bun "$@"

package/dist/bin/prjct.mjs

@@ -12541,7 +12541,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.29.10",
+      version: "0.30.1",
       description: "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

package/scripts/postinstall.js

@@ -17,6 +17,10 @@ const HOME = os.homedir()
 const CLAUDE_DIR = path.join(HOME, '.claude')
 const COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands')
 
+// Read version from package.json
+const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'))
+const VERSION = pkg.version
+
 console.log('\n   prjct-cli postinstall\n')
 
 // 1. Copy p.md router (CRITICAL - this is the only essential file)
@@ -48,11 +52,12 @@ try {
     fs.mkdirSync(path.join(STATUSLINE_DEST, 'components'), { recursive: true })
     fs.mkdirSync(path.join(STATUSLINE_DEST, 'themes'), { recursive: true })
 
-    // Copy main script
+    // Copy main script with version patched
     const mainScript = path.join(STATUSLINE_SRC, 'statusline.sh')
     if (fs.existsSync(mainScript)) {
-      fs.copyFileSync(mainScript, path.join(STATUSLINE_DEST, 'statusline.sh'))
-      fs.chmodSync(path.join(STATUSLINE_DEST, 'statusline.sh'), 0o755)
+      let content = fs.readFileSync(mainScript, 'utf-8')
+      content = content.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`)
+      fs.writeFileSync(path.join(STATUSLINE_DEST, 'statusline.sh'), content, { mode: 0o755 })
     }
 
     // Copy subdirs

package/templates/commands/bug.md

@@ -1,6 +1,6 @@
 ---
 allowed-tools: [Read, Write, Bash, Task, Glob, AskUserQuestion]
-description: 'Report bug with auto-priority and auto-start'
+description: 'Report bug with technical analysis and auto-start'
 architecture: 'Write-Through (JSON → MD → Events)'
 storage-layer: true
 source-of-truth: 'storage/queue.json + storage/state.json'
@@ -19,6 +19,8 @@ backend-sync: 'sync/pending.json'
 - `description`: Bug description
 - `--later`: Only queue, don't auto-start (default: auto-starts)
 
+**NEW**: Before auto-starting, Claude analyzes the codebase to understand the bug context.
+
 ## Architecture: Write-Through Pattern
 
 ```
@@ -110,6 +112,84 @@ WRITE: `{queuePath}`
 ### Calculate queue position
 {position} = index of task in array + 1
 
+## Step 4.5: Quick Technical Analysis (AUTOMÁTICO)
+
+**CRITICAL**: Before auto-starting a bug fix, ALWAYS analyze the codebase to understand context.
+
+### 4.5.1 Find Related Code
+
+```
+USE Task(Explore) to find:
+- Files likely related to the bug description
+- Recent commits touching those files
+- Test files for the affected area
+
+BASH: git log --oneline -10 -- {related_files}
+
+OUTPUT:
+## Bug Analysis
+
+Likely Affected Files:
+- `{file1}` - {reason it's likely involved}
+- `{file2}` - {reason it's likely involved}
+
+Related Commits:
+- {hash}: {message}
+- {hash}: {message}
+
+Test Files:
+- `{test_file}` - {what it tests}
+```
+
+### 4.5.2 Assess Complexity
+
+Based on analysis, determine if this is:
+
+| Complexity | Criteria | Action |
+|------------|----------|--------|
+| `simple` | 1-2 files, clear cause | Auto-start ✓ |
+| `medium` | 3-5 files, needs investigation | Ask user |
+| `complex` | Many files, unclear root cause | Suggest full enrichment |
+
+```
+IF complexity == "complex":
+  USE AskUserQuestion:
+    question: "This bug may be complex (multiple files, unclear cause). How to proceed?"
+    options:
+      - label: "Full PM Expert analysis"
+        description: "Run complete enrichment before fixing"
+      - label: "Start investigating"
+        description: "Begin fix now, analyze as you go"
+      - label: "Queue for later"
+        description: "Add to queue without starting"
+
+  IF "Full PM Expert analysis":
+    OUTPUT: "Running full enrichment..."
+    # Execute PM Expert 5-phase enrichment (from enrich.md)
+    CONTINUE with enrichment
+
+  IF "Queue for later":
+    SET: {laterFlag} = true
+    {autoStarted} = false
+    → Skip to Step 6
+```
+
+### 4.5.3 Suggest Approach
+
+```
+OUTPUT:
+## Suggested Approach
+
+Root cause hypothesis: {based on code analysis}
+
+Steps to fix:
+1. {first step}
+2. {second step}
+3. {verification}
+
+Ready to start fixing? [Continue / Ask questions]
+```
+
 ## Step 5: Handle Active Task (AGENTIC)
 
 READ: `{statePath}`
@@ -327,10 +407,18 @@ ELSE:
 ```
 🐛 [{severity}] {description}
 
+## Bug Analysis
+Affected: {file1}, {file2}
+Hypothesis: {root_cause_hypothesis}
+
 Branch: {branchName}
 Session: {sessionId}
 
-/p:done when fixed
+Approach:
+1. {step1}
+2. {step2}
+
+Next: Fix the bug, then `p. done`
 ```
 
 ### Queue Only (--later flag)

package/templates/commands/task.md

@@ -1,11 +1,11 @@
 ---
 allowed-tools: [Read, Write, Bash, Task, Glob, Grep, AskUserQuestion]
-description: 'Unified task workflow with intelligent classification'
+description: 'Unified task workflow with PM Expert enrichment'
 ---
 
 # p. task - Start Any Task
 
-Start any work with automatic classification and intelligent breakdown.
+Start any work with **automatic PM Expert enrichment** to ensure proper understanding before coding.
 
 ## Context Variables
 
@@ -19,13 +19,21 @@ Start any work with automatic classification and intelligent breakdown.
 
 ```
 1. Validate project exists
-2. Handle active task conflict (if any)
-3. Classify task type (agentic reasoning)
-4. Create git branch (if on main)
-5. Run 5-phase workflow
-6. Update storage + context
-7. Output summary
-```
+2. Handle no task / active task conflict
+3. PM EXPERT ENRICHMENT (5 phases - ALWAYS runs)
+   3.1 Intelligent Classification
+   3.2 Technical Analysis
+   3.3 Dependency Detection
+   3.4 User Story + AC Generation
+   3.5 Verify Understanding
+4. PRD Check (informed by enrichment)
+5. Git branch management
+6. Design + Task Breakdown
+7. Update storage + context
+8. Output summary
+```
+
+**CRITICAL**: PM Expert Enrichment runs AUTOMATICALLY before any coding starts.
 
 ---
 
@@ -43,104 +51,7 @@ IF file not found:
 
 ---
 
-## Step 1.5: PRD Check (AI Orchestration)
-
-**CRITICAL**: Check if a PRD exists for significant features.
-
-```
-# Skip PRD check if no task provided (handled in Step 2)
-IF no task provided:
-  SKIP to Step 2
-
-# Read orchestration config
-READ: .prjct/prjct.config.json
-SET: prdRequired = config.orchestration?.prdRequired || "standard"
-
-# Skip for off mode
-IF prdRequired == "off":
-  CONTINUE to Step 2
-
-# Quick classification (before full classification)
-SET: isSignificantWork = FALSE
-
-# Significant if:
-# - Contains "feature", "add", "create", "build", "implement"
-# - NOT a bug fix, chore, or small improvement
-# - Estimated > 4 hours of work
-
-IF task likely requires significant effort:
-  SET: isSignificantWork = TRUE
-
-# Check for existing PRD
-IF isSignificantWork:
-  READ: {globalPath}/storage/prds.json
-
-  # Search for matching PRD
-  SET: matchingPRD = null
-  FOR EACH prd in prds:
-    IF prd.title matches task (fuzzy):
-      SET: matchingPRD = prd
-      BREAK
-
-  IF matchingPRD exists:
-    # PRD found - link to it
-    OUTPUT: "📋 Found PRD: {matchingPRD.title} (status: {matchingPRD.status})"
-    SET: linkedPRDId = matchingPRD.id
-
-  ELSE:
-    # No PRD found - handle based on enforcement level
-    IF prdRequired == "strict":
-      OUTPUT: "⛔ PRD Required"
-      OUTPUT: "This task requires a PRD before starting."
-      OUTPUT: "Run `p. prd \"{task}\"` to create one."
-      STOP
-
-    ELSE IF prdRequired == "standard":
-      OUTPUT: "⚠️  No PRD found for this task"
-      OUTPUT: ""
-      OUTPUT: "For better tracking and planning, consider creating a PRD first."
-      OUTPUT: ""
-
-      USE AskUserQuestion:
-        question: "How would you like to proceed?"
-        options:
-          - label: "Create PRD first (recommended)"
-            description: "Run Chief Architect to document requirements"
-          - label: "Continue without PRD"
-            description: "Start working now, skip documentation"
-          - label: "This is a small task"
-            description: "Mark as not needing PRD"
-
-      IF "Create PRD first":
-        OUTPUT: "Running `p. prd \"{task}\"`..."
-        # Invoke PRD command
-        STOP (prd command will continue)
-
-      IF "This is a small task":
-        # Continue but don't warn again for this task
-        SET: skipPRDCheck = TRUE
-
-    ELSE IF prdRequired == "relaxed":
-      OUTPUT: "💡 Tip: Run `p. prd \"{task}\"` for better tracking"
-      # Continue without blocking
-```
-
-### Legacy Work Exemption
-
-```
-# Check if this is part of a legacy feature
-READ: {globalPath}/storage/roadmap.json
-
-FOR EACH feature in roadmap.features:
-  IF feature.legacy == TRUE AND feature matches task:
-    OUTPUT: "ℹ️  This is part of legacy feature '{feature.name}' - no PRD required"
-    SET: skipPRDCheck = TRUE
-    BREAK
-```
-
----
-
-## Step 2: Handle No Task Description
+## Step 2: Handle No Task / Active Task Conflict
 
 ```
 IF no task provided:
@@ -152,14 +63,6 @@ IF no task provided:
   ELSE:
     OUTPUT: "No current task. Use `p. task <description>` to start one."
     STOP
-```
-
----
-
-## Step 3: Handle Active Task Conflict
-
-```
-READ: {globalPath}/storage/state.json
 
 IF currentTask exists AND status == "active" AND description != {task}:
   USE AskUserQuestion:
@@ -172,11 +75,13 @@ IF currentTask exists AND status == "active" AND description != {task}:
 
 ---
 
-## Step 4: Agentic Classification
+## Step 3: PM Expert Enrichment (AUTOMÁTICO)
 
-**CRITICAL: Use reasoning, NOT keyword matching.**
+**CRITICAL**: Before ANY coding, ALWAYS run PM Expert enrichment to ensure proper understanding.
 
-Analyze the task holistically:
+### 3.1 Intelligent Classification
+
+Analyze the task using REASONING, not keyword matching:
 
 | Type | When to Use |
 |------|-------------|
@@ -186,154 +91,282 @@ Analyze the task holistically:
 | `refactor` | Reorganizes code, same behavior |
 | `chore` | Maintenance, deps, docs, config |
 
-**Reasoning Examples:**
-- "add error handling to login" → Reasoning: Adding new functionality → `feature`
-- "fix button that doesn't submit" → Reasoning: Broken behavior → `bug`
-- "make dashboard load faster" → Reasoning: Enhancing performance → `improvement`
-- "split UserService into modules" → Reasoning: Reorganizing code → `refactor`
+| Priority | Criteria |
+|----------|----------|
+| `critical` | Production broken, data loss risk |
+| `high` | Blocks users, security issue |
+| `medium` | Important but not blocking |
+| `low` | Nice to have, cosmetic |
+
+| Complexity | Hours | Files |
+|------------|-------|-------|
+| `trivial` | < 1h | 1-2 |
+| `small` | 1-4h | 2-5 |
+| `medium` | 4-16h | 5-15 |
+| `large` | 16-40h | 15+ |
+| `epic` | > 40h | Many |
 
 ```
 OUTPUT:
-Analyzing: {task}
-Intent: {your reasoning}
-Classification: {taskType}
+## Classification
+
+Task: {task}
+Type: {taskType} | Priority: {priority} | Complexity: {complexity}
+
+Reasoning: {why this classification}
 ```
 
----
+### 3.2 Technical Analysis
 
-## Step 5: Git Branch Management
+**ALWAYS use Task(Explore) to understand the codebase BEFORE proposing solutions.**
 
 ```
-BASH: git branch --show-current
-SET: currentBranch = result
+USE Task(Explore) to find:
+- Similar existing code patterns
+- Related files that would be affected
+- API endpoints involved
+- Database schemas touched
+- Test files related
 
-IF currentBranch == "main" OR currentBranch == "master":
-  # Handle uncommitted changes first
-  IF git status shows changes:
-    USE AskUserQuestion: "Uncommitted changes. Stash, commit, or abort?"
+OUTPUT:
+## Technical Analysis
 
-  # Create branch
-  SET: branchName = {taskType}/{slugify(task)}
-  BASH: git checkout -b {branchName}
-  OUTPUT: "Created branch: {branchName}"
-```
+Affected Files:
+- `{file1}` - {expected changes}
+- `{file2}` - {expected changes}
+- `{file3}` - {expected changes}
 
----
+Existing Patterns:
+- {pattern} in `{file}` - {how to follow it}
 
-## 5-Phase Workflow
+Suggested Approach:
+{high-level implementation strategy based on codebase patterns}
+```
+
+### 3.3 Dependency Detection
 
-### Phase 1: Discovery
-Summarize what you understand:
 ```
-Building: {one-sentence summary}
-Type: {taskType}
+ANALYZE:
+- Code imports/exports (what files depend on what)
+- API calls (fetch, axios, internal services)
+- Database queries (tables, schemas affected)
+- Other tasks in queue (potential blockers)
+- External services (third-party APIs)
+
+OUTPUT:
+## Dependencies
+
+Code Dependencies:
+- `{file}` - {reason} ({low|medium|high} risk)
 
-Requirements:
-- {req 1}
-- {req 2}
+API Dependencies:
+- {endpoint} - {status}
 
-Success looks like:
-- {criteria 1}
-- {criteria 2}
+Blocking Tasks:
+- {taskId}: {title} ({status}) OR "None"
+
+External:
+- {service} - {purpose} OR "None"
 ```
 
-### Phase 2: Exploration
-Use Task(Explore) agent to find:
-- Similar existing code
-- Patterns used in this codebase
-- Key files that would be affected
+### 3.4 User Story + Acceptance Criteria
 
-**Load skills based on task type:**
 ```
-READ: {globalPath}/config/skills.json (if exists)
+GENERATE user story in format:
+"As a {role}, I want to {action} so that {benefit}."
+
+GENERATE 3-7 acceptance criteria based on technical analysis:
+
+OUTPUT:
+## User Story
 
-IF task involves UI/frontend:
-  Invoke Skill("frontend-design") for design patterns
-  OUTPUT: "🎨 Using frontend-design skill"
+As a **{role}**, I want to **{action}** so that **{benefit}**.
 
-IF task involves backend/API:
-  Invoke Skill("javascript-typescript") OR Skill("python-development")
-  OUTPUT: "⚙️ Using {skill} skill"
+## Acceptance Criteria
+
+- [ ] {AC-1}: When {action}, then {expected result}
+- [ ] {AC-2}: When {action}, then {expected result}
+- [ ] {AC-3}: When {action}, then {expected result}
+...
+
+## Definition of Done
+
+- [ ] All acceptance criteria pass
+- [ ] Tests written and passing
+- [ ] Code reviewed (if team)
+- [ ] No regressions introduced
 ```
 
+### 3.5 Verify Understanding
+
 ```
+IF anything is UNCLEAR about:
+- What the user wants to achieve
+- How it should behave
+- Edge cases to handle
+- Priority of different aspects
+
+THEN:
+  USE AskUserQuestion to clarify BEFORE proceeding
+  DO NOT assume or invent requirements
+
 OUTPUT:
-Found similar:
-- {code} in {file}
+## Enrichment Complete
+
+Type: {type} | Priority: {priority} | Complexity: {complexity}
+Affected: {count} files | Dependencies: {count}
+
+User Story: As a {role}, I want to {action}...
+
+AC: {count} criteria defined
+
+Questions: {any_remaining_questions OR "All clear ✓"}
+```
+
+---
+
+## Step 4: PRD Check (Informed by Enrichment)
+
+Now that we have enrichment data, check if PRD is needed:
+
+```
+# Read orchestration config
+READ: .prjct/prjct.config.json
+SET: prdRequired = config.orchestration?.prdRequired || "standard"
+
+# Skip for off mode or trivial/small tasks
+IF prdRequired == "off" OR complexity in ["trivial", "small"]:
+  CONTINUE to Step 5
+
+# Check for existing PRD
+IF complexity in ["medium", "large", "epic"]:
+  READ: {globalPath}/storage/prds.json
+
+  # Search for matching PRD
+  SET: matchingPRD = null
+  FOR EACH prd in prds:
+    IF prd.title matches task (fuzzy):
+      SET: matchingPRD = prd
+      BREAK
+
+  IF matchingPRD exists:
+    OUTPUT: "📋 Found PRD: {matchingPRD.title} (status: {matchingPRD.status})"
+    SET: linkedPRDId = matchingPRD.id
+
+  ELSE IF prdRequired == "strict":
+    OUTPUT: "⛔ PRD Required for {complexity} tasks"
+    OUTPUT: "Run `p. prd \"{task}\"` to create one."
+    STOP
+
+  ELSE IF prdRequired == "standard" AND complexity in ["large", "epic"]:
+    USE AskUserQuestion:
+      question: "This is a {complexity} task. Create PRD first?"
+      options:
+        - label: "Create PRD (recommended)"
+          description: "Document requirements properly"
+        - label: "Continue without PRD"
+          description: "I understand the risks"
 
-Patterns used:
-- {pattern}: {where}
+    IF "Create PRD":
+      OUTPUT: "Running `p. prd \"{task}\"`..."
+      STOP (prd command will continue)
+```
+
+### Legacy Work Exemption
 
-Key files:
-- {file}: {what changes}
+```
+READ: {globalPath}/storage/roadmap.json
 
-Skills activated: {skills used}
+FOR EACH feature in roadmap.features:
+  IF feature.legacy == TRUE AND feature matches task:
+    OUTPUT: "ℹ️  Legacy feature - no PRD required"
+    BREAK
 ```
 
-### Phase 3: Questions
-If anything is unclear, use AskUserQuestion.
-If everything is clear, say so and continue.
+---
 
-### Phase 4: Design
-Load relevant agents from `{globalPath}/agents/` and their linked skills:
+## Step 5: Git Branch Management
 
-**Agent + Skill Loading:**
 ```
-FOR EACH relevant agent in {globalPath}/agents/:
+BASH: git branch --show-current
+SET: currentBranch = result
+
+IF currentBranch == "main" OR currentBranch == "master":
+  # Handle uncommitted changes first
+  IF git status shows changes:
+    USE AskUserQuestion: "Uncommitted changes. Stash, commit, or abort?"
+
+  # Create branch
+  SET: branchName = {taskType}/{slugify(task)}
+  BASH: git checkout -b {branchName}
+  OUTPUT: "Created branch: {branchName}"
+```
+
+---
+
+## Step 6: Design + Task Breakdown
+
+Now that enrichment is complete, design the solution and break into subtasks.
+
+### Load Domain Agents + Skills
+
+```
+READ: {globalPath}/agents/ → find relevant agents for task type
+
+FOR EACH relevant agent:
   READ agent file
   PARSE frontmatter → get `skills` array
 
   IF skills exist:
-    FOR EACH skill in skills:
-      Invoke Skill(skill) for domain expertise
-      OUTPUT: "📚 {agent} using /{skill}"
+    Invoke Skill(skill) for domain expertise
+    OUTPUT: "📚 {agent} using /{skill}"
+
+Example:
+- UI feature → Load uxui.md → Invoke /frontend-design
+- Backend → Load backend.md → Invoke /javascript-typescript
 ```
 
-**Example flow for UI feature:**
-1. Load `uxui.md` agent (has `skills: [frontend-design]`)
-2. Invoke `/frontend-design` skill
-3. Skill provides anti-AI-slop patterns, typography guidelines
-4. Agent applies them to design options
+### Propose 2-3 Approaches
 
-Propose 2-3 approaches:
+Based on enrichment Technical Analysis, propose options:
 
 ```
 ### Option 1: Minimal
 - Approach: {desc}
-- Files: {count}
-- Pros/Cons: ...
+- Files: {count from enrichment}
+- Pros: Fast, low risk
+- Cons: May need refactor later
 
 ### Option 2: Clean Architecture
 - Approach: {desc}
 - Files: {count}
-- Pros/Cons: ...
+- Pros: Maintainable
+- Cons: More initial work
 
-### Option 3: Recommended (Skill-informed)
-- Approach: {desc}
-- Files: {count}
-- Pros/Cons: ...
-- Skills applied: {skills}
+### Recommended: Option {N}
+Reason: {based on codebase patterns found in enrichment}
 ```
 
-Use AskUserQuestion to get approval.
+USE AskUserQuestion to get approval if options differ significantly.
+
+### Task Breakdown
 
-### Phase 5: Task Breakdown
 Break into actionable subtasks:
 - Each task: 30min - 2h
-- Ordered by dependency
+- Ordered by dependency (from Dependency Detection)
 - Include testing as final task
 
 ```
 Tasks for {task}:
-1. {subtask 1}
-2. {subtask 2}
+1. {subtask 1} - {file(s)}
+2. {subtask 2} - {file(s)}
 ...
-n. Write tests and verify
+n. Write tests and verify AC
 ```
 
 ---
 
-## Step 6: Update Storage
+## Step 7: Update Storage
 
 ### Write state.json
 ```json
@@ -374,7 +407,7 @@ Branch: {branchName}
 
 ---
 
-## Step 7: Log to Memory
+## Step 8: Log to Memory
 
 ```
 APPEND to {globalPath}/memory/events.jsonl:
@@ -386,10 +419,14 @@ APPEND to {globalPath}/memory/events.jsonl:
 ## Output
 
 ```
-{task}
-Type: {taskType}
+## {task}
 
+Type: {taskType} | Priority: {priority} | Complexity: {complexity}
 Branch: {branchName}
+
+User Story: As a {role}, I want to {action}...
+
+Affected: {count} files
 Subtasks: {count}
 
 Started: {firstSubtask}