loki-mode 6.62.1 → 6.63.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.62.1
+# Loki Mode v6.63.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.62.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.63.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.62.1
+6.63.0

package/autonomy/run.sh

@@ -3517,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",
@@ -3533,6 +3589,7 @@ track_iteration_start() {
 }
 EOF
 )
+    fi
 
     # Add to in-progress queue
     # BUG-XC-003: Use flock for atomic queue modification
@@ -7906,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
@@ -7928,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 ""
 
@@ -7954,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)
@@ -8700,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
 #===============================================================================
@@ -8812,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"

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.62.1"
+__version__ = "6.63.0"
 
 # Expose the control app for easy import
 try:

package/dashboard/server.py

@@ -1085,7 +1085,7 @@ async def list_tasks(
                                 # Skip if already in all_tasks
                                 if any(t["id"] == tid for t in all_tasks):
                                     continue
-                                all_tasks.append({
+                                task_entry = {
                                     "id": tid,
                                     "title": item.get("title", item.get("action", "Task")),
                                     "description": item.get("description", ""),
@@ -1093,7 +1093,16 @@ async def list_tasks(
                                     "priority": item.get("priority", "medium"),
                                     "type": item.get("type", "task"),
                                     "position": i,
-                                })
+                                }
+                                if item.get("acceptance_criteria"):
+                                    task_entry["acceptance_criteria"] = item["acceptance_criteria"]
+                                if item.get("user_story"):
+                                    task_entry["user_story"] = item["user_story"]
+                                if item.get("project"):
+                                    task_entry["project"] = item["project"]
+                                if item.get("source"):
+                                    task_entry["source"] = item["source"]
+                                all_tasks.append(task_entry)
                 except (json.JSONDecodeError, KeyError):
                     pass
 

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.62.1
+**Version:** v6.63.0
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.62.1'
+__version__ = '6.63.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.62.1",
+  "version": "6.63.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",

package/web-app/server.py

@@ -627,25 +627,32 @@ class DevServerManager:
                     subprocess.run(["docker", "--version"], capture_output=True, timeout=5)
                 except (FileNotFoundError, subprocess.TimeoutExpired):
                     break  # Docker not installed -- fall through to other detection
-                # Parse compose file to detect exposed port
+                # Parse compose file to detect exposed port and enumerate services
                 port = 3000  # default
+                services_info: list = []
                 try:
                     import yaml
                     with open(root / compose_file) as f:
                         compose = yaml.safe_load(f)
                     if compose and "services" in compose:
-                        for svc in compose["services"].values():
-                            ports = svc.get("ports", [])
-                            for p in ports:
+                        for svc_name, svc in compose["services"].items():
+                            svc_ports: list = []
+                            for p in svc.get("ports", []):
                                 p_str = str(p)
                                 if ":" in p_str:
-                                    # Handle IP:host:container (e.g. "127.0.0.1:8080:80")
-                                    # and host:container (e.g. "8080:80")
                                     parts = p_str.split(":")
-                                    host_port = parts[-2]  # second-to-last is always host port
-                                    port = int(host_port)
-                                    break
-                            if port != 3000:
+                                    host_port = int(parts[-2])
+                                    svc_ports.append(host_port)
+                            services_info.append({
+                                "name": svc_name,
+                                "ports": svc_ports,
+                                "image": svc.get("image"),
+                                "has_build": "build" in svc,
+                            })
+                        # Use the first exposed host port as the primary port
+                        for svc_entry in services_info:
+                            if svc_entry["ports"]:
+                                port = svc_entry["ports"][0]
                                 break
                 except ImportError:
                     # yaml not available -- fall back to regex parsing
@@ -654,11 +661,149 @@ class DevServerManager:
                         port_match = re.search(r'"?(\d+):(\d+)"?', content)
                         if port_match:
                             port = int(port_match.group(1))
+                        # Extract service names via regex
+                        for m in re.finditer(r'^  (\w[\w-]*):\s*$', content, re.MULTILINE):
+                            services_info.append({"name": m.group(1), "ports": []})
                     except Exception:
                         pass
                 except Exception:
                     pass
-                return {"command": f"docker compose -f {compose_file} up --build", "expected_port": port, "framework": "docker"}
+                result_dict: dict = {
+                    "command": f"docker compose -f {compose_file} up --build",
+                    "expected_port": port,
+                    "framework": "docker",
+                }
+                if services_info:
+                    result_dict["services"] = services_info
+                return result_dict
+
+        # -- Full-stack project detection (frontend + backend in subdirectories) --
+        frontend_dir_names = ["frontend", "client", "web", "app", "ui", "web-app", "webapp"]
+        backend_dir_names = ["backend", "server", "api", "service"]
+
+        frontend_dir: Optional[Path] = None
+        backend_dir: Optional[Path] = None
+
+        for d in frontend_dir_names:
+            candidate = root / d
+            if candidate.is_dir():
+                # Verify it is actually a frontend (has package.json or index.html)
+                if (candidate / "package.json").exists() or (candidate / "index.html").exists():
+                    frontend_dir = candidate
+                    break
+
+        for d in backend_dir_names:
+            candidate = root / d
+            if candidate.is_dir():
+                has_py = any(candidate.glob("*.py"))
+                has_pkg = (candidate / "package.json").exists()
+                has_go = (candidate / "go.mod").exists()
+                has_requirements = (candidate / "requirements.txt").exists()
+                has_cargo = (candidate / "Cargo.toml").exists()
+                if has_py or has_pkg or has_go or has_requirements or has_cargo:
+                    backend_dir = candidate
+                    break
+
+        if frontend_dir and backend_dir:
+            # Detect frontend framework and command
+            fe_cmd = "npm run dev"
+            fe_port = 3000
+            fe_framework = "node"
+            fe_pkg = frontend_dir / "package.json"
+            if fe_pkg.exists():
+                try:
+                    pkg = json.loads(fe_pkg.read_text(errors="replace"))
+                    fe_scripts = pkg.get("scripts", {})
+                    fe_deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+                    if "next" in fe_deps:
+                        fe_framework = "next"
+                        fe_port = 3000
+                        fe_cmd = "npm run dev"
+                    elif "vite" in fe_deps:
+                        fe_framework = "vite"
+                        fe_port = 5173
+                        fe_cmd = "npm run dev"
+                    elif "dev" in fe_scripts:
+                        fe_cmd = "npm run dev"
+                    elif "start" in fe_scripts:
+                        fe_cmd = "npm start"
+                except Exception:
+                    pass
+            elif (frontend_dir / "index.html").exists():
+                fe_framework = "static"
+                fe_cmd = "python3 -m http.server 3000"
+                fe_port = 3000
+
+            # Detect backend framework and command
+            be_cmd: Optional[str] = None
+            be_port = 8000
+            be_framework = "unknown"
+
+            if (backend_dir / "manage.py").exists():
+                be_cmd = "python manage.py runserver"
+                be_port = 8000
+                be_framework = "django"
+            else:
+                for py_entry in ("app.py", "main.py", "server.py"):
+                    py_file = backend_dir / py_entry
+                    if py_file.exists():
+                        try:
+                            src = py_file.read_text(errors="replace")[:4096]
+                            if "fastapi" in src.lower() or "FastAPI" in src:
+                                module = py_entry[:-3]
+                                be_cmd = f"uvicorn {module}:app --reload --port 8000"
+                                be_port = 8000
+                                be_framework = "fastapi"
+                                break
+                            if "flask" in src.lower() or "Flask" in src:
+                                be_cmd = "flask run --port 5000"
+                                be_port = 5000
+                                be_framework = "flask"
+                                break
+                        except OSError:
+                            pass
+                if be_cmd is None and (backend_dir / "package.json").exists():
+                    try:
+                        be_pkg = json.loads((backend_dir / "package.json").read_text(errors="replace"))
+                        be_scripts = be_pkg.get("scripts", {})
+                        be_deps = {**be_pkg.get("dependencies", {}), **be_pkg.get("devDependencies", {})}
+                        if "express" in be_deps:
+                            be_framework = "express"
+                        else:
+                            be_framework = "node"
+                        be_port = 3001
+                        if "dev" in be_scripts:
+                            be_cmd = "npm run dev"
+                        elif "start" in be_scripts:
+                            be_cmd = "npm start"
+                    except Exception:
+                        pass
+                if be_cmd is None and (backend_dir / "go.mod").exists():
+                    be_cmd = "go run ."
+                    be_port = 8080
+                    be_framework = "go"
+                if be_cmd is None and (backend_dir / "requirements.txt").exists():
+                    # Generic Python backend with requirements.txt
+                    for py_entry in ("app.py", "main.py", "server.py", "run.py"):
+                        if (backend_dir / py_entry).exists():
+                            be_cmd = f"python {py_entry}"
+                            be_port = 8000
+                            be_framework = "python"
+                            break
+
+            if be_cmd:
+                return {
+                    "framework": "full-stack",
+                    "command": f"cd {backend_dir.name} && {be_cmd}",
+                    "frontend_command": f"cd {frontend_dir.name} && {fe_cmd}",
+                    "expected_port": fe_port,
+                    "backend_port": be_port,
+                    "multi_service": True,
+                    "frontend_dir": str(frontend_dir),
+                    "backend_dir": str(backend_dir),
+                    "frontend_framework": fe_framework,
+                    "backend_framework": be_framework,
+                }
 
         pkg_json = root / "package.json"
         if pkg_json.exists():
@@ -767,6 +912,36 @@ class DevServerManager:
                     return port
         return None
 
+    def _install_pip_deps(self, project_path: Path, build_env: dict) -> None:
+        """Install pip dependencies into a project venv (creates one if needed)."""
+        if not (project_path / "requirements.txt").exists():
+            return
+        venv_dir = None
+        for venv_name in ("venv", ".venv", "env"):
+            candidate = project_path / venv_name
+            if candidate.is_dir() and (candidate / "bin" / "pip").exists():
+                venv_dir = candidate
+                break
+        if venv_dir is None:
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "venv", str(project_path / "venv")],
+                    capture_output=True, timeout=60,
+                )
+                venv_dir = project_path / "venv"
+            except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
+                logger.warning("venv creation failed: %s", exc)
+        pip_executable = str(venv_dir / "bin" / "pip") if venv_dir else "pip"
+        try:
+            subprocess.run(
+                [pip_executable, "install", "-r", "requirements.txt"],
+                cwd=str(project_path),
+                capture_output=True,
+                timeout=120,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
+            logger.warning("pip install failed: %s", exc)
+
     async def start(self, session_id: str, project_dir: str, command: Optional[str] = None) -> dict:
         """Start dev server. Auto-detect command if not provided."""
         if session_id in self.servers:
@@ -792,15 +967,177 @@ class DevServerManager:
         cmd_str = command or (detected["command"] if detected else "")
         expected_port = detected["expected_port"] if detected else 3000
         framework = detected["framework"] if detected else "unknown"
+        is_multi_service = detected.get("multi_service", False) if detected else False
+
+        build_env = {**os.environ}
+        build_env.update(_load_secrets())
+
+        # -- Multi-service full-stack startup --
+        if is_multi_service and not command:
+            be_dir = detected.get("backend_dir", actual_dir)
+            fe_dir = detected.get("frontend_dir", actual_dir)
+            be_cmd_str = detected.get("command", "")
+            fe_cmd_str = detected.get("frontend_command", "")
+            be_port = detected.get("backend_port", 8000)
+            fe_port = detected.get("expected_port", 3000)
+
+            # Install deps in both directories
+            for svc_dir_str in (be_dir, fe_dir):
+                svc_path = Path(svc_dir_str)
+                if (svc_path / "package.json").exists() and not (svc_path / "node_modules").exists():
+                    try:
+                        subprocess.run(["npm", "install"], cwd=svc_dir_str, capture_output=True, timeout=120, env=build_env)
+                    except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
+                        logger.warning("npm install failed in %s: %s", svc_dir_str, exc)
+                if (svc_path / "requirements.txt").exists():
+                    self._install_pip_deps(svc_path, build_env)
+
+            popen_kwargs = (
+                {"start_new_session": True} if sys.platform != "win32"
+                else {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+            )
+
+            # Start backend process (uses shell=True because command contains 'cd ...')
+            try:
+                be_proc = subprocess.Popen(
+                    be_cmd_str, shell=True,
+                    stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
+                    text=True, cwd=actual_dir, env=build_env, **popen_kwargs,
+                )
+            except Exception as e:
+                return {"status": "error", "message": f"Failed to start backend: {e}"}
+            _track_child_pid(be_proc.pid)
+
+            # Start frontend process
+            try:
+                fe_proc = subprocess.Popen(
+                    fe_cmd_str, shell=True,
+                    stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
+                    text=True, cwd=actual_dir, env=build_env, **popen_kwargs,
+                )
+            except Exception as e:
+                # Kill backend if frontend fails to start
+                try:
+                    be_proc.terminate()
+                except (ProcessLookupError, PermissionError, OSError):
+                    pass
+                _untrack_child_pid(be_proc.pid)
+                return {"status": "error", "message": f"Failed to start frontend: {e}"}
+            _track_child_pid(fe_proc.pid)
+
+            server_info: dict = {
+                "process": fe_proc,  # Primary process is frontend (user-facing)
+                "backend_process": be_proc,
+                "port": None,
+                "expected_port": fe_port,
+                "backend_port": be_port,
+                "command": fe_cmd_str,
+                "original_command": cmd_str,
+                "framework": framework,
+                "status": "starting",
+                "pid": fe_proc.pid,
+                "backend_pid": be_proc.pid,
+                "project_dir": project_dir,
+                "output_lines": [],
+                "backend_output_lines": [],
+                "multi_service": True,
+                "frontend_framework": detected.get("frontend_framework", "unknown"),
+                "backend_framework": detected.get("backend_framework", "unknown"),
+                "frontend_dir": fe_dir,
+                "backend_dir": be_dir,
+                "use_portless": False,
+                "portless_app_name": None,
+            }
+            self.servers[session_id] = server_info
+
+            asyncio.create_task(self._monitor_output(session_id))
+            asyncio.create_task(self._monitor_backend_output(session_id))
+
+            # Wait for either frontend or backend port (up to 30s)
+            for _ in range(60):
+                await asyncio.sleep(0.5)
+                info = self.servers.get(session_id)
+                if not info:
+                    return {"status": "error", "message": "Server entry disappeared"}
+                if info["status"] == "error":
+                    return {
+                        "status": "error",
+                        "message": "Dev server crashed",
+                        "output": info["output_lines"][-10:] if info["output_lines"] else [],
+                    }
+                if info["port"] is not None:
+                    health_ok = await self._health_check(info["port"])
+                    if health_ok:
+                        info["status"] = "running"
+                        services = [
+                            {
+                                "name": "frontend",
+                                "framework": info.get("frontend_framework", "unknown"),
+                                "port": fe_port,
+                                "status": "running",
+                            },
+                            {
+                                "name": "backend",
+                                "framework": info.get("backend_framework", "unknown"),
+                                "port": be_port,
+                                "status": "running" if be_proc.poll() is None else "error",
+                            },
+                        ]
+                        return {
+                            "status": "running",
+                            "port": info["port"],
+                            "command": fe_cmd_str,
+                            "pid": fe_proc.pid,
+                            "url": f"/proxy/{session_id}/",
+                            "multi_service": True,
+                            "framework": "full-stack",
+                            "services": services,
+                        }
+
+            # Timeout -- report whatever state we have
+            if fe_proc.poll() is not None and be_proc.poll() is not None:
+                server_info["status"] = "error"
+                return {
+                    "status": "error",
+                    "message": "Both frontend and backend exited before port was detected",
+                    "output": server_info["output_lines"][-10:],
+                }
+
+            # Fallback to expected port
+            health_ok = await self._health_check(fe_port)
+            if health_ok:
+                server_info["port"] = fe_port
+                server_info["status"] = "running"
+                return {
+                    "status": "running",
+                    "port": fe_port,
+                    "command": fe_cmd_str,
+                    "pid": fe_proc.pid,
+                    "url": f"/proxy/{session_id}/",
+                    "multi_service": True,
+                    "framework": "full-stack",
+                }
+
+            server_info["status"] = "starting"
+            server_info["port"] = fe_port
+            return {
+                "status": "starting",
+                "message": "Server started but port not yet confirmed",
+                "port": fe_port,
+                "command": fe_cmd_str,
+                "pid": fe_proc.pid,
+                "url": f"/proxy/{session_id}/",
+                "multi_service": True,
+                "framework": "full-stack",
+            }
+
+        # -- Single-service startup (original path) --
 
         # Auto-install dependencies before starting the dev server
         actual_path = Path(actual_dir)
         needs_npm = (actual_path / "package.json").exists() and not (actual_path / "node_modules").exists()
         needs_pip = (actual_path / "requirements.txt").exists() and not (actual_path / "venv").exists()
 
-        build_env = {**os.environ}
-        build_env.update(_load_secrets())
-
         if needs_npm:
             try:
                 subprocess.run(
@@ -814,34 +1151,7 @@ class DevServerManager:
                 logger.warning("npm install failed: %s", exc)
 
         if needs_pip:
-            # Use project venv if available, otherwise create one to avoid
-            # installing into the server's own Python environment.
-            venv_dir = None
-            for venv_name in ("venv", ".venv", "env"):
-                candidate = actual_path / venv_name
-                if candidate.is_dir() and (candidate / "bin" / "pip").exists():
-                    venv_dir = candidate
-                    break
-            if venv_dir is None:
-                # Create a virtual environment for the project
-                try:
-                    subprocess.run(
-                        [sys.executable, "-m", "venv", str(actual_path / "venv")],
-                        capture_output=True, timeout=60,
-                    )
-                    venv_dir = actual_path / "venv"
-                except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
-                    logger.warning("venv creation failed: %s", exc)
-            pip_executable = str(venv_dir / "bin" / "pip") if venv_dir else "pip"
-            try:
-                subprocess.run(
-                    [pip_executable, "install", "-r", "requirements.txt"],
-                    cwd=actual_dir,
-                    capture_output=True,
-                    timeout=120,
-                )
-            except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
-                logger.warning("pip install failed: %s", exc)
+            self._install_pip_deps(actual_path, build_env)
 
         # Check if portless is available and proxy is running
         use_portless = False
@@ -875,7 +1185,7 @@ class DevServerManager:
         _track_child_pid(proc.pid)
 
         effective_cmd = " ".join(cmd_parts)
-        server_info: dict = {
+        server_info = {
             "process": proc,
             "port": None,
             "expected_port": expected_port,
@@ -1016,6 +1326,39 @@ class DevServerManager:
                     except Exception:
                         logger.warning("Failed to schedule auto-fix for session %s", session_id, exc_info=True)
 
+    async def _monitor_backend_output(self, session_id: str) -> None:
+        """Background task: read backend dev server stdout for multi-service setups."""
+        info = self.servers.get(session_id)
+        if not info or not info.get("multi_service"):
+            return
+        be_proc = info.get("backend_process")
+        if not be_proc or not be_proc.stdout:
+            return
+        loop = asyncio.get_running_loop()
+        try:
+            while be_proc.poll() is None:
+                line = await loop.run_in_executor(None, be_proc.stdout.readline)
+                if not line:
+                    break
+                text = line.rstrip("\n")
+                be_lines = info.get("backend_output_lines", [])
+                be_lines.append(text)
+                if len(be_lines) > 200:
+                    be_lines = be_lines[-200:]
+                info["backend_output_lines"] = be_lines
+                # Also detect backend port from output
+                detected_port = self._parse_port(text)
+                if detected_port:
+                    info["backend_port"] = detected_port
+        except Exception:
+            logger.error("Backend monitor failed for session %s", session_id, exc_info=True)
+        finally:
+            if be_proc.poll() is not None and info.get("status") in ("starting", "running"):
+                # Only mark error if frontend is also dead
+                fe_proc = info.get("process")
+                if fe_proc and fe_proc.poll() is not None:
+                    info["status"] = "error"
+
     async def _auto_fix(self, session_id: str, error_context: str) -> None:
         """Auto-fix a crashed dev server by invoking loki quick with the error."""
         info = self.servers.get(session_id)
@@ -1169,6 +1512,34 @@ class DevServerManager:
                         pass
 
         _untrack_child_pid(proc.pid)
+
+        # For multi-service setups, also kill the backend process
+        be_proc = info.get("backend_process")
+        if be_proc:
+            if be_proc.poll() is None:
+                if sys.platform != "win32":
+                    try:
+                        pgid = os.getpgid(be_proc.pid)
+                        os.killpg(pgid, signal.SIGTERM)
+                    except (ProcessLookupError, PermissionError, OSError):
+                        try:
+                            be_proc.terminate()
+                        except (ProcessLookupError, PermissionError, OSError):
+                            pass
+                else:
+                    try:
+                        be_proc.terminate()
+                    except (ProcessLookupError, PermissionError, OSError):
+                        pass
+                try:
+                    be_proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    try:
+                        be_proc.kill()
+                    except (ProcessLookupError, PermissionError, OSError):
+                        pass
+            _untrack_child_pid(be_proc.pid)
+
         return {"stopped": True, "message": "Dev server stopped"}
 
     async def status(self, session_id: str) -> dict:
@@ -1203,6 +1574,29 @@ class DevServerManager:
             "auto_fix_status": info.get("auto_fix_status"),
             "auto_fix_attempts": info.get("auto_fix_attempts", 0),
         }
+
+        # Multi-service status reporting
+        if info.get("multi_service"):
+            be_proc = info.get("backend_process")
+            be_alive = be_proc.poll() is None if be_proc else False
+            result["multi_service"] = True
+            result["framework"] = "full-stack"
+            result["services"] = [
+                {
+                    "name": "frontend",
+                    "framework": info.get("frontend_framework", "unknown"),
+                    "port": info.get("expected_port"),
+                    "status": "running" if alive else "error",
+                },
+                {
+                    "name": "backend",
+                    "framework": info.get("backend_framework", "unknown"),
+                    "port": info.get("backend_port"),
+                    "status": "running" if be_alive else "error",
+                },
+            ]
+            result["backend_output"] = info.get("backend_output_lines", [])[-20:]
+
         if info.get("use_portless") and info.get("portless_app_name"):
             app_name = info["portless_app_name"]
             result["portless_url"] = f"http://{app_name}.localhost:1355/"