@grifhinz/logics-manager 2.5.2 → 2.7.0

package/logics_manager/viewer.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 import mimetypes
 import os
@@ -20,6 +21,7 @@ from typing import Any
 from urllib.parse import parse_qs, quote, unquote, urlencode, urlparse
 
 from .audit import audit_payload
+from .bootstrap import bootstrap_payload
 from .config import find_repo_root
 from .lint import lint_payload
 from .update_check import get_update_info
@@ -342,18 +344,28 @@ def viewer_data_payload(
     selected_id: str | None = None,
     *,
     auto_refresh_interval_seconds: int = 15,
+    projects: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
+    capabilities = viewer_project_capabilities(repo_root)
+    active_root = repo_root.resolve()
+    has_logics = capabilities["logics"]["available"] is True
     return {
-        "root": str(repo_root.resolve()),
-        "repoName": repo_root.resolve().name,
+        "root": str(active_root),
+        "repoName": active_root.name,
+        "repository": {
+            "root": str(active_root),
+            "githubUrl": github_repo_url(repo_root),
+        },
+        "capabilities": capabilities,
+        "projects": projects if projects is not None else viewer_project_registry(repo_root),
         "autoRefreshIntervalSeconds": auto_refresh_interval_seconds,
         "items": collect_viewer_items(repo_root),
         "updateInfo": get_update_info(_current_version()).to_payload(),
         "selectedId": selected_id,
         "changedPaths": [],
         "canResetProjectRoot": False,
-        "canBootstrapLogics": False,
-        "bootstrapLogicsTitle": "Local viewer is read-only. Use the CLI to bootstrap Logics.",
+        "canBootstrapLogics": not has_logics,
+        "bootstrapLogicsTitle": "Bootstrap Logics in this project." if not has_logics else "Logics is already bootstrapped.",
         "canLaunchCodex": False,
         "canLaunchClaude": False,
         "canRepairLogicsKit": False,
@@ -362,6 +374,155 @@ def viewer_data_payload(
     }
 
 
+def _viewer_project_id(repo_root: Path) -> str:
+    normalized = str(repo_root.resolve())
+    return hashlib.sha1(normalized.encode("utf-8")).hexdigest()[:12]
+
+
+def _looks_like_viewer_project(path: Path) -> bool:
+    if not path.is_dir():
+        return False
+    return any((path / marker).exists() for marker in ("logics", ".git", "package.json", "pyproject.toml", "logics.yaml"))
+
+
+def discover_viewer_project_roots(repo_root: Path, *, max_projects: int = 40) -> list[Path]:
+    active = repo_root.resolve()
+    candidates: list[Path] = [active]
+    parent = active.parent
+    try:
+        siblings = sorted(parent.iterdir(), key=lambda path: path.name.lower())
+    except OSError:
+        siblings = []
+    for sibling in siblings:
+        try:
+            resolved = sibling.resolve()
+        except OSError:
+            continue
+        if resolved == active or not _looks_like_viewer_project(resolved):
+            continue
+        candidates.append(resolved)
+        if len(candidates) >= max_projects:
+            break
+
+    unique: dict[str, Path] = {}
+    for candidate in candidates:
+        unique[str(candidate)] = candidate
+    return list(unique.values())
+
+
+def viewer_project_entry(repo_root: Path, *, active_root: Path | None = None) -> dict[str, Any]:
+    root = repo_root.resolve()
+    active = active_root.resolve() if active_root else root
+    has_logics = (root / "logics").is_dir()
+    available = root.is_dir()
+    return {
+        "id": _viewer_project_id(root),
+        "name": root.name,
+        "root": str(root),
+        "active": root == active,
+        "available": available,
+        "hasLogics": has_logics,
+        "message": "Logics corpus found." if has_logics else "No Logics corpus found.",
+    }
+
+
+def viewer_project_registry(repo_root: Path, *, project_roots: list[Path] | None = None) -> list[dict[str, Any]]:
+    active = repo_root.resolve()
+    roots = project_roots if project_roots is not None else discover_viewer_project_roots(active)
+    return [viewer_project_entry(root, active_root=active) for root in roots]
+
+
+def _viewer_capability(state: str, *, available: bool, message: str, detail: dict[str, Any] | None = None) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "state": state,
+        "available": available,
+        "message": message,
+    }
+    if detail:
+        payload["detail"] = detail
+    return payload
+
+
+def _git_is_repository(repo_root: Path, *, runner: Any | None = None) -> bool | None:
+    try:
+        result = _run_read_only_git(repo_root, ["rev-parse", "--is-inside-work-tree"], runner=runner)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return False
+    return result.stdout.strip().lower() == "true"
+
+
+def viewer_project_capabilities(
+    repo_root: Path,
+    *,
+    git_runner: Any | None = None,
+    which: Any | None = None,
+) -> dict[str, Any]:
+    which_command = which or shutil.which
+    logics_dir = repo_root / "logics"
+    has_logics = logics_dir.is_dir()
+    git_path = which_command("git")
+    cdx_path = which_command("cdx")
+
+    if has_logics:
+        logics = _viewer_capability("ready", available=True, message="Logics corpus found.")
+    else:
+        logics = _viewer_capability("missing", available=False, message="No Logics corpus found.")
+
+    if not git_path:
+        git = _viewer_capability("unavailable", available=False, message="Git executable is not available.")
+        github_url = ""
+        has_workflows = False
+    else:
+        is_repo = _git_is_repository(repo_root, runner=git_runner)
+        if is_repo is True:
+            git = _viewer_capability("ready", available=True, message="Git repository detected.")
+            github_url = github_repo_url(repo_root, runner=git_runner, which=which_command)
+            has_workflows = _has_github_actions_workflows(repo_root)
+        elif is_repo is False:
+            git = _viewer_capability("missing", available=False, message="Project is not a Git repository.")
+            github_url = ""
+            has_workflows = False
+        else:
+            git = _viewer_capability("error", available=False, message="Unable to inspect Git repository state.")
+            github_url = ""
+            has_workflows = False
+
+    if not github_url:
+        ci = _viewer_capability("hidden", available=False, message="No GitHub remote detected for this project.")
+    elif not has_workflows:
+        ci = _viewer_capability("hidden", available=False, message="No GitHub Actions workflows detected for this project.")
+    elif not which_command("gh"):
+        ci = _viewer_capability("unavailable", available=False, message="GitHub CLI is not available.")
+    else:
+        ci = _viewer_capability(
+            "ready",
+            available=True,
+            message="GitHub Actions can be inspected.",
+            detail={"githubUrl": github_url},
+        )
+
+    if cdx_path:
+        cdx = _viewer_capability("ready", available=True, message="CDX executable detected.")
+        cdx_runs = _viewer_capability(
+            "unsupported",
+            available=False,
+            message="CDX assistant run registry is not available yet.",
+        )
+    else:
+        cdx = _viewer_capability("missing", available=False, message="CDX executable is not available.")
+        cdx_runs = _viewer_capability("missing", available=False, message="CDX is required before assistant runs can be tracked.")
+
+    return {
+        "logics": logics,
+        "git": git,
+        "ci": ci,
+        "cdx": cdx,
+        "cdxRuns": cdx_runs,
+    }
+
+
 def read_doc_payload(repo_root: Path, rel_path: str) -> dict[str, Any]:
     normalized, absolute = _resolve_repo_doc_path(repo_root, rel_path)
     return {
@@ -392,6 +553,17 @@ def edit_doc_payload(repo_root: Path, rel_path: str, *, launcher: Any | None = N
     }
 
 
+def open_repo_folder_payload(repo_root: Path, *, launcher: Any | None = None) -> dict[str, str]:
+    root = repo_root.resolve()
+    command = _system_editor_command(root)
+    runner = launcher or subprocess.Popen
+    runner(command)
+    return {
+        "path": str(root),
+        "command": command[0],
+    }
+
+
 def _system_editor_command(path: Path) -> list[str]:
     if sys.platform == "darwin":
         return ["open", str(path)]
@@ -412,6 +584,12 @@ def _run_read_only_cdx(repo_root: Path, args: list[str], *, runner: Any | None =
     return cdx_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=5)
 
 
+def _run_read_only_gh(repo_root: Path, args: list[str], *, runner: Any | None = None) -> subprocess.CompletedProcess[str]:
+    command = ["gh", *args]
+    gh_runner = runner or subprocess.run
+    return gh_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=8)
+
+
 def _logics_doc_type(rel_path: str) -> str:
     normalized = rel_path.replace("\\", "/").lstrip("/")
     for family in DOC_FAMILIES:
@@ -427,6 +605,62 @@ def _sanitize_git_ref(value: str) -> str:
     return ref[:200]
 
 
+def _github_web_url_from_remote(value: str) -> str:
+    remote = value.strip()
+    if not remote:
+        return ""
+    remote = re.sub(r"^git\+", "", remote)
+    match = re.match(r"^(?:https://|http://)(?:[^/@\s]+@)?github\.com[:/]+([^/\s]+)/([^/\s]+?)(?:\.git)?/?$", remote)
+    if not match:
+        match = re.match(r"^(?:ssh://)?git@github\.com[:/]+([^/\s]+)/([^/\s]+?)(?:\.git)?/?$", remote)
+    if not match:
+        return ""
+    owner, repo = match.groups()
+    if not owner or not repo:
+        return ""
+    return f"https://github.com/{owner}/{repo}"
+
+
+def _github_owner_repo_from_web_url(value: str) -> tuple[str, str] | None:
+    match = re.match(r"^https://github\.com/([^/\s]+)/([^/\s]+?)/?$", value.strip())
+    if not match:
+        return None
+    owner, repo = match.groups()
+    return owner, repo
+
+
+def github_repo_url(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> str:
+    git_which = which or shutil.which
+    if not git_which("git"):
+        return ""
+    try:
+        remotes = _run_read_only_git(repo_root, ["remote", "-v"], runner=runner)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    if remotes.returncode != 0:
+        return ""
+
+    candidates: list[tuple[int, str]] = []
+    for line in remotes.stdout.splitlines():
+        parts = line.split()
+        if len(parts) < 2:
+            continue
+        name, url = parts[0], parts[1]
+        web_url = _github_web_url_from_remote(url)
+        if web_url:
+            candidates.append((0 if name == "origin" else 1, web_url))
+    if not candidates:
+        return ""
+    return sorted(candidates, key=lambda entry: entry[0])[0][1]
+
+
+def _has_github_actions_workflows(repo_root: Path) -> bool:
+    workflows_dir = repo_root / ".github" / "workflows"
+    if not workflows_dir.is_dir():
+        return False
+    return any(path.is_file() and path.suffix.lower() in {".yml", ".yaml"} for path in workflows_dir.iterdir())
+
+
 def _classify_porcelain_entry(line: str) -> tuple[str, dict[str, str]] | None:
     if not line or line.startswith("## "):
         return None
@@ -579,7 +813,7 @@ def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
         commit = _run_read_only_git(repo_root, ["log", "-1", "--pretty=format:%h %s"], runner=runner)
         recent_commits = _run_read_only_git(
             repo_root,
-            ["log", "-8", "--date=short", "--pretty=format:%h%x1f%s%x1f%an%x1f%ad%x1f%D"],
+            ["log", "-50", "--date=short", "--pretty=format:%h%x1f%s%x1f%an%x1f%ad%x1f%D"],
             runner=runner,
         )
         unpushed = _git_unpushed_commit_count(repo_root, runner=runner)
@@ -678,6 +912,164 @@ def git_diff_payload(
     }
 
 
+def _current_git_ci_context(repo_root: Path, *, runner: Any | None = None) -> dict[str, str]:
+    context = {"branch": "", "headSha": "", "subject": "", "author": ""}
+    commands = {
+        "branch": ["rev-parse", "--abbrev-ref", "HEAD"],
+        "headSha": ["rev-parse", "HEAD"],
+        "subject": ["log", "-1", "--pretty=format:%s"],
+        "author": ["log", "-1", "--pretty=format:%an"],
+    }
+    for key, args in commands.items():
+        try:
+            result = _run_read_only_git(repo_root, args, runner=runner)
+        except (OSError, subprocess.SubprocessError):
+            continue
+        if result.returncode == 0:
+            context[key] = result.stdout.strip()[:240]
+    if context["branch"] == "HEAD":
+        context["branch"] = ""
+    return context
+
+
+def _ci_badge_state(status: str, conclusion: str) -> str:
+    normalized_status = status.strip().lower()
+    normalized_conclusion = conclusion.strip().lower()
+    if normalized_status in {"queued", "in_progress", "waiting", "requested", "pending"}:
+        return "running" if normalized_status == "in_progress" else "queued"
+    if normalized_conclusion == "success":
+        return "passing"
+    if normalized_conclusion in {"failure", "timed_out", "action_required"}:
+        return "failing"
+    if normalized_conclusion == "cancelled":
+        return "cancelled"
+    return "unknown"
+
+
+def _parse_github_actions_run(run: dict[str, Any], *, match_source: str) -> dict[str, Any]:
+    status = str(run.get("status") or "")
+    conclusion = str(run.get("conclusion") or "")
+    commit = run.get("head_commit") if isinstance(run.get("head_commit"), dict) else {}
+    author = commit.get("author") if isinstance(commit.get("author"), dict) else {}
+    return {
+        "id": run.get("id"),
+        "name": str(run.get("name") or run.get("display_title") or "GitHub Actions"),
+        "workflowName": str(run.get("name") or "GitHub Actions"),
+        "status": status,
+        "conclusion": conclusion,
+        "badgeState": _ci_badge_state(status, conclusion),
+        "branch": str(run.get("head_branch") or ""),
+        "headSha": str(run.get("head_sha") or ""),
+        "event": str(run.get("event") or ""),
+        "htmlUrl": str(run.get("html_url") or ""),
+        "createdAt": str(run.get("created_at") or ""),
+        "updatedAt": str(run.get("updated_at") or ""),
+        "runStartedAt": str(run.get("run_started_at") or ""),
+        "commitMessage": str(commit.get("message") or run.get("display_title") or "").splitlines()[0][:240],
+        "author": str(author.get("name") or ""),
+        "matchSource": match_source,
+    }
+
+
+def _parse_github_actions_jobs(output: str) -> list[dict[str, str]]:
+    try:
+        parsed = json.loads(output or "{}")
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(parsed, dict):
+        return []
+    jobs = parsed.get("jobs")
+    if not isinstance(jobs, list):
+        return []
+    rows: list[dict[str, str]] = []
+    for job in jobs[:30]:
+        if not isinstance(job, dict):
+            continue
+        rows.append(
+            {
+                "name": str(job.get("name") or "Job"),
+                "status": str(job.get("status") or ""),
+                "conclusion": str(job.get("conclusion") or ""),
+                "htmlUrl": str(job.get("html_url") or ""),
+                "startedAt": str(job.get("started_at") or ""),
+                "completedAt": str(job.get("completed_at") or ""),
+            }
+        )
+    return rows
+
+
+def ci_status_payload(repo_root: Path, *, git_runner: Any | None = None, gh_runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    git_which = which or shutil.which
+    github_url = github_repo_url(repo_root, runner=git_runner, which=git_which)
+    if not github_url:
+        return {"state": "hidden", "visible": False, "message": "No GitHub remote detected."}
+    owner_repo = _github_owner_repo_from_web_url(github_url)
+    if not owner_repo:
+        return {"state": "hidden", "visible": False, "message": "GitHub remote could not be parsed."}
+    if not _has_github_actions_workflows(repo_root):
+        return {"state": "hidden", "visible": False, "message": "No GitHub Actions workflows detected."}
+    if not git_which("gh"):
+        return {
+            "state": "unavailable",
+            "visible": True,
+            "message": "GitHub CLI is not available on PATH.",
+            "repositoryUrl": github_url,
+            "badgeState": "unavailable",
+        }
+
+    owner, repo = owner_repo
+    context = _current_git_ci_context(repo_root, runner=git_runner)
+    branch = context.get("branch", "")
+    head_sha = context.get("headSha", "")
+    endpoint = f"repos/{owner}/{repo}/actions/runs?per_page=10"
+    if branch:
+        endpoint = f"{endpoint}&branch={quote(branch, safe='')}"
+    try:
+        runs_result = _run_read_only_gh(repo_root, ["api", endpoint], runner=gh_runner)
+    except subprocess.TimeoutExpired:
+        return {"state": "timeout", "visible": True, "message": "GitHub Actions status timed out.", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "visible": True, "message": f"Unable to collect GitHub Actions status: {exc}", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    if runs_result.returncode != 0:
+        message = (runs_result.stderr or runs_result.stdout or "GitHub Actions status failed.").strip().splitlines()[0]
+        return {"state": "unavailable", "visible": True, "message": message, "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+
+    try:
+        parsed = json.loads(runs_result.stdout or "{}")
+    except json.JSONDecodeError:
+        return {"state": "invalid-json", "visible": True, "message": "GitHub Actions status returned invalid JSON.", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    workflow_runs = parsed.get("workflow_runs") if isinstance(parsed, dict) else None
+    runs = [run for run in workflow_runs if isinstance(run, dict)] if isinstance(workflow_runs, list) else []
+    if not runs:
+        return {"state": "ok", "visible": True, "message": "No GitHub Actions runs found for the current branch.", "repositoryUrl": github_url, **context, "badgeState": "unknown", "run": None, "jobs": []}
+
+    selected = next((run for run in runs if head_sha and str(run.get("head_sha") or "") == head_sha), None)
+    match_source = "head" if selected else "branch-latest"
+    if selected is None:
+        selected = runs[0]
+    run_payload = _parse_github_actions_run(selected, match_source=match_source)
+    jobs: list[dict[str, str]] = []
+    run_id = run_payload.get("id")
+    if run_id:
+        try:
+            jobs_result = _run_read_only_gh(repo_root, ["api", f"repos/{owner}/{repo}/actions/runs/{run_id}/jobs?per_page=100"], runner=gh_runner)
+        except (OSError, subprocess.SubprocessError, subprocess.TimeoutExpired):
+            jobs_result = None
+        if jobs_result is not None and jobs_result.returncode == 0:
+            jobs = _parse_github_actions_jobs(jobs_result.stdout)
+
+    return {
+        "state": "ok",
+        "visible": True,
+        "message": "",
+        "repositoryUrl": github_url,
+        **context,
+        "badgeState": run_payload["badgeState"],
+        "run": run_payload,
+        "jobs": jobs,
+    }
+
+
 def cdx_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
     cdx_which = which or shutil.which
     if not cdx_which("cdx"):
@@ -704,6 +1096,123 @@ def cdx_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
     return {"state": "ok", "message": "", "status": parsed}
 
 
+def cdx_runs_payload(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    cdx_which = which or shutil.which
+    if not cdx_which("cdx"):
+        return {"state": "unavailable", "message": "CDX executable is not available on PATH.", "runs": []}
+    try:
+        result = _run_read_only_cdx(repo_root, ["runs", "--json"], runner=runner)
+    except subprocess.TimeoutExpired:
+        return {"state": "timeout", "message": "CDX runs timed out.", "runs": []}
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to run CDX runs: {exc}", "runs": []}
+    if result.returncode != 0:
+        message = (result.stderr or result.stdout or "CDX runs failed.").strip().splitlines()[0]
+        return {"state": "error", "message": message, "runs": []}
+    try:
+        parsed = json.loads(result.stdout or "{}")
+    except json.JSONDecodeError:
+        return {"state": "invalid-json", "message": "CDX runs returned invalid JSON.", "runs": []}
+    runs = parsed.get("runs") if isinstance(parsed, dict) else None
+    if not isinstance(runs, list):
+        return {"state": "invalid-json", "message": "CDX runs JSON must include a runs array.", "runs": []}
+    return {"state": "ok", "message": "", "runs": [run for run in runs if isinstance(run, dict)]}
+
+
+def cdx_run_report_payload(repo_root: Path, run_id: str, *, runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    cdx_which = which or shutil.which
+    if not run_id:
+        return {"state": "error", "message": "Missing CDX run id.", "report": None}
+    if not cdx_which("cdx"):
+        return {"state": "unavailable", "message": "CDX executable is not available on PATH.", "report": None}
+    try:
+        result = _run_read_only_cdx(repo_root, ["run-report", run_id, "--json"], runner=runner)
+    except subprocess.TimeoutExpired:
+        return {"state": "timeout", "message": "CDX run report timed out.", "report": None}
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to run CDX run-report: {exc}", "report": None}
+    if result.returncode != 0:
+        message = (result.stderr or result.stdout or "CDX run-report failed.").strip().splitlines()[0]
+        return {"state": "error", "message": message, "report": None}
+    try:
+        parsed = json.loads(result.stdout or "{}")
+    except json.JSONDecodeError:
+        return {"state": "invalid-json", "message": "CDX run-report returned invalid JSON.", "report": None}
+    report = parsed.get("report") if isinstance(parsed, dict) else None
+    if not isinstance(report, dict):
+        return {"state": "invalid-json", "message": "CDX run-report JSON must include a report object.", "report": None}
+    return {"state": "ok", "message": "", "report": report}
+
+
+def _slugify_viewer_doc(text: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "_", text.lower()).strip("_")
+    return slug[:80] or "cdx_code_review_findings"
+
+
+def _next_viewer_request_ref(repo_root: Path, title: str) -> str:
+    request_dir = repo_root / "logics" / "request"
+    highest = -1
+    if request_dir.is_dir():
+        for path in request_dir.glob("req_*.md"):
+            match = re.match(r"^req_(\d{3})_", path.stem)
+            if match:
+                highest = max(highest, int(match.group(1)))
+    return f"req_{highest + 1:03d}_{_slugify_viewer_doc(title)}"
+
+
+def create_request_from_cdx_report(repo_root: Path, report_payload: dict[str, Any]) -> dict[str, Any]:
+    report = report_payload.get("report") if isinstance(report_payload.get("report"), dict) else report_payload
+    run = report.get("run") if isinstance(report.get("run"), dict) else {}
+    task_report = report.get("task_report") if isinstance(report.get("task_report"), dict) else {}
+    run_id = str(run.get("run_id") or task_report.get("run_id") or "unknown")
+    findings = task_report.get("findings") if isinstance(task_report.get("findings"), list) else []
+    title = f"Address CDX code review findings for {run_id}"
+    ref = _next_viewer_request_ref(repo_root, title)
+    request_dir = repo_root / "logics" / "request"
+    request_dir.mkdir(parents=True, exist_ok=True)
+    rel_path = f"logics/request/{ref}.md"
+    path = repo_root / rel_path
+    finding_lines = []
+    for index, finding in enumerate(findings, start=1):
+        if not isinstance(finding, dict):
+            continue
+        location = finding.get("path") or finding.get("file") or "unknown path"
+        if finding.get("line"):
+            location = f"{location}:{finding['line']}"
+        severity = finding.get("severity") or "unknown"
+        message = finding.get("message") or finding.get("title") or "Review finding"
+        finding_lines.append(f"- F{index} [{severity}] `{location}`: {message}")
+    if not finding_lines:
+        finding_lines.append("- No structured findings were reported. Review the CDX artifacts linked below.")
+    text = "\n".join([
+        f"## {ref} - {title}",
+        "> Status: Draft",
+        "> Understanding: 70%",
+        "> Confidence: 70%",
+        "> Complexity: Medium",
+        "> Theme: Code review follow-up",
+        "",
+        "# Needs",
+        f"- Follow up on CDX code-review run `{run_id}`.",
+        f"- Summary: {task_report.get('summary') or 'No structured summary provided.'}",
+        "",
+        "# Findings",
+        *finding_lines,
+        "",
+        "# Traceability",
+        f"- CDX run id: `{run_id}`",
+        f"- Transcript: `{(report.get('artifacts') or {}).get('transcript_path') or ''}`",
+        f"- Stdout: `{(report.get('artifacts') or {}).get('stdout_path') or ''}`",
+        "",
+        "# Acceptance Criteria",
+        "- AC1: Each actionable finding is reviewed and either fixed, documented as not applicable, or split into follow-up work.",
+        "- AC2: Validation evidence is added before closing this request.",
+        "",
+    ])
+    path.write_text(text, encoding="utf-8")
+    return {"id": ref, "path": rel_path, "title": title}
+
+
 def _json_bytes(payload: Any) -> bytes:
     return json.dumps(payload, indent=2, sort_keys=True).encode("utf-8")
 
@@ -716,10 +1225,35 @@ class LogicsViewerServer(ThreadingHTTPServer):
         *,
         auto_refresh_interval_seconds: int = 15,
     ):
-        self.repo_root = repo_root.resolve()
+        self.launch_repo_root = repo_root.resolve()
+        self.project_roots = discover_viewer_project_roots(self.launch_repo_root)
+        self.project_root_by_id = {_viewer_project_id(root): root.resolve() for root in self.project_roots}
+        self.active_project_id = _viewer_project_id(self.launch_repo_root)
+        self.repo_root = self.launch_repo_root
         self.auto_refresh_interval_seconds = auto_refresh_interval_seconds
         super().__init__(server_address, LogicsViewerRequestHandler)
 
+    def project_registry_payload(self) -> list[dict[str, Any]]:
+        return viewer_project_registry(self.repo_root, project_roots=self.project_roots)
+
+    def viewer_payload(self, *, selected_id: str | None = None) -> dict[str, Any]:
+        return viewer_data_payload(
+            self.repo_root,
+            selected_id=selected_id,
+            auto_refresh_interval_seconds=self.auto_refresh_interval_seconds,
+            projects=self.project_registry_payload(),
+        )
+
+    def switch_project(self, project_id: str) -> dict[str, Any]:
+        target = self.project_root_by_id.get(project_id)
+        if target is None:
+            raise ValueError("Unknown project id.")
+        if not target.is_dir():
+            raise FileNotFoundError(str(target))
+        self.active_project_id = project_id
+        self.repo_root = target
+        return self.viewer_payload()
+
 
 class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
     server: LogicsViewerServer
@@ -783,13 +1317,13 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             self._send_json(
                 {
                     "ok": True,
-                    "payload": viewer_data_payload(
-                        self.server.repo_root,
-                        auto_refresh_interval_seconds=self.server.auto_refresh_interval_seconds,
-                    ),
+                    "payload": self.server.viewer_payload(),
                 }
             )
             return
+        if route == "/api/projects":
+            self._send_json({"ok": True, "payload": {"projects": self.server.project_registry_payload()}})
+            return
         if route == "/api/doc":
             rel_path = parse_qs(parsed.query).get("path", [""])[0]
             try:
@@ -803,12 +1337,25 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
         if route == "/api/audit":
             self._send_json({"ok": True, "payload": audit_payload(self.server.repo_root)})
             return
+        if route == "/api/capabilities":
+            self._send_json({"ok": True, "payload": viewer_project_capabilities(self.server.repo_root)})
+            return
         if route == "/api/git-status":
             self._send_json({"ok": True, "payload": git_status_payload(self.server.repo_root)})
             return
+        if route == "/api/ci-status":
+            self._send_json({"ok": True, "payload": ci_status_payload(self.server.repo_root)})
+            return
         if route == "/api/cdx-status":
             self._send_json({"ok": True, "payload": cdx_status_payload(self.server.repo_root)})
             return
+        if route == "/api/cdx-runs":
+            self._send_json({"ok": True, "payload": cdx_runs_payload(self.server.repo_root)})
+            return
+        if route == "/api/cdx-run-report":
+            run_id = parse_qs(parsed.query).get("runId", [""])[0]
+            self._send_json({"ok": True, "payload": cdx_run_report_payload(self.server.repo_root, run_id)})
+            return
         if route == "/api/git-diff":
             params = parse_qs(parsed.query)
             rel_path = params.get("path", [""])[0]
@@ -823,13 +1370,49 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             self._send_json(
                 {
                     "ok": True,
-                    "payload": viewer_data_payload(
-                        self.server.repo_root,
-                        auto_refresh_interval_seconds=self.server.auto_refresh_interval_seconds,
-                    ),
+                    "payload": self.server.viewer_payload(),
                 }
             )
             return
+        if parsed.path == "/api/switch-project":
+            try:
+                length = int(self.headers.get("Content-Length", "0") or "0")
+                raw_body = self.rfile.read(length).decode("utf-8") if length > 0 else "{}"
+                body = json.loads(raw_body or "{}")
+                project_id = str(body.get("projectId") or "")
+                self._send_json({"ok": True, "payload": self.server.switch_project(project_id)})
+            except json.JSONDecodeError:
+                self._send_error_json(HTTPStatus.BAD_REQUEST, "Invalid JSON body.")
+            except ValueError as exc:
+                self._send_error_json(HTTPStatus.FORBIDDEN, str(exc))
+            except FileNotFoundError as exc:
+                self._send_error_json(HTTPStatus.NOT_FOUND, str(exc))
+            return
+        if parsed.path == "/api/bootstrap-logics":
+            try:
+                bootstrap = bootstrap_payload(self.server.repo_root, check=False)
+                self._send_json({"ok": True, "payload": self.server.viewer_payload(), "bootstrap": bootstrap})
+            except SystemExit as exc:
+                self._send_error_json(HTTPStatus.BAD_REQUEST, str(exc))
+            except OSError as exc:
+                self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
+            return
+        if parsed.path == "/api/cdx-report-request":
+            try:
+                length = int(self.headers.get("Content-Length", "0") or "0")
+                raw_body = self.rfile.read(length).decode("utf-8") if length > 0 else "{}"
+                body = json.loads(raw_body or "{}")
+                report_payload = cdx_run_report_payload(self.server.repo_root, str(body.get("runId") or ""))
+                if report_payload.get("state") != "ok":
+                    self._send_error_json(HTTPStatus.BAD_GATEWAY, str(report_payload.get("message") or "Unable to load CDX report."))
+                    return
+                created = create_request_from_cdx_report(self.server.repo_root, report_payload)
+                self._send_json({"ok": True, "created": created, "payload": self.server.viewer_payload(selected_id=created["id"])})
+            except json.JSONDecodeError:
+                self._send_error_json(HTTPStatus.BAD_REQUEST, "Invalid JSON body.")
+            except OSError as exc:
+                self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
+            return
         if parsed.path == "/api/edit":
             rel_path = parse_qs(parsed.query).get("path", [""])[0]
             try:
@@ -839,6 +1422,12 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             except OSError as exc:
                 self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
             return
+        if parsed.path == "/api/open-repo-folder":
+            try:
+                self._send_json({"ok": True, "payload": open_repo_folder_payload(self.server.repo_root)})
+            except OSError as exc:
+                self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
+            return
         self._send_error_json(HTTPStatus.NOT_FOUND, "Not found")