@grifhinz/logics-manager 2.6.0 → 2.7.0

package/VERSION

@@ -1 +1 @@
-2.6.0
+2.7.0

package/clients/viewer/browser-host.js

@@ -13,6 +13,7 @@
   const connectionDetail = () => document.getElementById("viewer-connection-detail");
   const filterCount = () => document.getElementById("viewer-filter-count");
   const repoPill = () => document.getElementById("viewer-repo-pill");
+  const projectMenu = () => document.getElementById("viewer-project-menu");
   const repoGithubLink = () => document.getElementById("viewer-repo-github");
   const repoFolderButton = () => document.getElementById("viewer-repo-folder");
   const ciButton = () => document.getElementById("viewer-ci");
@@ -37,6 +38,8 @@
   let latestItems = [];
   let latestRepoRoot = "";
   let latestRepository = { root: "", githubUrl: "" };
+  let latestCapabilities = {};
+  let latestProjects = [];
   let latestMetaText = "Read-only local viewer";
   let autoRefreshIntervalMs = defaultAutoRefreshIntervalMs;
   let nextAutoRefreshAt = 0;
@@ -273,6 +276,7 @@
 
   function updateRepositoryIdentity(payload) {
     latestRepoRoot = String(payload.root || latestRepoRoot || "");
+    latestProjects = Array.isArray(payload.projects) ? payload.projects : latestProjects;
     const repository = payload.repository && typeof payload.repository === "object" ? payload.repository : {};
     latestRepository = {
       root: String(repository.root || latestRepoRoot || ""),
@@ -281,10 +285,178 @@
     const pill = repoPill();
     if (pill) {
       const repoName = String(payload.repoName || latestRepoRoot.split(/[\\/]/).filter(Boolean).pop() || "repository");
-      pill.textContent = repoName;
+      const label = pill.querySelector("[data-viewer-project-label]");
+      if (label) {
+        label.textContent = repoName;
+      } else {
+        pill.textContent = repoName;
+      }
       pill.title = latestRepoRoot || repoName;
+      if ("disabled" in pill) {
+        pill.disabled = latestProjects.length <= 1;
+      }
+      pill.onclick = () => {
+        const menu = projectMenu();
+        setProjectMenuOpen(Boolean(menu?.hidden));
+      };
     }
     updateRepositoryShortcuts();
+    renderProjectMenu();
+  }
+
+  function projectStateLabel(project) {
+    if (project?.active) {
+      return "current";
+    }
+    if (project?.available === false) {
+      return "missing";
+    }
+    if (project?.hasLogics === false) {
+      return "no Logics";
+    }
+    return "available";
+  }
+
+  function renderProjectMenu() {
+    const menu = projectMenu();
+    if (!(menu instanceof HTMLElement)) {
+      return;
+    }
+    const projects = latestProjects.filter((project) => project && typeof project === "object");
+    menu.innerHTML = projects.map((project) => `
+      <button class="viewer-project-switcher__item${project.active ? " is-active" : ""}" type="button" role="menuitem" data-viewer-project-id="${escapeHtml(project.id || "")}" title="${escapeHtml(project.root || project.name || "")}">
+        <span class="viewer-project-switcher__item-name">${escapeHtml(project.name || "project")}</span>
+        <span class="viewer-project-switcher__item-state">${escapeHtml(projectStateLabel(project))}</span>
+        <span class="viewer-project-switcher__item-path">${escapeHtml(project.root || "")}</span>
+      </button>
+    `).join("");
+  }
+
+  function setProjectMenuOpen(open) {
+    const button = repoPill();
+    const menu = projectMenu();
+    if (!(button instanceof HTMLElement) || !(menu instanceof HTMLElement)) {
+      return;
+    }
+    const nextOpen = Boolean(open) && latestProjects.length > 1;
+    menu.hidden = !nextOpen;
+    button.setAttribute("aria-expanded", nextOpen ? "true" : "false");
+  }
+
+  async function switchViewerProject(projectId) {
+    if (!projectId) {
+      return;
+    }
+    const target = latestProjects.find((project) => project.id === projectId);
+    if (!target || target.active) {
+      setProjectMenuOpen(false);
+      return;
+    }
+    setProjectMenuOpen(false);
+    setMeta(`Switching to ${target.name || "project"}...`);
+    const response = await fetch("/api/switch-project", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ projectId })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.ok) {
+      throw new Error(data.error || "Unable to switch project.");
+    }
+    latestGitBadgeCounts = { unpushedCommits: 0, uncommittedFiles: 0 };
+    latestCiStatus = { visible: false, badgeState: "unknown", message: "" };
+    updateMainGitBadges();
+    updateMainCiBadge(latestCiStatus);
+    updateMainCdxBadge(null);
+    const panel = documentPanel();
+    if (panel) {
+      panel.hidden = true;
+    }
+    postToApp(data.payload);
+  }
+
+  async function bootstrapLogicsProject() {
+    setMeta("Bootstrapping Logics...");
+    const response = await fetch("/api/bootstrap-logics", { method: "POST" });
+    const data = await response.json();
+    if (!response.ok || !data.ok) {
+      throw new Error(data.error || "Unable to bootstrap Logics.");
+    }
+    postToApp(data.payload);
+    const created = Array.isArray(data.bootstrap?.created_paths) ? data.bootstrap.created_paths.length : 0;
+    setMeta(created > 0 ? `Logics bootstrapped · ${created} paths created.` : "Logics bootstrap checked.");
+  }
+
+  function normalizeCapabilities(payload) {
+    const capabilities = payload?.capabilities && typeof payload.capabilities === "object" ? payload.capabilities : {};
+    return {
+      logics: capabilities.logics || { state: "ready", available: true, message: "" },
+      git: capabilities.git || { state: "ready", available: true, message: "" },
+      ci: capabilities.ci || { state: "ready", available: true, message: "" },
+      cdx: capabilities.cdx || { state: "ready", available: true, message: "" },
+      cdxRuns: capabilities.cdxRuns || { state: "unsupported", available: false, message: "" }
+    };
+  }
+
+  function capability(name) {
+    return latestCapabilities?.[name] || { state: "unknown", available: false, message: "" };
+  }
+
+  function isCapabilityAvailable(name) {
+    return capability(name).available === true;
+  }
+
+  function capabilityMessage(name, fallback) {
+    return String(capability(name).message || fallback || "");
+  }
+
+  function setButtonUnavailable(button, message) {
+    if (!(button instanceof HTMLElement) || !("disabled" in button)) {
+      return;
+    }
+    button.disabled = true;
+    button.setAttribute("aria-disabled", "true");
+    button.title = message;
+  }
+
+  function setButtonAvailable(button, title) {
+    if (!(button instanceof HTMLElement) || !("disabled" in button)) {
+      return;
+    }
+    button.disabled = false;
+    button.removeAttribute("aria-disabled");
+    button.title = title;
+  }
+
+  function updateCapabilityControls() {
+    const gitButton = document.getElementById("viewer-git");
+    if (gitButton instanceof HTMLElement) {
+      gitButton.hidden = !isCapabilityAvailable("git");
+      if (isCapabilityAvailable("git")) {
+        setButtonAvailable(gitButton, "Show Git status");
+      } else {
+        setButtonUnavailable(gitButton, capabilityMessage("git", "Git is not available for this project."));
+      }
+    }
+
+    const ci = ciButton();
+    if (ci instanceof HTMLElement) {
+      ci.hidden = !isCapabilityAvailable("ci");
+      if (isCapabilityAvailable("ci")) {
+        setButtonAvailable(ci, "Show GitHub Actions CI status");
+      } else {
+        setButtonUnavailable(ci, capabilityMessage("ci", "CI is not available for this project."));
+      }
+    }
+
+    const cdx = document.getElementById("viewer-cdx");
+    if (cdx instanceof HTMLElement) {
+      if (isCapabilityAvailable("cdx")) {
+        setButtonAvailable(cdx, "Show CDX status");
+      } else {
+        setButtonUnavailable(cdx, capabilityMessage("cdx", "CDX is not available for this project."));
+      }
+    }
   }
 
   function updateRepositoryShortcuts() {
@@ -430,6 +602,10 @@
   }
 
   async function refreshCiBadgeCounters() {
+    if (!isCapabilityAvailable("ci")) {
+      updateMainCiBadge({ visible: false, badgeState: "unknown", message: capabilityMessage("ci", "CI is not available for this project.") });
+      return;
+    }
     try {
       const response = await fetch("/api/ci-status");
       if (response.status === 404) {
@@ -476,7 +652,9 @@
     button.querySelector("[data-viewer-cdx-badge]")?.remove();
     const activeCount = activeCdxAssistantCountFromPayload(payload);
     if (activeCount <= 0) {
-      button.title = "Show CDX status";
+      button.title = isCapabilityAvailable("cdx")
+        ? "Show CDX status"
+        : capabilityMessage("cdx", "CDX is not available for this project.");
       return;
     }
     const label = activeCount > 9 ? "9+" : String(activeCount);
@@ -486,6 +664,10 @@
   }
 
   async function refreshCdxBadgeCounters() {
+    if (!isCapabilityAvailable("cdx")) {
+      updateMainCdxBadge(null);
+      return;
+    }
     try {
       const response = await fetch("/api/cdx-status");
       if (response.status === 404) {
@@ -509,6 +691,11 @@
   }
 
   async function refreshGitBadgeCounters() {
+    if (!isCapabilityAvailable("git")) {
+      latestGitBadgeCounts = { unpushedCommits: 0, uncommittedFiles: 0 };
+      updateMainGitBadges();
+      return;
+    }
     try {
       const response = await fetch("/api/git-status");
       const data = await response.json();
@@ -586,13 +773,10 @@
     }, 0);
   }
 
-  function applyFocusRequest(payload) {
-    if (focusApplied) {
-      return payload;
-    }
+  function applyFocusRequest(payload, options = {}) {
     const request = focusRequest();
     if (!request.focus) {
-      if (window.location.search.includes("focus=")) {
+      if (!focusApplied && !options.silent && window.location.search.includes("focus=")) {
         window.setTimeout(() => setMeta("Invalid focus target. Loaded corpus without changing selection."), 0);
       }
       focusApplied = true;
@@ -600,14 +784,20 @@
     }
     const item = findFocusItem(request.focus);
     if (!item) {
-      window.setTimeout(() => setMeta(`Focus target not found: ${request.focus}`), 0);
+      if (!focusApplied && !options.silent) {
+        window.setTimeout(() => setMeta(`Focus target not found: ${request.focus}`), 0);
+      }
       focusApplied = true;
       return payload;
     }
+    const nextPayload = { ...payload, selectedId: item.id };
+    if (focusApplied) {
+      persistSelectedItem(item.id);
+      return nextPayload;
+    }
     viewerFilterState = { ...viewerFilterState, focus: "all", type: "all", status: "any", relation: "any", activity: "any" };
     persistSelectedItem(item.id);
     focusApplied = true;
-    const nextPayload = { ...payload, selectedId: item.id };
     window.setTimeout(() => {
       revealFocusedCard(item);
       if (request.read) {
@@ -765,8 +955,10 @@
       updateRefreshIntervalControl();
     }
     updateRepositoryIdentity(payload);
+    latestCapabilities = normalizeCapabilities(payload);
+    updateCapabilityControls();
     const payloadWithActivity = { ...payload, items: latestItems };
-    const nextPayload = options.silent ? payloadWithActivity : applyFocusRequest(payloadWithActivity);
+    const nextPayload = applyFocusRequest(payloadWithActivity, { silent: Boolean(options.silent) });
     window.dispatchEvent(new MessageEvent("message", { data: { type: "data", payload: nextPayload } }));
     const rootName = payload.root ? payload.root.split(/[\\/]/).filter(Boolean).pop() : "repository";
     if (!options.silent) {
@@ -840,6 +1032,12 @@
     return Boolean(panel && !panel.hidden && title && title.textContent === "CDX status");
   }
 
+  function isCdxRunsOpen() {
+    const panel = documentPanel();
+    const title = documentTitle();
+    return Boolean(panel && !panel.hidden && title && title.textContent === "CDX runs");
+  }
+
   function isCiStatusOpen() {
     const panel = documentPanel();
     const title = documentTitle();
@@ -854,6 +1052,8 @@
       await showCiStatus({ silent: Boolean(options.silent) });
     } else if (isCdxStatusOpen()) {
       await showCdxStatus({ silent: Boolean(options.silent) });
+    } else if (isCdxRunsOpen()) {
+      await showCdxRuns({ silent: Boolean(options.silent) });
     } else if (method === "POST") {
       await refreshGitBadgeCounters();
     }
@@ -1906,10 +2106,20 @@
     return rows || `<li class="viewer-cdx__empty">${escapeHtml(emptyText)}</li>`;
   }
 
+  function renderCdxModeSwitcher(active) {
+    return `
+      <div class="viewer-cdx__modes" role="tablist" aria-label="CDX views">
+        <button class="viewer-cdx__mode${active === "status" ? " is-active" : ""}" type="button" data-viewer-cdx-mode="status" aria-selected="${active === "status" ? "true" : "false"}">Status</button>
+        <button class="viewer-cdx__mode${active === "runs" ? " is-active" : ""}" type="button" data-viewer-cdx-mode="runs" aria-selected="${active === "runs" ? "true" : "false"}">Runs</button>
+      </div>
+    `;
+  }
+
   function renderCdxStatus(payload) {
     if (!payload || payload.state !== "ok") {
       return `
         <div class="viewer-cdx">
+          ${renderCdxModeSwitcher("status")}
           <div class="viewer-cdx__state">${escapeHtml(payload?.message || "CDX status is unavailable.")}</div>
         </div>
       `;
@@ -1945,6 +2155,7 @@
     `).join("");
     return `
       <div class="viewer-cdx">
+        ${renderCdxModeSwitcher("status")}
         <div class="viewer-cdx__summary">${cards}</div>
         <div class="viewer-cdx__workspace">
           <div class="viewer-cdx__stack">
@@ -1972,7 +2183,87 @@
     `;
   }
 
+  function renderCdxRuns(payload) {
+    if (!payload || payload.state !== "ok") {
+      return `
+        <div class="viewer-cdx">
+          ${renderCdxModeSwitcher("runs")}
+          <div class="viewer-cdx__state">${escapeHtml(payload?.message || "CDX runs are unavailable.")}</div>
+        </div>
+      `;
+    }
+    const runs = Array.isArray(payload.runs) ? payload.runs : [];
+    const rows = runs.map((run) => `
+      <tr>
+        <td><code>${escapeHtml(run.run_id || "-")}</code></td>
+        <td>${renderCdxBadge(run.status || "unknown")}</td>
+        <td>${escapeHtml(run.kind || "assistant")}</td>
+        <td>${escapeHtml(run.session || "-")}</td>
+        <td>${escapeHtml(run.cwd || "-")}</td>
+        <td><button class="viewer-cdx__mode" type="button" data-viewer-cdx-report="${escapeHtml(run.run_id || "")}">Report</button></td>
+      </tr>
+    `).join("");
+    return `
+      <div class="viewer-cdx">
+        ${renderCdxModeSwitcher("runs")}
+        <section class="viewer-cdx__section">
+          <div class="viewer-ci__heading"><h2>Assistant runs</h2><span>${escapeHtml(runs.length)} reported</span></div>
+          <div class="viewer-cdx__table-wrap">
+            <table class="viewer-cdx__table">
+              <thead><tr><th>RUN</th><th>STATUS</th><th>KIND</th><th>SESSION</th><th>CWD</th><th>REPORT</th></tr></thead>
+              <tbody>${rows || '<tr><td colspan="6" class="viewer-cdx__empty">No assistant runs reported.</td></tr>'}</tbody>
+            </table>
+          </div>
+        </section>
+      </div>
+    `;
+  }
+
+  function renderCdxReport(payload) {
+    if (!payload || payload.state !== "ok" || !payload.report) {
+      return `
+        <div class="viewer-cdx">
+          ${renderCdxModeSwitcher("runs")}
+          <div class="viewer-cdx__state">${escapeHtml(payload?.message || "CDX run report is unavailable.")}</div>
+        </div>
+      `;
+    }
+    const report = payload.report || {};
+    const run = report.run || {};
+    const taskReport = report.task_report || {};
+    const findings = Array.isArray(taskReport.findings) ? taskReport.findings : [];
+    const findingRows = findings.map((finding, index) => {
+      const location = [finding.path || finding.file || "", finding.line || ""].filter(Boolean).join(":") || "-";
+      return `<li class="viewer-cdx__entity"><div class="viewer-cdx__entity-main"><div><strong>${escapeHtml(finding.message || finding.title || `Finding ${index + 1}`)}</strong><div class="viewer-cdx__meta">${escapeHtml(location)}</div></div>${renderCdxBadge(finding.severity || "unknown")}</div></li>`;
+    }).join("");
+    const canCreate = taskReport.kind === "code-review";
+    return `
+      <div class="viewer-cdx">
+        ${renderCdxModeSwitcher("runs")}
+        <section class="viewer-cdx__section">
+          <div class="viewer-ci__heading"><h2>Run report</h2><span>${escapeHtml(run.status || "unknown")}</span></div>
+          <ul class="viewer-cdx__list">
+            <li class="viewer-cdx__row"><span>Run</span><strong>${escapeHtml(run.run_id || taskReport.run_id || "-")}</strong></li>
+            <li class="viewer-cdx__row"><span>Kind</span><strong>${escapeHtml(taskReport.kind || run.kind || "assistant")}</strong></li>
+            <li class="viewer-cdx__row"><span>Summary</span><strong>${escapeHtml(taskReport.summary || "No summary reported.")}</strong></li>
+          </ul>
+          ${canCreate ? `<button class="btn" type="button" data-viewer-cdx-create-request="${escapeHtml(run.run_id || taskReport.run_id || "")}">Create Logics request</button>` : ""}
+        </section>
+        <section class="viewer-cdx__section">
+          <div class="viewer-ci__heading"><h2>Findings</h2><span>${escapeHtml(findings.length)} reported</span></div>
+          <ul class="viewer-cdx__list">${findingRows || '<li class="viewer-cdx__empty">No structured findings reported.</li>'}</ul>
+        </section>
+      </div>
+    `;
+  }
+
   async function showCdxStatus(options = {}) {
+    if (!isCapabilityAvailable("cdx")) {
+      const message = capabilityMessage("cdx", "CDX is not available for this project.");
+      setDocument("CDX status", renderCdxStatus({ state: capability("cdx").state, message }));
+      setMeta(message);
+      return;
+    }
     if (!options.silent) {
       setMeta("Checking CDX status...");
     }
@@ -1999,6 +2290,62 @@
     setMeta(options.silent ? "CDX status refreshed." : "CDX status loaded.");
   }
 
+  async function showCdxRuns(options = {}) {
+    if (!isCapabilityAvailable("cdx")) {
+      const message = capabilityMessage("cdx", "CDX is not available for this project.");
+      setDocument("CDX runs", renderCdxRuns({ state: capability("cdx").state, message }));
+      setMeta(message);
+      return;
+    }
+    if (!options.silent) {
+      setMeta("Checking CDX runs...");
+    }
+    const response = await fetch("/api/cdx-runs");
+    let data = {};
+    try {
+      data = await response.json();
+    } catch {
+      data = {};
+    }
+    if (!response.ok || !data.ok) {
+      throw new Error(data.error || "Unable to load CDX runs.");
+    }
+    setDocument("CDX runs", renderCdxRuns(data.payload));
+    setMeta(options.silent ? "CDX runs refreshed." : "CDX runs loaded.");
+  }
+
+  async function showCdxReport(runId) {
+    if (!runId) {
+      return;
+    }
+    setMeta("Loading CDX report...");
+    const response = await fetch(`/api/cdx-run-report?${new URLSearchParams({ runId }).toString()}`);
+    const data = await response.json();
+    if (!response.ok || !data.ok) {
+      throw new Error(data.error || "Unable to load CDX report.");
+    }
+    setDocument("CDX run report", renderCdxReport(data.payload));
+    setMeta("CDX report loaded.");
+  }
+
+  async function createRequestFromCdxReport(runId) {
+    if (!runId) {
+      return;
+    }
+    setMeta("Creating Logics request from CDX report...");
+    const response = await fetch("/api/cdx-report-request", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ runId })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.ok) {
+      throw new Error(data.error || "Unable to create Logics request.");
+    }
+    postToApp(data.payload);
+    setMeta(`Created ${data.created?.id || "Logics request"} from CDX report.`);
+  }
+
   function renderCiBadge(value) {
     const tone = ciBadgeTone(value);
     return `<span class="viewer-ci__badge viewer-ci__badge--${escapeHtml(tone)}">${escapeHtml(ciBadgeLabel(value))}</span>`;
@@ -2068,6 +2415,12 @@
   }
 
   async function showCiStatus(options = {}) {
+    if (!isCapabilityAvailable("ci")) {
+      const message = capabilityMessage("ci", "CI is not available for this project.");
+      setDocument("CI status", renderCiStatus({ visible: false, state: capability("ci").state, message }));
+      setMeta(message);
+      return;
+    }
     if (!options.silent) {
       setMeta("Checking CI status...");
     }
@@ -2341,6 +2694,12 @@
 
   async function showGitStatus(options = {}) {
     const previous = options.preserve ? currentGitViewState() : { domain: "changes", path: "", cached: false };
+    if (!isCapabilityAvailable("git")) {
+      const message = capabilityMessage("git", "Git is not available for this project.");
+      setDocument("Git status", renderGitStatus({ state: capability("git").state, message }));
+      setMeta(message);
+      return;
+    }
     if (!options.silent) {
       setMeta("Checking Git status...");
     }
@@ -2388,6 +2747,10 @@
           refreshViewer("POST").catch((error) => setMeta(error.message));
           return;
         }
+        if (message.type === "bootstrap-logics") {
+          bootstrapLogicsProject().catch((error) => setMeta(error.message));
+          return;
+        }
         if (message.type === "open" || message.type === "read") {
           const item = latestItems.find((entry) => entry.id === message.id);
           showDocument(item).catch((error) => setMeta(error.message));
@@ -2480,6 +2843,10 @@
     document.getElementById("viewer-cdx")?.addEventListener("click", () => {
       showCdxStatus().catch((error) => setMeta(error.message));
     });
+    repoPill()?.addEventListener("click", () => {
+      const menu = projectMenu();
+      setProjectMenuOpen(Boolean(menu?.hidden));
+    });
     repoFolderButton()?.addEventListener("click", () => {
       openRepositoryFolder().catch((error) => setMeta(error.message));
     });
@@ -2518,6 +2885,38 @@
       const gitHistoryRevealTarget = event.target instanceof Element ? event.target.closest("[data-viewer-git-history-reveal]") : null;
       const gitDomainTarget = event.target instanceof Element ? event.target.closest(".viewer-git__domain[data-viewer-git-domain]") : null;
       const gitFileTarget = event.target instanceof Element ? event.target.closest("[data-viewer-git-file]") : null;
+      const projectSwitcherTarget = event.target instanceof Element ? event.target.closest("#viewer-repo-pill") : null;
+      const projectTarget = event.target instanceof Element ? event.target.closest("[data-viewer-project-id]") : null;
+      const cdxModeTarget = event.target instanceof Element ? event.target.closest("[data-viewer-cdx-mode]") : null;
+      const cdxReportTarget = event.target instanceof Element ? event.target.closest("[data-viewer-cdx-report]") : null;
+      const cdxCreateRequestTarget = event.target instanceof Element ? event.target.closest("[data-viewer-cdx-create-request]") : null;
+      if (cdxReportTarget instanceof HTMLElement) {
+        showCdxReport(cdxReportTarget.getAttribute("data-viewer-cdx-report") || "").catch((error) => setMeta(error.message));
+        return;
+      }
+      if (cdxCreateRequestTarget instanceof HTMLElement) {
+        createRequestFromCdxReport(cdxCreateRequestTarget.getAttribute("data-viewer-cdx-create-request") || "").catch((error) => setMeta(error.message));
+        return;
+      }
+      if (cdxModeTarget instanceof HTMLElement) {
+        const mode = cdxModeTarget.getAttribute("data-viewer-cdx-mode") || "status";
+        if (mode === "runs") {
+          showCdxRuns().catch((error) => setMeta(error.message));
+        } else {
+          showCdxStatus().catch((error) => setMeta(error.message));
+        }
+        return;
+      }
+      if (projectSwitcherTarget instanceof HTMLElement) {
+        const menu = projectMenu();
+        setProjectMenuOpen(Boolean(menu?.hidden));
+        return;
+      }
+      if (projectTarget instanceof HTMLElement) {
+        event.preventDefault();
+        switchViewerProject(projectTarget.getAttribute("data-viewer-project-id") || "").catch((error) => setMeta(error.message));
+        return;
+      }
       if (gitHistoryRevealTarget instanceof HTMLElement) {
         event.preventDefault();
         event.stopImmediatePropagation();

package/clients/viewer/index.html

@@ -18,7 +18,13 @@
     <div>
       <div class="viewer-topbar__identity">
         <div class="viewer-topbar__title">Logics Viewer</div>
-        <span class="viewer-topbar__repo" id="viewer-repo-pill" title="">repository</span>
+        <div class="viewer-project-switcher" id="viewer-project-switcher">
+          <button class="viewer-topbar__repo viewer-project-switcher__button" id="viewer-repo-pill" type="button" title="" aria-haspopup="menu" aria-expanded="false" aria-controls="viewer-project-menu">
+            <span data-viewer-project-label>repository</span>
+            <span class="viewer-project-switcher__chevron" aria-hidden="true">v</span>
+          </button>
+          <div class="viewer-project-switcher__menu" id="viewer-project-menu" role="menu" aria-label="Known projects" hidden></div>
+        </div>
         <span class="viewer-topbar__repo-actions" id="viewer-repo-actions" aria-label="Repository shortcuts">
           <a class="viewer-topbar__repo-action" id="viewer-repo-github" href="#" target="_blank" rel="noreferrer" title="Open GitHub repository" aria-label="Open GitHub repository" hidden>
             <svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M9 19c-4.2 1.2-4.2-2-6-2.4m12 4.4v-3.5c0-1 .1-1.4-.5-2 2-.2 4.1-1 4.1-4.6 0-1-.4-1.9-1-2.6.1-.3.4-1.3-.1-2.6 0 0-.8-.3-2.7 1a9.3 9.3 0 0 0-4.9 0c-1.8-1.3-2.7-1-2.7-1-.5 1.3-.2 2.3-.1 2.6a3.8 3.8 0 0 0-1 2.6c0 3.6 2.1 4.4 4.1 4.6-.5.5-.7 1-.7 1.9V21" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" /></svg>
@@ -31,6 +37,9 @@
       <div class="viewer-topbar__meta" id="viewer-meta">Read-only local viewer</div>
     </div>
     <div class="viewer-topbar__actions">
+      <button class="btn" id="viewer-git" type="button" title="Show Git status">Git</button>
+      <button class="btn" id="viewer-ci" type="button" title="Show GitHub Actions CI status" hidden>CI</button>
+      <button class="btn" id="viewer-cdx" type="button" title="Show CDX status">CDX</button>
       <div class="viewer-refresh-menu">
         <button class="btn" id="viewer-refresh-menu-button" type="button" title="Viewer settings" aria-haspopup="menu" aria-expanded="false" aria-controls="viewer-refresh-menu">Settings</button>
         <div class="viewer-refresh-menu__panel" id="viewer-refresh-menu" role="menu" aria-label="Viewer settings" hidden>
@@ -59,9 +68,6 @@
           </section>
         </div>
       </div>
-      <button class="btn" id="viewer-git" type="button" title="Show Git status">Git</button>
-      <button class="btn" id="viewer-ci" type="button" title="Show GitHub Actions CI status" hidden>CI</button>
-      <button class="btn" id="viewer-cdx" type="button" title="Show CDX status">CDX</button>
     </div>
   </header>
 

package/clients/viewer/viewer.css

@@ -37,6 +37,92 @@
   line-height: 1.3;
 }
 
+.viewer-project-switcher {
+  position: relative;
+  min-width: 0;
+}
+
+.viewer-project-switcher__button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  cursor: pointer;
+}
+
+.viewer-project-switcher__button[disabled] {
+  cursor: default;
+  opacity: 0.75;
+}
+
+.viewer-project-switcher__chevron {
+  font-size: 9px;
+  opacity: 0.75;
+}
+
+.viewer-project-switcher__menu {
+  position: absolute;
+  z-index: 20;
+  top: calc(100% + 6px);
+  left: 0;
+  min-width: 260px;
+  max-width: min(420px, calc(100vw - 24px));
+  max-height: min(360px, calc(100vh - 96px));
+  overflow: auto;
+  padding: 6px;
+  border: 1px solid var(--vscode-panel-border, #333333);
+  border-radius: 6px;
+  background: var(--vscode-dropdown-background, var(--vscode-editorWidget-background, #202020));
+  box-shadow: 0 12px 28px rgb(0 0 0 / 28%);
+}
+
+.viewer-project-switcher__menu[hidden] {
+  display: none !important;
+}
+
+.viewer-project-switcher__item {
+  width: 100%;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 4px 10px;
+  padding: 7px 8px;
+  border: 0;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--vscode-foreground, #d4d4d4);
+  text-align: left;
+  cursor: pointer;
+}
+
+.viewer-project-switcher__item:hover,
+.viewer-project-switcher__item.is-active {
+  background: var(--vscode-list-hoverBackground, rgb(255 255 255 / 8%));
+}
+
+.viewer-project-switcher__item-name,
+.viewer-project-switcher__item-state {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.viewer-project-switcher__item-name {
+  font-weight: 650;
+}
+
+.viewer-project-switcher__item-path {
+  grid-column: 1 / -1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--vscode-descriptionForeground, #9da5b4);
+  font-size: 11px;
+}
+
+.viewer-project-switcher__item-state {
+  color: var(--vscode-descriptionForeground, #9da5b4);
+  font-size: 11px;
+}
+
 .viewer-topbar__repo-actions {
   display: inline-flex;
   align-items: center;
@@ -529,6 +615,31 @@
   gap: 14px;
 }
 
+.viewer-cdx__modes {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  width: fit-content;
+  padding: 2px;
+  border: 1px solid var(--vscode-panel-border, #333333);
+  border-radius: 6px;
+  background: var(--vscode-editorWidget-background, #202020);
+}
+
+.viewer-cdx__mode {
+  border: 0;
+  border-radius: 4px;
+  padding: 5px 10px;
+  background: transparent;
+  color: var(--vscode-descriptionForeground, #9da5b4);
+  cursor: pointer;
+}
+
+.viewer-cdx__mode.is-active {
+  background: var(--vscode-button-secondaryBackground, #3a3d41);
+  color: var(--vscode-button-secondaryForeground, var(--vscode-foreground, #d4d4d4));
+}
+
 .viewer-git__summary,
 .viewer-cdx__summary,
 .viewer-ci__summary,

package/logics_manager/assist.py

@@ -336,6 +336,7 @@ def _build_spec_first_pass(repo_root: Path, backlog_ref: str) -> dict[str, objec
         [
             f"## {ref} - {spec_title}",
             f"> From version: {_parse_package_version(repo_root)}",
+            "> Status: Draft",
             "> Understanding: 90%",
             "> Confidence: 85%",
             "",

package/logics_manager/flow.py

@@ -800,6 +800,8 @@ def _workflow_mermaid_block(kind: str, signature: str) -> list[str]:
 
 
 def _with_workflow_mermaid_overview(kind: str, content: str) -> str:
+    if kind == "task":
+        return content
     lines = content.rstrip().splitlines()
     signature = expected_workflow_mermaid_signature(kind, lines)
     if not signature:
@@ -995,6 +997,8 @@ def _mermaid_closeout_issue(path: Path, kind: str) -> str | None:
     text = path.read_text(encoding="utf-8")
     match = re.search(r"```mermaid\s*\n(.*?)\n```", text, flags=re.DOTALL)
     if match is None:
+        if kind == "task":
+            return None
         return "missing Mermaid overview block"
     signature_match = re.search(r"^\s*%%\s*logics-signature:\s*(.+?)\s*$", match.group(1), flags=re.MULTILINE)
     expected = expected_workflow_mermaid_signature(kind, text.splitlines())
@@ -1625,7 +1629,7 @@ def _build_native_task_doc(
             "",
         ]
     ).rstrip() + "\n"
-    return _with_workflow_mermaid_overview("task", content)
+    return content
 
 
 def _extract_doc_title(path: Path) -> str:
@@ -2183,7 +2187,7 @@ def _build_native_task_from_backlog(
             "",
         ]
     ).rstrip() + "\n"
-    return ref, _with_workflow_mermaid_overview("task", content)
+    return ref, content
 
 
 def build_parser() -> argparse.ArgumentParser:

package/logics_manager/lint.py

@@ -15,18 +15,19 @@ from .config import find_repo_root
 @dataclass(frozen=True)
 class Kind:
     directory: str
-    prefix: str
+    prefixes: tuple[str, ...]
     requires_progress: bool
     required_indicators: tuple[str, ...]
     allowed_statuses: tuple[str, ...]
 
 
 KINDS = {
-    "request": Kind("logics/request", "req", False, ("From version", "Understanding", "Confidence"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
-    "backlog": Kind("logics/backlog", "item", True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
-    "task": Kind("logics/tasks", "task", True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
-    "product": Kind("logics/product", "prod", False, ("Date", "Status", "Related request", "Related backlog", "Related task", "Related architecture", "Reminder"), ("Draft", "Proposed", "Active", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
-    "architecture": Kind("logics/architecture", "adr", False, ("Date", "Status", "Drivers", "Related request", "Related backlog", "Related task", "Reminder"), ("Draft", "Proposed", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
+    "request": Kind("logics/request", ("req",), False, ("From version", "Understanding", "Confidence"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
+    "backlog": Kind("logics/backlog", ("item",), True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
+    "task": Kind("logics/tasks", ("task",), True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
+    "product": Kind("logics/product", ("prod",), False, ("Date", "Status", "Related request", "Related backlog", "Related task", "Related architecture", "Reminder"), ("Draft", "Proposed", "Active", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
+    "architecture": Kind("logics/architecture", ("adr",), False, ("Date", "Status", "Drivers", "Related request", "Related backlog", "Related task", "Reminder"), ("Draft", "Proposed", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
+    "spec": Kind("logics/specs", ("spec", "req"), False, ("From version", "Status", "Understanding", "Confidence"), ("Draft", "Ready", "In progress", "Done", "Validated", "Settled", "Archived")),
 }
 
 WORKFLOW_KINDS = {"request", "backlog", "task"}
@@ -503,7 +504,8 @@ def _lint_file(path: Path, kind_name: str, kind: Kind, require_status: bool, che
     issues: list[str] = []
     warnings: list[str] = []
     name = path.name
-    if not re.match(rf"^{re.escape(kind.prefix)}_\d{{3}}_[a-z0-9_]+\.md$", name):
+    allowed_prefixes = "|".join(re.escape(prefix) for prefix in kind.prefixes)
+    if not re.match(rf"^({allowed_prefixes})_\d{{3}}_[a-z0-9_]+\.md$", name):
         issues.append(f"bad filename: {name}")
 
     lines = _read_lines(path)
@@ -557,6 +559,8 @@ def lint_payload(repo_root: Path, *, require_status: bool = False) -> dict[str,
         if not directory.is_dir():
             continue
         for path in sorted(directory.glob("*.md")):
+            if path.name == "README.md":
+                continue
             rel_path = path.relative_to(repo_root)
             issues, warnings = _lint_file(
                 path,

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,22 +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(repo_root.resolve()),
+            "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,
@@ -366,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 {
@@ -939,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")
 
@@ -951,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
@@ -1018,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:
@@ -1038,6 +1337,9 @@ 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
@@ -1047,6 +1349,13 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
         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]
@@ -1061,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:

package/package.json

@@ -2,7 +2,7 @@
   "name": "@grifhinz/logics-manager",
   "displayName": "Logics Orchestrator",
   "description": "Visual orchestration for Logics workflows inside VS Code.",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "publisher": "cdx-logics",
   "icon": "clients/shared-web/media/icon.png",
   "repository": {

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "logics-manager"
-version = "2.6.0"
+version = "2.7.0"
 description = "Canonical Logics CLI"
 requires-python = ">=3.10"