loki-mode 6.62.0 → 6.63.0

package/autonomy/run.sh

@@ -183,7 +183,7 @@ if [[ -z "${LOKI_RUNNING_FROM_TEMP:-}" ]] && [[ "${BASH_SOURCE[0]}" == "${0}" ]]
     cp "${BASH_SOURCE[0]}" "$TEMP_SCRIPT"
     chmod 700 "$TEMP_SCRIPT"
     # BUG-XC-011: Set trap BEFORE exec so the temp file gets cleaned up
-    trap "rm -f '$TEMP_SCRIPT'" EXIT
+    trap 'rm -f "$TEMP_SCRIPT"' EXIT
     export LOKI_RUNNING_FROM_TEMP=1
     export LOKI_ORIGINAL_SCRIPT_DIR="$SCRIPT_DIR"
     export LOKI_ORIGINAL_PROJECT_DIR="$PROJECT_DIR"
@@ -508,6 +508,13 @@ mapping = {
     'model.fast': 'LOKI_MODEL_FAST',
     'notify.slack': 'LOKI_SLACK_WEBHOOK',
     'notify.discord': 'LOKI_DISCORD_WEBHOOK',
+    'provider': 'LOKI_PROVIDER',
+    'issue.provider': 'LOKI_ISSUE_PROVIDER',
+    'blind_validation': 'LOKI_BLIND_VALIDATION',
+    'adversarial_testing': 'LOKI_ADVERSARIAL_TESTING',
+    'spawn_timeout': 'LOKI_SPAWN_TIMEOUT',
+    'spawn_retries': 'LOKI_SPAWN_RETRIES',
+    'budget': 'LOKI_BUDGET_LIMIT',
 }
 for key, env_var in mapping.items():
     # Try nested dict lookup first, then flat key, then underscore variant
@@ -2108,8 +2115,10 @@ create_worktree() {
         git -C "$TARGET_DIR" worktree add "$worktree_path" -b "$branch_name" 2>/dev/null && wt_exit=0 || \
         { git -C "$TARGET_DIR" worktree add "$worktree_path" "$branch_name" 2>/dev/null && wt_exit=0; }
     else
-        # Track main branch
-        git -C "$TARGET_DIR" worktree add "$worktree_path" main 2>/dev/null && wt_exit=0 || \
+        # BUG-PAR-001: Testing/docs worktrees use -b parallel-<stream> main (not bare main checkout)
+        # This avoids "already checked out" errors and keeps each worktree on its own branch
+        git -C "$TARGET_DIR" worktree add "$worktree_path" -b "parallel-${stream_name}" main 2>/dev/null && wt_exit=0 || \
+        { git -C "$TARGET_DIR" worktree add "$worktree_path" "parallel-${stream_name}" 2>/dev/null && wt_exit=0; } || \
         { git -C "$TARGET_DIR" worktree add "$worktree_path" HEAD 2>/dev/null && wt_exit=0; }
     fi
 
@@ -2164,8 +2173,11 @@ remove_worktree() {
 
     # Remove worktree (with safety check for rm -rf)
     git -C "$TARGET_DIR" worktree remove "$worktree_path" --force 2>/dev/null || {
-        # Safety check: only rm -rf if path looks like a worktree (contains .git or is under TARGET_DIR)
-        if [[ -n "$worktree_path" && "$worktree_path" != "/" && "$worktree_path" == "$TARGET_DIR"* ]]; then
+        # BUG-PAR-005: Safety check uses dirname with trailing / to prevent prefix-match false positives
+        # e.g. TARGET_DIR=/foo/bar must not match /foo/bar-other
+        local parent_dir
+        parent_dir="$(dirname "$TARGET_DIR")/"
+        if [[ -n "$worktree_path" && "$worktree_path" != "/" && "$worktree_path" == "${parent_dir}"* ]]; then
             rm -rf "$worktree_path" 2>/dev/null
         else
             log_warn "Skipping unsafe rm -rf for path: $worktree_path"
@@ -2198,7 +2210,11 @@ spawn_worktree_session() {
     done
 
     if [ "$active_count" -ge "$MAX_PARALLEL_SESSIONS" ]; then
-        log_warn "Max parallel sessions reached ($MAX_PARALLEL_SESSIONS). Waiting..."
+        # BUG-PAR-014: Max-sessions rejection queues spawn for retry
+        log_warn "Max parallel sessions reached ($MAX_PARALLEL_SESSIONS). Queuing $stream_name for retry."
+        mkdir -p "${TARGET_DIR:-.}/.loki/signals"
+        echo "{\"stream\":\"$stream_name\",\"task\":\"$(echo "$task_prompt" | head -c 200)\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" \
+            > "${TARGET_DIR:-.}/.loki/signals/SPAWN_QUEUED_${stream_name}"
         return 1
     fi
 
@@ -2249,19 +2265,31 @@ spawn_worktree_session() {
 
         # Completion signaling (v6.7.0)
         if [ $_wt_exit -eq 0 ]; then
-            # Commit any uncommitted work
-            git -C "$worktree_path" add -A 2>/dev/null
+            # BUG-PAR-006: git add excludes .env, *.key, *.pem, credentials*
+            git -C "$worktree_path" add -A \
+                ':!.env' ':!*.key' ':!*.pem' ':!credentials*' 2>/dev/null
             git -C "$worktree_path" commit -m "feat($stream_name): worktree work complete" 2>/dev/null || true
-            # Signal merge readiness to main orchestrator
+            # BUG-PAR-008: Signal files written atomically (temp + mv)
             mkdir -p "${TARGET_DIR:-.}/.loki/signals"
-            cat > "${TARGET_DIR:-.}/.loki/signals/MERGE_REQUESTED_${stream_name}" <<EOSIG
+            local _sig_tmp
+            _sig_tmp=$(mktemp "${TARGET_DIR:-.}/.loki/signals/.tmp.XXXXXX") || true
+            cat > "$_sig_tmp" <<EOSIG
 {"stream":"$stream_name","branch":"$(git -C "$worktree_path" branch --show-current 2>/dev/null)","worktree":"$worktree_path","timestamp":"$(date -u +%Y-%m-%dT%H:%M:%SZ)","exit_code":$_wt_exit}
 EOSIG
+            mv "$_sig_tmp" "${TARGET_DIR:-.}/.loki/signals/MERGE_REQUESTED_${stream_name}" 2>/dev/null || \
+                cp "$_sig_tmp" "${TARGET_DIR:-.}/.loki/signals/MERGE_REQUESTED_${stream_name}" 2>/dev/null
+            rm -f "$_sig_tmp" 2>/dev/null
             echo "WORKTREE_COMPLETE: $stream_name" >> "$log_file"
         else
+            # BUG-PAR-008: Signal files written atomically (temp + mv)
             mkdir -p "${TARGET_DIR:-.}/.loki/signals"
+            local _fail_tmp
+            _fail_tmp=$(mktemp "${TARGET_DIR:-.}/.loki/signals/.tmp.XXXXXX") || true
             echo "{\"stream\":\"$stream_name\",\"status\":\"failed\",\"exit_code\":$_wt_exit,\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" \
-                > "${TARGET_DIR:-.}/.loki/signals/WORKTREE_FAILED_${stream_name}"
+                > "$_fail_tmp"
+            mv "$_fail_tmp" "${TARGET_DIR:-.}/.loki/signals/WORKTREE_FAILED_${stream_name}" 2>/dev/null || \
+                cp "$_fail_tmp" "${TARGET_DIR:-.}/.loki/signals/WORKTREE_FAILED_${stream_name}" 2>/dev/null
+            rm -f "$_fail_tmp" 2>/dev/null
         fi
     ) &
 
@@ -2284,9 +2312,12 @@ merge_worktree() {
         return 1
     fi
 
+    # BUG-PAR-013: Signal file parsing falls back to jq when python3 unavailable
     local branch worktree_path
-    branch=$(python3 -c "import json; print(json.load(open('$signal_file'))['branch'])" 2>/dev/null)
-    worktree_path=$(python3 -c "import json; print(json.load(open('$signal_file'))['worktree'])" 2>/dev/null)
+    branch=$(python3 -c "import json; print(json.load(open('$signal_file'))['branch'])" 2>/dev/null) || \
+        branch=$(jq -r '.branch' "$signal_file" 2>/dev/null) || true
+    worktree_path=$(python3 -c "import json; print(json.load(open('$signal_file'))['worktree'])" 2>/dev/null) || \
+        worktree_path=$(jq -r '.worktree' "$signal_file" 2>/dev/null) || true
 
     if [ -z "$branch" ]; then
         log_error "Could not determine branch for: $stream_name"
@@ -2295,9 +2326,16 @@ merge_worktree() {
 
     log_step "Merging worktree: $stream_name (branch: $branch)"
 
-    # Merge into current branch
+    # BUG-PAR-009: Verify git checkout main before merge
     local current_branch
     current_branch=$(git -C "${TARGET_DIR:-.}" branch --show-current 2>/dev/null)
+    if [ "$current_branch" != "main" ]; then
+        log_info "Switching to main before merge (was on: $current_branch)"
+        if ! git -C "${TARGET_DIR:-.}" checkout main 2>/dev/null; then
+            log_error "Failed to checkout main for merge: $stream_name"
+            return 1
+        fi
+    fi
 
     if git -C "${TARGET_DIR:-.}" merge --no-ff "$branch" -m "merge($stream_name): auto-merge from parallel worktree" 2>&1; then
         log_info "Merge successful: $stream_name"
@@ -2440,50 +2478,51 @@ Output ONLY the resolved file content with no conflict markers. No explanations.
 }
 
 # Merge a completed feature branch (with AI conflict resolution)
+# BUG-PAR-011: Not in a subshell -- uses git -C instead of cd
+# BUG-PAR-003: Strips feature- prefix to avoid feature/feature-auth double-prefix
 merge_feature() {
     local feature="$1"
-    local branch="feature/$feature"
+    # BUG-PAR-003: Strip feature- prefix if present to avoid double-prefix (feature/feature-auth)
+    local clean_feature="${feature#feature-}"
+    local branch="feature/$clean_feature"
 
-    log_step "Merging feature: $feature"
+    log_step "Merging feature: $clean_feature"
 
-    (
-        cd "$TARGET_DIR" || exit 1
+    # BUG-PAR-011: Ensure we're on main using git -C (no subshell)
+    git -C "$TARGET_DIR" checkout main 2>/dev/null
 
-        # Ensure we're on main
-        git checkout main 2>/dev/null
-
-        # Attempt merge with no-ff for clear history
-        if git merge "$branch" --no-ff -m "feat: Merge $feature" 2>/dev/null; then
-            log_info "Merged cleanly: $feature"
+    # Attempt merge with no-ff for clear history
+    if git -C "$TARGET_DIR" merge "$branch" --no-ff -m "feat: Merge $clean_feature" 2>/dev/null; then
+        log_info "Merged cleanly: $clean_feature"
+    else
+        # Merge has conflicts - try AI resolution
+        log_warn "Merge conflicts detected - attempting AI resolution"
+
+        if resolve_conflicts_with_ai "$clean_feature"; then
+            # AI resolved conflicts, commit the merge
+            git -C "$TARGET_DIR" commit -m "feat: Merge $clean_feature (AI-resolved conflicts)"
+            audit_agent_action "git_commit" "Committed changes" "merge=$clean_feature,resolution=ai"
+            log_info "Merged with AI conflict resolution: $clean_feature"
         else
-            # Merge has conflicts - try AI resolution
-            log_warn "Merge conflicts detected - attempting AI resolution"
-
-            if resolve_conflicts_with_ai "$feature"; then
-                # AI resolved conflicts, commit the merge
-                git commit -m "feat: Merge $feature (AI-resolved conflicts)"
-                audit_agent_action "git_commit" "Committed changes" "merge=$feature,resolution=ai"
-                log_info "Merged with AI conflict resolution: $feature"
-            else
-                # AI resolution failed, abort merge
-                log_error "AI conflict resolution failed: $feature"
-                git merge --abort 2>/dev/null || true
-                return 1
-            fi
+            # AI resolution failed, abort merge
+            log_error "AI conflict resolution failed: $clean_feature"
+            git -C "$TARGET_DIR" merge --abort 2>/dev/null || true
+            return 1
         fi
+    fi
 
-        # Remove signal
-        rm -f ".loki/signals/MERGE_REQUESTED_$feature"
+    # Remove signal
+    rm -f "$TARGET_DIR/.loki/signals/MERGE_REQUESTED_$feature"
 
-        # Remove worktree
-        remove_worktree "feature-$feature"
+    # Remove worktree
+    remove_worktree "feature-$clean_feature"
 
-        # Delete branch
-        git branch -d "$branch" 2>/dev/null || true
+    # Delete branch
+    git -C "$TARGET_DIR" branch -d "$branch" 2>/dev/null || true
 
-        # Signal for docs update
-        touch ".loki/signals/DOCS_NEEDED"
-    )
+    # Signal for docs update
+    mkdir -p "$TARGET_DIR/.loki/signals"
+    touch "$TARGET_DIR/.loki/signals/DOCS_NEEDED"
 }
 
 # Initialize parallel workflow streams
@@ -2525,7 +2564,9 @@ spawn_feature_stream() {
     local task_description="$2"
 
     # Check worktree limit
-    local worktree_count=$(git -C "$TARGET_DIR" worktree list 2>/dev/null | wc -l)
+    # BUG-PAR-012: Worktree count subtracts 1 for main (git worktree list includes main)
+    local worktree_count_raw=$(git -C "$TARGET_DIR" worktree list 2>/dev/null | wc -l)
+    local worktree_count=$((worktree_count_raw > 0 ? worktree_count_raw - 1 : 0))
     if [ "$worktree_count" -ge "$MAX_WORKTREES" ]; then
         log_warn "Max worktrees reached ($MAX_WORKTREES). Queuing feature: $feature_name"
         return 1
@@ -2594,12 +2635,37 @@ run_parallel_orchestrator() {
 
     # Main orchestrator loop
     local running=true
-    trap 'running=false; cleanup_parallel_streams' INT TERM
+    # BUG-PAR-004: Orchestrator trap handles SIGTERM properly (cleanup + restore global trap + exit)
+    trap 'running=false; cleanup_parallel_streams; trap cleanup INT TERM; exit 0' TERM
+    trap 'running=false; cleanup_parallel_streams' INT
 
     while $running; do
         # Check for merge requests
         check_merge_queue
 
+        # BUG-PAR-014: Retry queued spawns when sessions free up
+        local active_count=0
+        for _qpid in "${WORKTREE_PIDS[@]}"; do
+            if kill -0 "$_qpid" 2>/dev/null; then
+                ((active_count++))
+            fi
+        done
+        if [ "$active_count" -lt "$MAX_PARALLEL_SESSIONS" ]; then
+            for queued_signal in "${TARGET_DIR:-.}"/.loki/signals/SPAWN_QUEUED_*; do
+                [ -f "$queued_signal" ] || continue
+                local queued_stream
+                queued_stream=$(basename "$queued_signal" | sed 's/SPAWN_QUEUED_//')
+                local queued_task=""
+                queued_task=$(python3 -c "import json; print(json.load(open('$queued_signal'))['task'])" 2>/dev/null) || \
+                    queued_task=$(jq -r '.task' "$queued_signal" 2>/dev/null) || true
+                if [ -n "$queued_task" ] && [ -n "${WORKTREE_PATHS[$queued_stream]:-}" ]; then
+                    rm -f "$queued_signal"
+                    spawn_worktree_session "$queued_stream" "$queued_task" && \
+                        log_info "Retried queued spawn: $queued_stream"
+                fi
+            done
+        fi
+
         # Check session health
         for stream in "${!WORKTREE_PIDS[@]}"; do
             local pid="${WORKTREE_PIDS[$stream]}"
@@ -2613,22 +2679,28 @@ run_parallel_orchestrator() {
         local state_file="$TARGET_DIR/.loki/state/parallel-streams.json"
         mkdir -p "$(dirname "$state_file")"
 
+        # BUG-PAR-007: Empty worktree map produces valid JSON
+        local worktree_json=""
+        if [ ${#WORKTREE_PATHS[@]} -gt 0 ]; then
+            worktree_json=$(for stream in "${!WORKTREE_PATHS[@]}"; do
+                local path="${WORKTREE_PATHS[$stream]}"
+                local pid="null"
+                if [ -n "${WORKTREE_PIDS[$stream]+x}" ]; then
+                    pid="${WORKTREE_PIDS[$stream]}"
+                fi
+                local status="stopped"
+                if [ "$pid" != "null" ] && kill -0 "$pid" 2>/dev/null; then
+                    status="running"
+                fi
+                echo "    \"$stream\": {\"path\": \"$path\", \"pid\": $pid, \"status\": \"$status\"},"
+            done | sed '$ s/,$//')
+        fi
+
         cat > "$state_file" << EOF
 {
   "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
   "worktrees": {
-$(for stream in "${!WORKTREE_PATHS[@]}"; do
-    local path="${WORKTREE_PATHS[$stream]}"
-    local pid="null"
-    if [ -n "${WORKTREE_PIDS[$stream]+x}" ]; then
-        pid="${WORKTREE_PIDS[$stream]}"
-    fi
-    local status="stopped"
-    if [ "$pid" != "null" ] && kill -0 "$pid" 2>/dev/null; then
-        status="running"
-    fi
-    echo "    \"$stream\": {\"path\": \"$path\", \"pid\": $pid, \"status\": \"$status\"},"
-done | sed '$ s/,$//')
+${worktree_json}
   },
   "active_sessions": ${#WORKTREE_PIDS[@]},
   "max_sessions": $MAX_PARALLEL_SESSIONS
@@ -3445,10 +3517,66 @@ track_iteration_start() {
             "provider=${PROVIDER_NAME:-claude}"
     fi
 
+    # Read next pending task for context (enrich iteration with PRD task details)
+    local next_task_context=""
+    if [[ -f ".loki/queue/pending.json" ]]; then
+        next_task_context=$(python3 -c "
+import json
+try:
+    with open('.loki/queue/pending.json') as f:
+        tasks = json.load(f)
+    if isinstance(tasks, dict):
+        tasks = tasks.get('tasks', [])
+    pending = [t for t in tasks if isinstance(t, dict) and t.get('status','pending') == 'pending']
+    if pending:
+        t = pending[0]
+        print(json.dumps({
+            'current_task': t.get('title',''),
+            'description': t.get('description',''),
+            'acceptance_criteria': t.get('acceptance_criteria', []),
+            'user_story': t.get('user_story', ''),
+            'source': t.get('source', ''),
+            'project': t.get('project', '')
+        }))
+except: pass
+" 2>/dev/null || true)
+    fi
+
     # Create task entry (escape PRD path for safe JSON embedding)
     local prd_escaped
     prd_escaped=$(printf '%s' "${prd:-Codebase Analysis}" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g')
-    local task_json=$(cat <<EOF
+
+    # Build enriched task JSON with pending task context
+    local task_json
+    if [[ -n "$next_task_context" ]]; then
+        task_json=$(python3 -c "
+import json, sys
+ctx = json.loads('''$next_task_context''')
+task = {
+    'id': 'iteration-$iteration',
+    'type': 'iteration',
+    'title': ctx.get('current_task') or 'Iteration $iteration',
+    'description': ctx.get('description') or 'PRD: ${prd_escaped}',
+    'status': 'in_progress',
+    'priority': 'medium',
+    'startedAt': '$(date -u +%Y-%m-%dT%H:%M:%SZ)',
+    'provider': '${PROVIDER_NAME:-claude}'
+}
+if ctx.get('acceptance_criteria'):
+    task['acceptance_criteria'] = ctx['acceptance_criteria']
+if ctx.get('user_story'):
+    task['user_story'] = ctx['user_story']
+if ctx.get('source'):
+    task['source'] = ctx['source']
+if ctx.get('project'):
+    task['project'] = ctx['project']
+print(json.dumps(task, indent=2))
+" 2>/dev/null)
+    fi
+
+    # Fallback to basic task JSON if enrichment failed
+    if [[ -z "$task_json" ]]; then
+        task_json=$(cat <<EOF
 {
   "id": "$task_id",
   "type": "iteration",
@@ -3461,6 +3589,7 @@ track_iteration_start() {
 }
 EOF
 )
+    fi
 
     # Add to in-progress queue
     # BUG-XC-003: Use flock for atomic queue modification
@@ -7834,11 +7963,12 @@ load_state() {
 
 # Load tasks from queue files for prompt injection
 # Supports both array format [...] and object format {"tasks": [...]}
+# Enhanced in v6.63.0 to include rich task details (description, acceptance criteria, user stories)
 load_queue_tasks() {
     local task_injection=""
 
-    # Helper Python script to extract and format tasks
-    # Handles both formats, truncates long actions, normalizes newlines
+    # Helper Python script to extract and format tasks with rich details
+    # Handles both formats, includes description, acceptance criteria, and user stories
     local extract_script='
 import json
 import sys
@@ -7856,23 +7986,45 @@ def extract_tasks(filepath, prefix):
             if not isinstance(task, dict):
                 continue
             task_id = task.get("id") or "unknown"
-            task_type = task.get("type") or "unknown"
-            payload = task.get("payload", {})
-
-            # Extract action from payload
-            if isinstance(payload, dict):
-                action = payload.get("action") or payload.get("goal") or ""
+            source = task.get("source", "")
+
+            # Rich PRD-sourced tasks (v6.63.0)
+            if source == "prd" or task_id.startswith("prd-"):
+                title = task.get("title", "Task")
+                lines = [f"{prefix}[{i+1}] {task_id}: {title}"]
+                desc = task.get("description", "")
+                if desc and desc != title:
+                    # First 300 chars of description, normalized
+                    desc_short = desc.replace("\n", " ").replace("\r", "")[:300]
+                    if len(desc) > 300:
+                        desc_short += "..."
+                    lines.append(f"  Description: {desc_short}")
+                criteria = task.get("acceptance_criteria", [])
+                if criteria:
+                    criteria_str = "; ".join(str(c) for c in criteria[:5])
+                    lines.append(f"  Acceptance: {criteria_str}")
+                story = task.get("user_story", "")
+                if story:
+                    lines.append(f"  User Story: {story}")
+                results.append("\n".join(lines))
             else:
-                action = str(payload) if payload else ""
-
-            # Normalize: remove newlines, truncate to 500 chars
-            action = str(action).replace("\n", " ").replace("\r", "")[:500]
-            if len(str(task.get("payload", {}).get("action", ""))) > 500:
-                action += "..."
-
-            results.append(f"{prefix}[{i+1}] id={task_id} type={task_type}: {action}")
-
-        return " ".join(results)
+                # Legacy format: extract action from payload
+                task_type = task.get("type") or "unknown"
+                payload = task.get("payload", {})
+                if isinstance(payload, dict):
+                    action = payload.get("action") or payload.get("goal") or ""
+                else:
+                    action = str(payload) if payload else ""
+                # Also check top-level title/description for non-payload tasks
+                if not action:
+                    action = task.get("title", task.get("description", ""))
+                # Normalize: remove newlines, truncate to 500 chars
+                action = str(action).replace("\n", " ").replace("\r", "")[:500]
+                if len(str(action)) > 500:
+                    action += "..."
+                results.append(f"{prefix}[{i+1}] id={task_id} type={task_type}: {action}")
+
+        return "\n".join(results)
     except:
         return ""
 
@@ -7882,11 +8034,11 @@ pending = extract_tasks(".loki/queue/pending.json", "PENDING")
 
 output = []
 if in_progress:
-    output.append(f"IN-PROGRESS TASKS (EXECUTE THESE): {in_progress}")
+    output.append(f"IN-PROGRESS TASKS (EXECUTE THESE):\n{in_progress}")
 if pending:
-    output.append(f"PENDING: {pending}")
+    output.append(f"PENDING:\n{pending}")
 
-print(" | ".join(output))
+print("\n---\n".join(output))
 '
 
     # First check in-progress tasks (highest priority)
@@ -8628,6 +8780,212 @@ MIROFISH_QUEUE_EOF
     log_info "MiroFish queue population complete"
 }
 
+# Populate task queue from plain PRD markdown (if no adapter populated tasks)
+# Extracts features/requirements from markdown structure into rich task entries
+populate_prd_queue() {
+    local prd_file="${1:-}"
+    if [[ -z "$prd_file" ]] || [[ ! -f "$prd_file" ]]; then
+        return 0
+    fi
+    # Skip if already populated
+    if [[ -f ".loki/queue/.prd-populated" ]]; then
+        return 0
+    fi
+    # Skip if OpenSpec, BMAD, or MiroFish already populated tasks
+    if [[ -f ".loki/queue/.openspec-populated" ]] || [[ -f ".loki/queue/.bmad-populated" ]] || [[ -f ".loki/queue/.mirofish-populated" ]]; then
+        log_info "Task queue already populated by adapter, skipping PRD parsing"
+        return 0
+    fi
+
+    log_step "Parsing PRD into structured tasks..."
+    mkdir -p ".loki/queue"
+
+    LOKI_PRD_FILE="$prd_file" python3 << 'PRD_PARSE_EOF'
+import json, re, os, sys
+
+prd_path = os.environ.get("LOKI_PRD_FILE", "")
+if not prd_path or not os.path.isfile(prd_path):
+    sys.exit(0)
+
+with open(prd_path, "r", errors="replace") as f:
+    content = f.read()
+
+# Parse PRD structure
+sections = {}
+current_section = "Overview"
+current_content = []
+
+for line in content.split("\n"):
+    heading_match = re.match(r'^#{1,3}\s+(.+)', line)
+    if heading_match:
+        if current_content:
+            sections[current_section] = "\n".join(current_content).strip()
+        current_section = heading_match.group(1).strip()
+        current_content = []
+    else:
+        current_content.append(line)
+if current_content:
+    sections[current_section] = "\n".join(current_content).strip()
+
+# Extract project name from first H1
+project_name = "Project"
+for line in content.split("\n"):
+    m = re.match(r'^#\s+(.+)', line)
+    if m:
+        project_name = m.group(1).strip()
+        break
+
+# Find feature/requirement sections
+feature_keywords = [
+    "features", "requirements", "key features", "core features",
+    "functional requirements", "user stories", "deliverables",
+    "scope", "functionality", "capabilities", "modules"
+]
+
+# Extract features from bullet points in feature sections
+features = []
+for section_name, section_content in sections.items():
+    is_feature_section = any(kw in section_name.lower() for kw in feature_keywords)
+    if is_feature_section:
+        # Extract numbered items or bullet points
+        for line in section_content.split("\n"):
+            line = line.strip()
+            # Match: "1. Feature name" or "- Feature name" or "* Feature name"
+            m = re.match(r'^(?:\d+[\.\)]\s*|\-\s+|\*\s+)(.+)', line)
+            if m:
+                feature_text = m.group(1).strip()
+                if len(feature_text) > 10:  # Skip very short lines
+                    features.append({
+                        "title": feature_text,
+                        "section": section_name,
+                    })
+
+# If no bullet features found, extract from ## headings that look like features
+if not features:
+    skip_sections = {"overview", "introduction", "summary", "target audience",
+                     "tech stack", "technology", "deployment", "timeline",
+                     "out of scope", "non-functional", "appendix", "references",
+                     "problem statement", "value proposition", "background"}
+    for section_name, section_content in sections.items():
+        if section_name.lower() not in skip_sections and len(section_content) > 20:
+            features.append({
+                "title": section_name,
+                "section": "Requirements",
+            })
+
+if not features:
+    print("No features extracted from PRD", file=sys.stderr)
+    sys.exit(0)
+
+# Build acceptance criteria from section content
+def extract_acceptance_criteria(section_name, sections):
+    """Extract testable criteria from section content."""
+    criteria = []
+    content = sections.get(section_name, "")
+    for line in content.split("\n"):
+        line = line.strip()
+        if line.startswith(("- ", "* ", "  - ", "  * ")):
+            text = re.sub(r'^[\-\*]\s+', '', line).strip()
+            if len(text) > 5:
+                criteria.append(text)
+    # Also check for acceptance criteria section
+    for key in ["acceptance criteria", "success criteria", "definition of done"]:
+        for sname, scontent in sections.items():
+            if key in sname.lower():
+                for cline in scontent.split("\n"):
+                    cline = cline.strip()
+                    m = re.match(r'^(?:\d+[\.\)]\s*|\-\s+|\*\s+|\[.\]\s*)(.+)', cline)
+                    if m:
+                        criteria.append(m.group(1).strip())
+    return criteria[:10]  # Cap at 10
+
+# Determine priority based on position (earlier = higher)
+def get_priority(index, total):
+    if total <= 3:
+        return "high"
+    third = total / 3
+    if index < third:
+        return "high"
+    elif index < 2 * third:
+        return "medium"
+    return "low"
+
+# Build task queue entries
+pending_path = ".loki/queue/pending.json"
+existing = []
+if os.path.exists(pending_path):
+    try:
+        with open(pending_path, "r") as f:
+            data = json.load(f)
+            if isinstance(data, list):
+                existing = data
+            elif isinstance(data, dict) and "tasks" in data:
+                existing = data["tasks"]
+    except (json.JSONDecodeError, FileNotFoundError):
+        existing = []
+
+existing_ids = {t.get("id") for t in existing if isinstance(t, dict)}
+added = 0
+
+for i, feat in enumerate(features):
+    task_id = f"prd-{i+1:03d}"
+    if task_id in existing_ids:
+        continue
+
+    criteria = extract_acceptance_criteria(feat["section"], sections)
+
+    # Build a rich description
+    section_content = sections.get(feat["section"], "")
+    desc_parts = [feat["title"]]
+    if section_content and len(section_content) > len(feat["title"]):
+        # Include relevant context (first 500 chars of section)
+        desc_parts.append(section_content[:500])
+
+    task = {
+        "id": task_id,
+        "title": feat["title"],
+        "description": "\n".join(desc_parts),
+        "priority": get_priority(i, len(features)),
+        "status": "pending",
+        "source": "prd",
+        "project": project_name,
+    }
+
+    if criteria:
+        task["acceptance_criteria"] = criteria
+
+    # Add user story format
+    # Try to extract target audience for user story
+    audience = "a user"
+    for key in ["target audience", "users", "user personas", "audience"]:
+        for sname in sections:
+            if key in sname.lower():
+                # Extract first line
+                first_line = sections[sname].split("\n")[0].strip()
+                if first_line:
+                    audience = first_line[:100]
+                    break
+
+    task["user_story"] = f"As {audience}, I want to {feat['title'].lower().rstrip('.')}, so that the product delivers its core value."
+
+    existing.append(task)
+    added += 1
+
+with open(pending_path, "w") as f:
+    json.dump(existing, f, indent=2)
+
+print(f"Extracted {added} tasks from PRD ({len(features)} features found)", file=sys.stderr)
+PRD_PARSE_EOF
+
+    if [[ $? -ne 0 ]]; then
+        log_warn "Failed to parse PRD into tasks"
+        return 0
+    fi
+
+    touch ".loki/queue/.prd-populated"
+    log_info "PRD task parsing complete"
+}
+
 #===============================================================================
 # Main Autonomous Loop
 #===============================================================================
@@ -8740,6 +9098,9 @@ run_autonomous() {
     # Populate task queue from MiroFish advisory (if present, runs once)
     populate_mirofish_queue
 
+    # Populate task queue from PRD (if no adapters already populated, runs once)
+    populate_prd_queue "$prd_path"
+
     # Check max iterations before starting
     if check_max_iterations; then
         log_error "Max iterations already reached. Reset with: rm .loki/autonomy-state.json"