@codyswann/lisa 2.235.0 → 2.237.0

package/ui/index.html

@@ -326,6 +326,29 @@
         font-family: var(--mono);
         font-size: 11px;
       }
+      .plugins-state {
+        padding: 18px 20px;
+        border: 1px dashed var(--line);
+        border-radius: 10px;
+        background: var(--surface2);
+        color: var(--muted);
+        font-size: 13px;
+        line-height: 1.45;
+      }
+      .plugins-state.unknown {
+        border-style: solid;
+        border-color: var(--warn, #c9872a);
+      }
+      .plugins-state.unknown b {
+        display: block;
+        color: var(--text);
+        margin-bottom: 4px;
+      }
+      .plugins-live-block .plugin-status-badge.available {
+        background: transparent;
+        border: 1px solid var(--line);
+        color: var(--muted);
+      }
       .live-status-item .status-why {
         display: inline;
         margin: 0;
@@ -854,6 +877,23 @@
           grid-template-columns: 1fr;
         }
       }
+      .stacks-state {
+        border: 1px dashed var(--line);
+        border-radius: 10px;
+        background: var(--surface);
+        padding: 16px 18px;
+        color: var(--muted);
+        display: flex;
+        flex-direction: column;
+        gap: 4px;
+      }
+      .stacks-state.unknown {
+        border-color: var(--warn, #c99a2e);
+        border-style: solid;
+      }
+      .stacks-state.unknown b {
+        color: var(--ink);
+      }
       .stack-card {
         border: 1px solid var(--line);
         border-radius: 10px;
@@ -3134,77 +3174,22 @@
           },
           {
             type: "table",
+            id: "deploy-pipeline-stages",
             card: "Deploy pipeline stages",
-            note: "Runs when an environment branch (dev / staging / main) receives a merge",
+            note: "Live from deploy.yml + GitHub environment protection rules — never fabricated",
             cols: ["Stage", "What it does", "Active"],
             rows: [
               [
-                { t: "mono", v: "🏗️ Build & package" },
-                {
-                  t: "text",
-                  v: "Builds the artifacts for the environment mapped to the pushed branch",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "🚦 Release approval — production" },
-                {
-                  t: "text",
-                  v: "Pauses at the release_approval job until a configured reviewer approves the GitHub environment",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "🚦 Release approval — staging" },
+                { t: "mono", v: "…" },
                 {
                   t: "text",
-                  v: "Approval hold before staging deploys",
+                  v: "Loading live deploy pipeline stages…",
                 },
                 {
                   t: "status",
-                  v: false,
-                  reason: "require_approval is off for staging",
-                },
-              ],
-              [
-                { t: "mono", v: "🚀 Deploy" },
-                {
-                  t: "text",
-                  v: "Runs the stack’s deploy (EAS / Serverless / CDK / Fabric) against the target environment",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "📝 Version bump & changelog" },
-                {
-                  t: "text",
-                  v: "standard-version tags the release and pushes the chore(release) commit through the deploy key’s ruleset bypass",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "🔄 Sync-down branches" },
-                {
-                  t: "text",
-                  v: "After a promotion merges, back-merges higher environment branches into lower ones",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "🧯 Deploy auto-fix" },
-                {
-                  t: "text",
-                  v: "On a failed deploy, a Claude workflow investigates and opens a fix PR",
-                },
-                { t: "status", v: true },
-              ],
-              [
-                { t: "mono", v: "🎫 Issue on failure" },
-                {
-                  t: "text",
-                  v: "Files a tracker issue when a deploy run fails",
+                  v: "unknown",
+                  reason: "waiting for deploy-pipeline-stages probe",
                 },
-                { t: "status", v: true },
               ],
             ],
           },
@@ -3392,183 +3377,14 @@
           {
             type: "table",
             card: "Scheduled jobs",
-            note: "Status and next run are mocked \u2014 live wiring is LCW-1 (#1544). Runs on = which scheduler fires the job; the nightly agents are pipeline files, inventoried under Pipelines.",
-            cols: [
-              "Automation",
-              "What it does",
-              "Runs on",
-              "Cadence",
-              "Last run",
-              "Next run",
-              "Enabled",
-            ],
-            rows: [
-              [
-                { t: "mono", v: "intake-tickets" },
-                {
-                  t: "text",
-                  v: "Claims the next build-ready ticket and runs the full build flow on it \u2014 one item per cycle",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                {
-                  t: "select",
-                  v: "every 10 min",
-                  options: ["every 10 min", "every 30 min", "every 60 min"],
-                },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "12:50",
-                  reason: "ok \u2014 queue empty, exited clean",
-                },
-                { t: "mono", v: "13:00" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "intake-prd" },
-                {
-                  t: "text",
-                  v: "Validates the next ready PRD at the gate and either creates its work units or blocks it with clarifying questions",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                {
-                  t: "select",
-                  v: "every 60 min",
-                  options: ["every 10 min", "every 30 min", "every 60 min"],
-                },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "12:04",
-                  reason: "ok \u2014 1 PRD ticketed",
-                },
-                { t: "mono", v: "13:04" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "intake-repair" },
-                {
-                  t: "text",
-                  v: "Finds stuck work \u2014 stalled builds, half-closed items, unreconciled rollups \u2014 and repairs each one",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                {
-                  t: "select",
-                  v: "every 60 min",
-                  options: ["every 30 min", "every 60 min", "every 3 h"],
-                },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "12:04",
-                  reason: "ok \u2014 0 stuck items",
-                },
-                { t: "mono", v: "13:04" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "exploratory-bugs" },
-                {
-                  t: "text",
-                  v: "QA loop: explores the product like a first-time user (respecting the mutation policy) and files bugs build-ready",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                { t: "select", v: "daily", options: ["daily", "weekly"] },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "04:00",
-                  reason: "ok \u2014 2 bugs filed",
-                },
-                { t: "mono", v: "tomorrow 04:00" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "exploratory-prds" },
-                {
-                  t: "text",
-                  v: "Product Planning loop: ideates improvements and writes PRDs prd-ready",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                { t: "select", v: "daily", options: ["daily", "weekly"] },
-                {
-                  t: "run",
-                  ok: "warn",
-                  v: "04:15",
-                  reason: "skipped \u2014 queue pressure (1 prd-ready waiting)",
-                },
-                { t: "mono", v: "tomorrow 04:15" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "monitor" },
-                {
-                  t: "text",
-                  v: "Monitoring loop: audits the connected observability providers against the alert thresholds and files regression tickets",
-                },
-                { t: "badge", v: "harness", cls: "default" },
-                { t: "select", v: "daily", options: ["daily", "weekly"] },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "05:00",
-                  reason: "ok \u2014 1 regression filed",
-                },
-                { t: "mono", v: "tomorrow 05:00" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "nightly-test-coverage" },
-                {
-                  t: "text",
-                  v: "Raises test coverage toward the thresholds and opens a PR \u2014 one module per run",
-                },
-                { t: "badge", v: "pipeline host", cls: "default" },
-                { t: "mono", v: "03:00 Mon\u2013Fri" },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "03:00",
-                  reason: "ok \u2014 PR opened",
-                },
-                { t: "mono", v: "tomorrow 03:00" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "nightly-test-improvement" },
-                {
-                  t: "text",
-                  v: "Strengthens weak assertions in existing tests and opens a PR",
-                },
-                { t: "badge", v: "pipeline host", cls: "default" },
-                { t: "mono", v: "04:00 Mon\u2013Fri" },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "04:00",
-                  reason: "ok \u2014 PR opened",
-                },
-                { t: "mono", v: "tomorrow 04:00" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "nightly-code-complexity" },
-                {
-                  t: "text",
-                  v: "Refactors a complexity hotspot without changing behavior and opens a PR",
-                },
-                { t: "badge", v: "pipeline host", cls: "default" },
-                { t: "mono", v: "05:00 Mon\u2013Fri" },
-                {
-                  t: "run",
-                  ok: true,
-                  v: "05:00",
-                  reason: "ok \u2014 no hotspot over budget",
-                },
-                { t: "mono", v: "tomorrow 05:00" },
-                { t: "toggle", v: true },
-              ],
-            ],
+            id: "automations-scheduled-jobs",
+            note: "Live from the harness scheduler (Codex automations or Claude /schedule). Only lisa-auto-<project>-* jobs are listed. Cadence is read-only in this phase \u2014 change jobs with /lisa:setup-automations. Nightly agents are pipeline files, inventoried under Pipelines.",
+            cols: ["Automation", "Runs on", "Cadence", "Last run", "Status"],
+            rows: [],
+            empty: {
+              state: "loading",
+              message: "Loading harness scheduler\u2026",
+            },
           },
           {
             card: "Fleet controls",
@@ -3672,7 +3488,7 @@
                   t: "text",
                   v: "Error events, issue volume, release health",
                 },
-                { t: "status", v: true },
+                { t: "status", v: true, provider: "sentry" },
               ],
               [
                 { t: "mono", v: "AWS CloudWatch (Alarms)" },
@@ -3680,7 +3496,11 @@
                   t: "text",
                   v: "Alarm states, error-rate and latency metrics",
                 },
-                { t: "status", v: true },
+                {
+                  t: "status",
+                  v: true,
+                  provider: "cloudwatch-alarms",
+                },
               ],
               [
                 { t: "mono", v: "AWS X-Ray" },
@@ -3688,6 +3508,7 @@
                 {
                   t: "status",
                   v: false,
+                  provider: "x-ray",
                   reason: "no traces found — X-Ray is not instrumented",
                 },
               ],
@@ -5113,175 +4934,83 @@
       };
 
       /* ---------------------------------- Plugins ---------------------------------- */
+      /* Catalog copy only — enablement comes from the enabled-plugins probe.
+         Demo toggles are never rendered as a fallback. */
       DATA.sections.plugins = {
         title: "Plugins & MCP",
         desc: "Lisa’s own plugin set (base + one per detected stack), curated third-party plugins, and the MCP servers each one carries. Non-Claude agents receive generated equivalents of everything here.",
         src: ".claude/settings.json enabledPlugins · plugins/src/",
         blocks: [
           {
-            type: "table",
-            card: "Lisa plugins",
-            cols: ["Plugin", "Bundles", "Enabled"],
-            rows: [
-              [
-                { t: "mono", v: "lisa@lisa" },
-                {
-                  t: "text",
-                  v: "Base governance: ~145 skills, 26 agents, 12 hooks, /lisa:* commands, rules, Sentry MCP",
-                },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "lisa-typescript@lisa" },
-                {
-                  t: "text",
-                  v: "format-on-edit, lint-on-edit, ast-grep-on-edit, suppress-directive blocking",
-                },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "lisa-expo@lisa" },
-                {
-                  t: "text",
-                  v: "~40 skills (EAS, expo-router, gluestack), ops-specialist agent, Expo MCP",
-                },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "lisa-nestjs@lisa" },
-                {
-                  t: "text",
-                  v: "GraphQL/TypeORM skills, migration-edit blocking",
-                },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "lisa-phaser@lisa" },
-                { t: "text", v: "8 skills, 20 game-dev agents, Phaser rules" },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "lisa-rails@lisa" },
-                {
-                  t: "text",
-                  v: "20 skills, rubocop-on-edit, Rails conventions",
-                },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "lisa-harper-fabric@lisa" },
-                { t: "text", v: "12 skills, generated-artifact protection" },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "lisa-wiki@lisa" },
-                {
-                  t: "text",
-                  v: "In-repo LLM wiki: 22 skills, ingestion connectors (default-on for phaser only)",
-                },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "lisa-openclaw@lisa" },
-                {
-                  t: "text",
-                  v: "Telegram/Slack routing via OpenClaw (opt-in)",
-                },
-                { t: "toggle", v: false },
-              ],
-            ],
-          },
-          {
-            type: "table",
-            card: "Curated third-party plugins",
-            note: "Flip an entry to enable or disable; Lisa never touches third-party keys on re-apply",
-            cols: ["Plugin", "Purpose", "Enabled"],
-            rows: [
-              [
-                { t: "mono", v: "code-review@claude-plugins-official" },
-                { t: "text", v: "Pre-ship diff defect hunt" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "code-simplifier@claude-plugins-official" },
-                { t: "text", v: "Behavior-preserving cleanup" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "coderabbit@claude-plugins-official" },
-                { t: "text", v: "AI PR review (also a required check)" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "sentry@claude-plugins-official" },
-                { t: "text", v: "Issue debugging, Seer, instrumentation" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "safety-net@cc-marketplace" },
-                { t: "text", v: "Guardrail rulebooks" },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "typescript-lsp@claude-plugins-official" },
-                { t: "text", v: "TypeScript language server" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "playwright@claude-plugins-official" },
-                { t: "text", v: "Browser automation MCP" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "posthog@claude-plugins-official" },
-                { t: "text", v: "Product analytics" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "impeccable@impeccable" },
-                { t: "text", v: "UI design polish" },
-                { t: "toggle", v: true },
-              ],
-              [
-                { t: "mono", v: "skill-creator@claude-plugins-official" },
-                { t: "text", v: "Author and optimize skills" },
-                { t: "toggle", v: false },
-              ],
-              [
-                { t: "mono", v: "ruby-lsp@claude-plugins-official" },
-                { t: "text", v: "Ruby language server (rails stacks)" },
-                { t: "toggle", v: false },
-              ],
-            ],
+            type: "plugins-live",
+            lisaCatalog: {
+              "lisa@lisa":
+                "Base governance: ~145 skills, 26 agents, 12 hooks, /lisa:* commands, rules, Sentry MCP",
+              "lisa-typescript@lisa":
+                "format-on-edit, lint-on-edit, ast-grep-on-edit, suppress-directive blocking",
+              "lisa-expo@lisa":
+                "~40 skills (EAS, expo-router, gluestack), ops-specialist agent, Expo MCP",
+              "lisa-nestjs@lisa":
+                "GraphQL/TypeORM skills, migration-edit blocking",
+              "lisa-phaser@lisa": "8 skills, 20 game-dev agents, Phaser rules",
+              "lisa-rails@lisa":
+                "20 skills, rubocop-on-edit, Rails conventions",
+              "lisa-harper-fabric@lisa":
+                "12 skills, generated-artifact protection",
+              "lisa-wiki@lisa":
+                "In-repo LLM wiki: 22 skills, ingestion connectors (default-on for phaser only)",
+              "lisa-openclaw@lisa":
+                "Telegram/Slack routing via OpenClaw (opt-in)",
+              "lisa-cdk@lisa": "AWS CDK plugin",
+            },
+            thirdPartyCatalog: {
+              "code-review@claude-plugins-official":
+                "Pre-ship diff defect hunt",
+              "code-simplifier@claude-plugins-official":
+                "Behavior-preserving cleanup",
+              "coderabbit@claude-plugins-official":
+                "AI PR review (also a required check)",
+              "sentry@claude-plugins-official":
+                "Issue debugging, Seer, instrumentation",
+              "safety-net@cc-marketplace": "Guardrail rulebooks",
+              "typescript-lsp@claude-plugins-official":
+                "TypeScript language server",
+              "playwright@claude-plugins-official": "Browser automation MCP",
+              "posthog@claude-plugins-official": "Product analytics",
+              "impeccable@impeccable": "UI design polish",
+              "skill-creator@claude-plugins-official":
+                "Author and optimize skills",
+              "ruby-lsp@claude-plugins-official":
+                "Ruby language server (rails stacks)",
+              "atlassian@claude-plugins-official": "Jira / Confluence access",
+              "hookify@claude-plugins-official": "Custom hook authoring",
+            },
           },
           {
             type: "table",
             card: "MCP servers",
-            cols: ["Server", "Transport", "Enablement", "Enabled"],
+            note: "Catalog of MCP servers commonly carried by plugins — enablement follows the hosting plugin (read-only in this phase).",
+            cols: ["Server", "Transport", "Enablement"],
             rows: [
               [
                 { t: "mono", v: "sentry" },
                 { t: "mono", v: "http" },
                 { t: "text", v: "always-on via base plugin" },
-                { t: "toggle", v: true },
               ],
               [
                 { t: "mono", v: "expo" },
                 { t: "mono", v: "http" },
                 { t: "text", v: "on when the expo stack is detected" },
-                { t: "toggle", v: true },
               ],
               [
                 { t: "mono", v: "linear-server" },
                 { t: "mono", v: "http" },
                 { t: "text", v: "project-level .mcp.json" },
-                { t: "toggle", v: false },
               ],
               [
                 { t: "mono", v: "phaser-editor" },
                 { t: "mono", v: "stdio" },
                 { t: "text", v: "shipped disabled (disabledMcpjsonServers)" },
-                { t: "toggle", v: false },
               ],
             ],
           },
@@ -5391,6 +5120,18 @@
       const $toast = document.getElementById("toast");
       const dirty = new Set();
 
+      /* Live enabled-plugins state, hydrated from GET /api/status. Starts as
+         "loading" so the Plugins section never presents demo toggles as truth. */
+      let pluginsLive = {
+        status: "loading",
+        settingsPresent: false,
+        plugins: [],
+      };
+      /* Live detected-stacks state, hydrated from GET /api/status. Starts as
+         "detecting" so the Stacks section never presents the metadata catalog
+         as if it were the detection result. */
+      let stackDetection = { status: "detecting", ids: [] };
+
       function el(tag, cls, html) {
         const node = document.createElement(tag);
         if (cls) node.className = cls;
@@ -5599,35 +5340,116 @@
         return card;
       }
 
-      function buildTable(block) {
-        const card = el("div", "card");
-        if (block.card) {
-          const head = el("div", "card-head");
-          head.appendChild(el("h2", "", esc(block.card)));
-          if (block.note) head.appendChild(el("span", "note", esc(block.note)));
-          card.appendChild(head);
+      function paintProviderStatus(td, cell) {
+        td.innerHTML = "";
+        if (cell.v === true || cell.v === "connected") {
+          td.appendChild(el("span", "badge pass", "✓ connected"));
+          return;
         }
-        const scroll = el("div", "table-scroll");
-        const table = el("table", "grid");
-        const thead = el("thead");
-        const trh = el("tr");
-        block.cols.forEach(c => {
-          // Cols accept either a plain string or {v, tip} — tip renders as a
-          // hover tooltip on the header for jargon that needs a definition.
-          if (typeof c === "string") {
-            trh.appendChild(el("th", "", esc(c)));
-            return;
+        if (cell.v === "connected-but-empty") {
+          td.appendChild(el("span", "badge warn", "◐ connected-but-empty"));
+          if (cell.reason) {
+            td.appendChild(el("span", "status-why", esc(cell.reason)));
           }
-          const th = el("th", c.tip ? "th-help" : "", esc(c.v));
-          if (c.tip) th.title = c.tip;
-          trh.appendChild(th);
+          return;
+        }
+        if (cell.v === "pending") {
+          td.appendChild(el("span", "badge default", "checking…"));
+          return;
+        }
+        if (cell.v === "unknown") {
+          td.appendChild(el("span", "badge warn", "unknown"));
+          if (cell.reason) {
+            td.appendChild(el("span", "status-why", esc(cell.reason)));
+          }
+          return;
+        }
+        if (cell.v) {
+          td.appendChild(el("span", "badge pass", "✓ active"));
+          return;
+        }
+        td.appendChild(el("span", "badge fail", "✗ off"));
+        if (cell.reason) {
+          td.appendChild(el("span", "status-why", esc(cell.reason)));
+        }
+      }
+      function buildStatusCell(cell) {
+        const td = el("td");
+        if (cell.provider) td.dataset.provider = cell.provider;
+        if (cell.jobId) td.dataset.jobId = cell.jobId;
+        if (cell.provider) {
+          paintProviderStatus(td, cell);
+          return td;
+        }
+        if (cell.v === "unknown" || cell.v === null || cell.v === undefined) {
+          td.appendChild(el("span", "badge warn", "unknown"));
+          if (cell.reason) {
+            td.appendChild(el("span", "status-why", esc(cell.reason)));
+          }
+          return td;
+        }
+        if (cell.v) {
+          td.appendChild(el("span", "badge pass", "✓ active"));
+          return td;
+        }
+        td.appendChild(el("span", "badge fail", "✗ off"));
+        if (cell.reason) {
+          td.appendChild(el("span", "status-why", esc(cell.reason)));
+        }
+        return td;
+      }
+
+      function buildTable(block) {
+        const card = el("div", "card");
+        if (block.id) {
+          card.id = block.id;
+          card.dataset.testid = block.id;
+        }
+        if (block.card) {
+          const head = el("div", "card-head");
+          head.appendChild(el("h2", "", esc(block.card)));
+          if (block.note) head.appendChild(el("span", "note", esc(block.note)));
+          card.appendChild(head);
+        }
+        if (block.empty && (!block.rows || block.rows.length === 0)) {
+          const empty = el(
+            "div",
+            "status-why automations-empty",
+            esc(block.empty.message || "No rows")
+          );
+          empty.dataset.testid = (block.id || "table") + "-empty";
+          if (block.empty.state) empty.dataset.state = block.empty.state;
+          card.appendChild(empty);
+          return card;
+        }
+        const scroll = el("div", "table-scroll");
+        const table = el("table", "grid");
+        const thead = el("thead");
+        const trh = el("tr");
+        block.cols.forEach(c => {
+          // Cols accept either a plain string or {v, tip} — tip renders as a
+          // hover tooltip on the header for jargon that needs a definition.
+          if (typeof c === "string") {
+            trh.appendChild(el("th", "", esc(c)));
+            return;
+          }
+          const th = el("th", c.tip ? "th-help" : "", esc(c.v));
+          if (c.tip) th.title = c.tip;
+          trh.appendChild(th);
         });
         thead.appendChild(trh);
         table.appendChild(thead);
         const tbody = el("tbody");
         block.rows.forEach(cells => {
           const tr = el("tr");
+          if (cells && cells._automationId) {
+            tr.dataset.automationId = cells._automationId;
+          }
           cells.forEach(cell => {
+            if (cell.t === "status") {
+              tr.appendChild(buildStatusCell(cell));
+              return;
+            }
             const td = el("td");
             if (cell.t === "mono") td.className = "mono";
             if (cell.t === "text" || cell.t === "mono") {
@@ -5718,46 +5540,118 @@
         return card;
       }
 
-      function buildStacks(block) {
-        const grid = el("div", "stack-grid");
+      /* The 8-entry stack metadata, keyed by id. This is a catalog of what each
+         stack installs — NOT the detection result; only ids the probe reports
+         are rendered from it. */
+      function stackCatalog(block) {
+        const catalog = new Map();
         block.items.forEach(s => {
-          const card = el("div", "stack-card" + (s.on ? " on" : ""));
-          const head = el("div", "head");
-          head.appendChild(el("span", "glyph", esc(s.glyph)));
-          const t = el("div", "t");
-          t.appendChild(el("b", "", esc(s.name)));
-          t.appendChild(el("i", "", esc(s.tagline)));
-          head.appendChild(t);
-          const toggleWrap = buildControl(
-            { type: "toggle", value: s.on },
-            "stack." + s.id
+          catalog.set(s.id, s);
+        });
+        return catalog;
+      }
+
+      /* A detected id with no catalog entry still gets a card (id as name) so
+         detection truth is never dropped just because copy is missing. */
+      function minimalStackMeta(id) {
+        return {
+          id,
+          glyph: id.slice(0, 2).toUpperCase(),
+          name: id,
+          tagline: "",
+          detect: "",
+          badges: [],
+          more: [],
+        };
+      }
+
+      function stackCard(s) {
+        const card = el("div", "stack-card on");
+        const head = el("div", "head");
+        head.appendChild(el("span", "glyph", esc(s.glyph)));
+        const t = el("div", "t");
+        t.appendChild(el("b", "", esc(s.name)));
+        t.appendChild(el("i", "", esc(s.tagline)));
+        head.appendChild(t);
+        const toggleWrap = buildControl(
+          { type: "toggle", value: true },
+          "stack." + s.id
+        );
+        toggleWrap.querySelector("input").addEventListener("change", e => {
+          card.classList.toggle("on", e.target.checked);
+          markDirty("stack." + s.id, null);
+        });
+        head.appendChild(toggleWrap);
+        card.appendChild(head);
+        const meta = el("div", "meta");
+        (s.badges || []).forEach(b =>
+          meta.appendChild(el("span", "tag", esc(b)))
+        );
+        card.appendChild(meta);
+        card.appendChild(el("div", "detect", s.detect || ""));
+        if (s.more && s.more.length) {
+          const det = el("details", "stack-more");
+          det.appendChild(el("summary", "", "What this stack installs"));
+          const ul = el("ul");
+          s.more.forEach(m => ul.appendChild(el("li", "", esc(m))));
+          det.appendChild(ul);
+          card.appendChild(det);
+        }
+        return card;
+      }
+
+      function renderStacksInto(wrap, block) {
+        wrap.innerHTML = "";
+        const d = stackDetection;
+        if (d.status === "detecting") {
+          wrap.appendChild(
+            el("div", "stacks-state detecting", "Detecting project stacks…")
           );
-          toggleWrap.querySelector("input").addEventListener("change", e => {
-            card.classList.toggle("on", e.target.checked);
-            markDirty("stack." + s.id, null);
-          });
-          head.appendChild(toggleWrap);
-          card.appendChild(head);
-          const meta = el("div", "meta");
-          s.badges.forEach(b => meta.appendChild(el("span", "tag", esc(b))));
-          card.appendChild(meta);
-          card.appendChild(el("div", "detect", s.detect));
-          if (s.more && s.more.length) {
-            const det = el("details", "stack-more");
-            det.appendChild(el("summary", "", "What this stack installs"));
-            const ul = el("ul");
-            s.more.forEach(m => ul.appendChild(el("li", "", esc(m))));
-            det.appendChild(ul);
-            card.appendChild(det);
-          }
-          grid.appendChild(card);
+          return;
+        }
+        if (d.status === "unknown") {
+          const box = el("div", "stacks-state unknown");
+          box.appendChild(el("b", "", "Stack detection unavailable"));
+          box.appendChild(
+            el("span", "status-why", esc(d.reason + ": " + d.message))
+          );
+          wrap.appendChild(box);
+          return;
+        }
+        if (!d.ids || d.ids.length === 0) {
+          wrap.appendChild(
+            el(
+              "div",
+              "stacks-state empty",
+              "No Lisa stack detected in this project."
+            )
+          );
+          return;
+        }
+        const catalog = stackCatalog(block);
+        const grid = el("div", "stack-grid");
+        d.ids.forEach(id => {
+          grid.appendChild(stackCard(catalog.get(id) || minimalStackMeta(id)));
         });
-        const wrap = el("div");
         wrap.appendChild(grid);
         wrap.appendChild(el("div", "", "&nbsp;"));
+      }
+
+      function buildStacks(block) {
+        const wrap = el("div", "stacks-block");
+        renderStacksInto(wrap, block);
         return wrap;
       }
 
+      /* Re-render the Stacks section in place after detection hydrates. */
+      function refreshStacks() {
+        const block = DATA.sections.stacks.blocks.find(
+          b => b.type === "stacks"
+        );
+        const wrap = document.querySelector(".stacks-block");
+        if (block && wrap) renderStacksInto(wrap, block);
+      }
+
       function buildHooks(block) {
         const grid = el("div", "hooks-grid");
         block.items.forEach(h => {
@@ -5897,6 +5791,131 @@
         return card;
       }
 
+      function pluginDescription(id, probeDescription, catalog) {
+        if (Object.hasOwn(catalog, id) && typeof catalog[id] === "string") {
+          return catalog[id];
+        }
+        return typeof probeDescription === "string" ? probeDescription : "";
+      }
+
+      function pluginTableRows(entries, catalog) {
+        return entries.map(plugin => {
+          const enabled = plugin.status === "enabled";
+          return [
+            { t: "mono", v: plugin.id },
+            {
+              t: "text",
+              v: pluginDescription(plugin.id, plugin.description, catalog),
+            },
+            {
+              t: "badge",
+              v: enabled ? "enabled" : "available, not enabled",
+              cls: enabled ? "on" : "plugin-status-badge available",
+            },
+          ];
+        });
+      }
+
+      function renderPluginsInto(wrap, block) {
+        wrap.innerHTML = "";
+        const state = pluginsLive;
+        if (state.status === "loading") {
+          wrap.appendChild(
+            el("div", "plugins-state loading", "Loading plugin enablement…")
+          );
+          return;
+        }
+        if (state.status === "unknown") {
+          const box = el("div", "plugins-state unknown");
+          box.appendChild(el("b", "", "Plugin enablement unavailable"));
+          box.appendChild(
+            el(
+              "span",
+              "status-why",
+              esc((state.reason || "unknown") + ": " + (state.message || ""))
+            )
+          );
+          wrap.appendChild(box);
+          return;
+        }
+        if (!state.settingsPresent) {
+          wrap.appendChild(
+            el(
+              "div",
+              "plugins-state empty",
+              "No .claude/settings.json in this project — plugin enablement is not configured."
+            )
+          );
+          return;
+        }
+        const plugins = Array.isArray(state.plugins) ? state.plugins : [];
+        const lisaCatalog =
+          block.lisaCatalog && typeof block.lisaCatalog === "object"
+            ? block.lisaCatalog
+            : {};
+        const thirdPartyCatalog =
+          block.thirdPartyCatalog && typeof block.thirdPartyCatalog === "object"
+            ? block.thirdPartyCatalog
+            : {};
+        const lisa = [];
+        const thirdParty = [];
+        plugins.forEach(plugin => {
+          if (!plugin || typeof plugin !== "object") return;
+          const id = plugin.id;
+          if (typeof id !== "string" || id.trim().length === 0) return;
+          if (id.endsWith("@lisa") || Object.hasOwn(lisaCatalog, id)) {
+            lisa.push(plugin);
+          } else {
+            thirdParty.push(plugin);
+          }
+        });
+        if (lisa.length === 0 && thirdParty.length === 0) {
+          wrap.appendChild(
+            el(
+              "div",
+              "plugins-state empty",
+              "No plugins enabled or available in the marketplace catalog."
+            )
+          );
+          return;
+        }
+        if (lisa.length > 0) {
+          wrap.appendChild(
+            buildTable({
+              type: "table",
+              card: "Lisa plugins",
+              cols: ["Plugin", "Bundles", "Status"],
+              rows: pluginTableRows(lisa, lisaCatalog),
+            })
+          );
+        }
+        if (thirdParty.length > 0) {
+          wrap.appendChild(
+            buildTable({
+              type: "table",
+              card: "Third-party plugins",
+              note: "Read-only: enablement comes from .claude/settings.json enabledPlugins",
+              cols: ["Plugin", "Purpose", "Status"],
+              rows: pluginTableRows(thirdParty, thirdPartyCatalog),
+            })
+          );
+        }
+      }
+
+      function buildPluginsLive(block) {
+        const wrap = el("div", "plugins-live-block");
+        renderPluginsInto(wrap, block);
+        return wrap;
+      }
+
+      function refreshPlugins() {
+        const block = DATA.sections.plugins.blocks.find(
+          b => b.type === "plugins-live"
+        );
+        const wrap = document.querySelector(".plugins-live-block");
+        if (block && wrap) renderPluginsInto(wrap, block);
+      }
+
       function buildBlock(block) {
         if (block.type === "tiles") return buildTiles(block);
         if (block.type === "flow") return buildFlow(block);
@@ -5906,6 +5925,7 @@
         if (block.type === "table") return buildTable(block);
         if (block.type === "tabs") return buildTabs(block);
         if (block.type === "checklist") return buildChecklist(block);
+        if (block.type === "plugins-live") return buildPluginsLive(block);
         return buildCard(block);
       }
 
@@ -6097,6 +6117,7 @@
               if (value !== undefined) hydrateControl(row.control, value);
             });
           });
+          markObservabilityProvidersPending();
         }
         configureRemoteEnvironment(cfg);
         const repoEl = document.querySelector(".project-switch .repo");
@@ -6156,6 +6177,115 @@
         }
         return snapshot.probes;
       }
+      function connectedProvidersBlock() {
+        const blocks = DATA.sections.monitor && DATA.sections.monitor.blocks;
+        if (!Array.isArray(blocks)) return null;
+        return (
+          blocks.find(
+            block =>
+              block &&
+              block.type === "table" &&
+              block.card === "Connected providers"
+          ) || null
+        );
+      }
+      function setProviderStatusCell(provider, cell) {
+        const block = connectedProvidersBlock();
+        if (!block || !Array.isArray(block.rows)) return;
+        block.rows.forEach(row => {
+          if (!Array.isArray(row)) return;
+          row.forEach((entry, index) => {
+            if (entry && entry.t === "status" && entry.provider === provider) {
+              row[index] = cell;
+            }
+          });
+        });
+        const td = document.querySelector(
+          'td[data-provider="' + provider + '"]'
+        );
+        if (td) paintProviderStatus(td, cell);
+      }
+      function markObservabilityProvidersPending() {
+        ["sentry", "cloudwatch-alarms", "x-ray"].forEach(provider => {
+          setProviderStatusCell(provider, {
+            t: "status",
+            v: "pending",
+            provider,
+          });
+        });
+      }
+      /**
+       * Paint Connected providers from sentry / cloudwatch-alarms / x-ray probes.
+       * unknown ≠ disconnected — never invent an unevidenced "off" claim.
+       * @param probes - Live-status probe map from /api/status
+       */
+      function applyObservabilityProviders(probes) {
+        const specs = [
+          {
+            id: "sentry",
+            emptyReason: "reachable — no Sentry data observed",
+          },
+          {
+            id: "cloudwatch-alarms",
+            emptyReason: "connected — no alarms",
+          },
+          {
+            id: "x-ray",
+            emptyReason: "connected — no traces",
+          },
+        ];
+        specs.forEach(spec => {
+          const raw =
+            probes && Object.hasOwn(probes, spec.id)
+              ? probes[spec.id]
+              : undefined;
+          const result =
+            raw === undefined
+              ? {
+                  state: "unknown",
+                  reason: "missing-probe",
+                  message: "The " + spec.id + " probe was not reported",
+                }
+              : normalizeLiveStatusResult(raw);
+          if (
+            result.state === "value" &&
+            result.value &&
+            typeof result.value === "object" &&
+            result.value.status === "connected"
+          ) {
+            setProviderStatusCell(spec.id, {
+              t: "status",
+              v: "connected",
+              provider: spec.id,
+            });
+            return;
+          }
+          if (
+            result.state === "value" &&
+            result.value &&
+            typeof result.value === "object" &&
+            result.value.status === "connected-but-empty"
+          ) {
+            setProviderStatusCell(spec.id, {
+              t: "status",
+              v: "connected-but-empty",
+              provider: spec.id,
+              reason: spec.emptyReason,
+            });
+            return;
+          }
+          const reason =
+            result.state === "unknown"
+              ? result.reason + ": " + result.message
+              : "invalid-value: provider probe returned an unusable value";
+          setProviderStatusCell(spec.id, {
+            t: "status",
+            v: "unknown",
+            provider: spec.id,
+            reason,
+          });
+        });
+      }
       function renderLiveStatuses(probes) {
         const list = document.getElementById("liveStatusList");
         list.innerHTML = "";
@@ -6190,6 +6320,101 @@
           list.appendChild(item);
         });
       }
+      /**
+       * Map the enabled-plugins probe into pluginsLive. A missing probe or an
+       * unusable value becomes an explicit unknown state — never demo toggles.
+       * @param probes - Live-status probe map from /api/status
+       */
+      function applyEnabledPlugins(probes) {
+        const raw =
+          probes && Object.hasOwn(probes, "enabled-plugins")
+            ? probes["enabled-plugins"]
+            : undefined;
+        if (raw === undefined) {
+          pluginsLive = {
+            status: "unknown",
+            settingsPresent: false,
+            plugins: [],
+            reason: "missing-probe",
+            message: "The enabled-plugins probe was not reported",
+          };
+          refreshPlugins();
+          return;
+        }
+        const result = normalizeLiveStatusResult(raw);
+        if (
+          result.state === "value" &&
+          result.value &&
+          typeof result.value === "object"
+        ) {
+          const settingsPresent = result.value.settingsPresent === true;
+          const plugins = result.value.plugins;
+          if (!Array.isArray(plugins)) {
+            pluginsLive = {
+              status: "unknown",
+              settingsPresent: false,
+              plugins: [],
+              reason: "invalid-value",
+              message: "enabled-plugins did not return a plugins array",
+            };
+          } else {
+            const rows = [];
+            let invalid = false;
+            for (const entry of plugins) {
+              if (
+                !entry ||
+                typeof entry !== "object" ||
+                typeof entry.id !== "string" ||
+                entry.id.trim().length === 0 ||
+                (entry.status !== "enabled" && entry.status !== "available")
+              ) {
+                invalid = true;
+                break;
+              }
+              rows.push({
+                id: entry.id,
+                status: entry.status,
+                description:
+                  typeof entry.description === "string"
+                    ? entry.description
+                    : "",
+              });
+            }
+            if (invalid) {
+              pluginsLive = {
+                status: "unknown",
+                settingsPresent: false,
+                plugins: [],
+                reason: "invalid-value",
+                message: "enabled-plugins returned an unusable plugin row",
+              };
+            } else {
+              pluginsLive = {
+                status: "value",
+                settingsPresent,
+                plugins: rows,
+              };
+            }
+          }
+        } else if (result.state === "not-applicable") {
+          pluginsLive = {
+            status: "unknown",
+            settingsPresent: false,
+            plugins: [],
+            reason: "not-applicable",
+            message: "enabled-plugins reported not applicable",
+          };
+        } else {
+          pluginsLive = {
+            status: "unknown",
+            settingsPresent: false,
+            plugins: [],
+            reason: result.reason || "unknown",
+            message: result.message || "Plugin enablement unavailable",
+          };
+        }
+        refreshPlugins();
+      }
       /**
        * Paint `#healthChip` from the lisa-version probe.
        * green=ok (up to date), amber=warn (behind), unknown≠ok.
@@ -6309,6 +6534,413 @@
         renderAll();
         showSection(current);
       }
+      function githubRepoHostBlock() {
+        return {
+          card: "Host",
+          rows: [
+            {
+              key: "",
+              label: "Git host",
+              desc: "Which host this repository lives on. GitHub is the only host Lisa provisions today.",
+              control: sel("GitHub", ["GitHub", "GitLab", "Bitbucket"]),
+            },
+          ],
+        };
+      }
+      function githubRepoSettingsRows(settings) {
+        return [
+          {
+            label: "Allow merge commits",
+            desc: "The fleet is merge-only — squash and rebase are disabled because squashing flattens release commits and breaks promotion.",
+            control: tog(!!settings.allow_merge_commit),
+          },
+          {
+            label: "Allow squash merge",
+            desc: "",
+            control: tog(!!settings.allow_squash_merge),
+          },
+          {
+            label: "Allow rebase merge",
+            desc: "",
+            control: tog(!!settings.allow_rebase_merge),
+          },
+          {
+            label: "Auto-merge",
+            desc: "Lisa PRs enable auto-merge and drive themselves to green.",
+            control: tog(!!settings.allow_auto_merge),
+          },
+          {
+            label: "Suggest updating PR branches",
+            desc: "",
+            control: tog(!!settings.allow_update_branch),
+          },
+          {
+            label: "Delete head branch on merge",
+            desc: "Environment branches survive via the prevent-delete ruleset.",
+            control: tog(!!settings.delete_branch_on_merge),
+          },
+          {
+            label: "Merge commit title",
+            desc: "",
+            control: sel(String(settings.merge_commit_title || ""), [
+              "MERGE_MESSAGE",
+              "PR_TITLE",
+            ]),
+          },
+          {
+            label: "Issues tab",
+            desc: "",
+            control: tog(!!settings.has_issues),
+          },
+          {
+            label: "Wiki tab",
+            desc: "Off — Lisa uses the in-repo wiki/ directory instead.",
+            control: tog(!!settings.has_wiki),
+          },
+          {
+            label: "Secret scanning + push protection",
+            desc: "Best-effort; skipped when the plan lacks GitHub Advanced Security.",
+            control: tog(!!settings.secret_scanning),
+          },
+          {
+            label: "Default branch",
+            desc: "Live default branch from the repository.",
+            control: txt(String(settings.default_branch || ""), {
+              mono: true,
+            }),
+          },
+        ];
+      }
+      function applyGithubRepoPanel(result) {
+        const host = githubRepoHostBlock();
+        if (result.state !== "value") {
+          const reason =
+            result.state === "unknown"
+              ? result.reason + ": " + result.message
+              : "not applicable";
+          DATA.sections.repository.blocks = [
+            host,
+            {
+              type: "callout",
+              variant: "warn",
+              text:
+                "<b>unknown — not authenticated / unavailable</b> — " +
+                esc(reason) +
+                ". No setting, ruleset, label, or secret state is shown as a concrete value.",
+            },
+          ];
+          return;
+        }
+        const value = result.value || {};
+        const settings = value.settings || {};
+        const rulesets = Array.isArray(value.rulesets) ? value.rulesets : [];
+        const labels = Array.isArray(value.labels) ? value.labels : [];
+        const secrets = Array.isArray(value.secrets) ? value.secrets : [];
+        DATA.sections.repository.blocks = [
+          host,
+          {
+            card: "Repository settings",
+            note:
+              "Live from gh api repos/" +
+              String(value.owner || "") +
+              "/" +
+              String(value.repo || ""),
+            rows: githubRepoSettingsRows(settings),
+          },
+          {
+            type: "table",
+            card: "Rulesets",
+            note: "Live from gh api repos/{owner}/{repo}/rulesets",
+            cols: ["Ruleset", "Applies to", "Enforces", "Active"],
+            rows: rulesets.map(row => [
+              { t: "mono", v: String(row.name || "") },
+              { t: "text", v: String(row.appliesTo || "—") },
+              { t: "text", v: String(row.enforces || "—") },
+              {
+                t: "badge",
+                v: row.active ? "active" : "disabled",
+                cls: row.active ? "on" : "off",
+              },
+            ]),
+          },
+          {
+            type: "table",
+            card: "Lifecycle labels",
+            note: "Config-expected labels vs live gh label list",
+            cols: ["Label", "Role", "Color", "Status"],
+            rows: labels.map(row => [
+              { t: "mono", v: String(row.name || "") },
+              { t: "text", v: String(row.role || "") },
+              row.present && row.color
+                ? {
+                    t: "color",
+                    v: "#" + String(row.color).replace(/^#/u, ""),
+                  }
+                : { t: "text", v: "—" },
+              {
+                t: "badge",
+                v: row.present ? "present" : "missing",
+                cls: row.present ? "on" : "off",
+              },
+            ]),
+          },
+          {
+            type: "table",
+            card: "Secrets",
+            note: "Presence only from gh secret list — values are never read",
+            cols: ["Secret", "Purpose", "Status"],
+            rows: secrets.map(row => [
+              { t: "mono", v: String(row.name || "") },
+              { t: "text", v: String(row.purpose || "") },
+              {
+                t: "badge",
+                v: row.set ? "set" : "missing",
+                cls: row.set ? "on" : "off",
+              },
+            ]),
+          },
+        ];
+      }
+      function reRenderAfterGithubRepoHydration() {
+        const current = activeSection;
+        renderAll();
+        showSection(current || "overview");
+      }
+      /**
+       * Replace the Deploy pipeline stages table from the live probe.
+       * Never leaves demo hold/no-hold claims in place.
+       * @param probes - Live-status probe map from /api/status
+       */
+      function applyDeployPipelineStages(probes) {
+        const section = DATA.sections.deploy;
+        if (!section || !Array.isArray(section.blocks)) return;
+        const block = section.blocks.find(
+          candidate =>
+            candidate &&
+            candidate.type === "table" &&
+            candidate.id === "deploy-pipeline-stages"
+        );
+        if (!block) return;
+        const raw =
+          probes && Object.hasOwn(probes, "deploy-pipeline-stages")
+            ? probes["deploy-pipeline-stages"]
+            : undefined;
+        const result =
+          raw === undefined
+            ? {
+                state: "unknown",
+                reason: "missing-probe",
+                message: "The deploy-pipeline-stages probe was not reported",
+              }
+            : normalizeLiveStatusResult(raw);
+        if (result.state === "not-applicable") {
+          block.rows = [
+            [
+              { t: "mono", v: "—" },
+              {
+                t: "text",
+                v: "No deploy.yml or github.environments configured for this project",
+              },
+              { t: "status", v: "unknown", reason: "not-applicable" },
+            ],
+          ];
+        } else if (
+          result.state === "value" &&
+          result.value &&
+          typeof result.value === "object" &&
+          Array.isArray(result.value.stages)
+        ) {
+          block.rows = result.value.stages.map(stage => [
+            {
+              t: "mono",
+              v: String(stage.name || stage.id || "stage"),
+            },
+            {
+              t: "text",
+              v: String(stage.description || ""),
+            },
+            {
+              t: "status",
+              v: stage.active === "unknown" ? "unknown" : stage.active === true,
+              reason:
+                typeof stage.reason === "string" && stage.reason.length > 0
+                  ? stage.reason
+                  : undefined,
+            },
+          ]);
+          if (block.rows.length === 0) {
+            block.rows = [
+              [
+                { t: "mono", v: "—" },
+                { t: "text", v: "Deploy pipeline reported zero stages" },
+                {
+                  t: "status",
+                  v: "unknown",
+                  reason: "empty-stages",
+                },
+              ],
+            ];
+          }
+        } else {
+          const reason =
+            result.state === "unknown"
+              ? result.reason + ": " + result.message
+              : "invalid-value: deploy-pipeline-stages probe returned an unusable value";
+          block.rows = [
+            [
+              { t: "mono", v: "—" },
+              {
+                t: "text",
+                v: "Deploy pipeline stages unavailable",
+              },
+              { t: "status", v: "unknown", reason: reason },
+            ],
+          ];
+        }
+        const existing = document.getElementById("deploy-pipeline-stages");
+        if (existing) {
+          existing.replaceWith(buildTable(block));
+        }
+      }
+      /* Map the detected-stacks probe into stackDetection. A missing probe or a
+         non-value/non-array result becomes an explicit unknown state — never a
+         false empty and never the metadata catalog. */
+      function applyDetectedStacks(probes) {
+        const raw =
+          probes && Object.hasOwn(probes, "detected-stacks")
+            ? probes["detected-stacks"]
+            : undefined;
+        if (raw === undefined) {
+          stackDetection = {
+            status: "unknown",
+            ids: [],
+            reason: "missing-probe",
+            message: "The detected-stacks probe was not reported",
+          };
+          refreshStacks();
+          return;
+        }
+        const result = normalizeLiveStatusResult(raw);
+        if (result.state === "value" && Array.isArray(result.value)) {
+          const ids = result.value.filter(v => typeof v === "string");
+          if (ids.length !== result.value.length) {
+            // Any non-string element makes the whole array untrustworthy;
+            // an empty state here would fabricate a "no stacks" certainty.
+            stackDetection = {
+              status: "unknown",
+              ids: [],
+              reason: "invalid-value",
+              message: "detected-stacks did not return a string array",
+            };
+          } else {
+            stackDetection =
+              ids.length > 0
+                ? { status: "value", ids }
+                : { status: "empty", ids: [] };
+          }
+        } else if (result.state === "value") {
+          stackDetection = {
+            status: "unknown",
+            ids: [],
+            reason: "invalid-value",
+            message: "detected-stacks did not return a string array",
+          };
+        } else if (result.state === "not-applicable") {
+          stackDetection = {
+            status: "unknown",
+            ids: [],
+            reason: "not-applicable",
+            message: "detected-stacks reported not applicable",
+          };
+        } else {
+          stackDetection = {
+            status: "unknown",
+            ids: [],
+            reason: result.reason,
+            message: result.message,
+          };
+        }
+        refreshStacks();
+      }
+      function markStacksUnreachable(error) {
+        stackDetection = {
+          status: "unknown",
+          ids: [],
+          reason: "status-unavailable",
+          message: error instanceof Error ? error.message : String(error),
+        };
+        refreshStacks();
+      }
+      function automationsScheduledJobsBlock() {
+        const blocks =
+          (DATA.sections.automations && DATA.sections.automations.blocks) || [];
+        return blocks.find(block => block.id === "automations-scheduled-jobs");
+      }
+      function automationRowFromProbe(entry) {
+        const cadence =
+          typeof entry.cadence === "string" && entry.cadence.trim().length > 0
+            ? entry.cadence
+            : "unknown";
+        const lastRun =
+          typeof entry.lastRunAt === "string" &&
+          entry.lastRunAt.trim().length > 0
+            ? entry.lastRunAt
+            : "—";
+        const status =
+          typeof entry.status === "string" && entry.status.trim().length > 0
+            ? entry.status
+            : "unknown";
+        const runtime =
+          entry.runtime === "claude" ? "claude /schedule" : "codex";
+        const row = [
+          { t: "mono", v: entry.id },
+          { t: "badge", v: runtime, cls: "default" },
+          { t: "mono", v: cadence },
+          { t: "mono", v: lastRun },
+          {
+            t: "badge",
+            v: status,
+            cls: status.toUpperCase() === "ACTIVE" ? "pass" : "default",
+          },
+        ];
+        row._automationId = entry.id;
+        return row;
+      }
+      function hydrateAutomationsSection(probeResult) {
+        const block = automationsScheduledJobsBlock();
+        if (!block) return;
+        const result = normalizeLiveStatusResult(probeResult);
+        if (result.state === "value") {
+          const automations = Array.isArray(result.value.automations)
+            ? result.value.automations
+            : [];
+          block.rows = automations.map(automationRowFromProbe);
+          if (block.rows.length === 0) {
+            block.empty = {
+              state: "empty",
+              message:
+                "No lisa-auto-<project>- automations found in the harness scheduler",
+            };
+          } else {
+            delete block.empty;
+          }
+        } else if (result.state === "not-applicable") {
+          block.rows = [];
+          block.empty = {
+            state: "not-applicable",
+            message: "Automations are not applicable on this machine",
+          };
+        } else {
+          block.rows = [];
+          block.empty = {
+            state: "unknown",
+            message: result.reason + ": " + result.message,
+          };
+        }
+        renderAll();
+        showSection(activeSection);
+      }
+
       async function hydrateLiveStatuses() {
         try {
           const response = await fetch("/api/status", {
@@ -6318,9 +6950,29 @@
           const snapshot = await response.json();
           const probes = liveStatusProbeMap(snapshot);
           renderLiveStatuses(probes);
-          // Quality jobs re-renders the page; paint the version chip after.
+          applyEnabledPlugins(probes);
+          applyDetectedStacks(probes);
+          // Quality jobs / automations re-render the page; paint the version chip after.
           applyCiQualityJobs(probes);
+          hydrateAutomationsSection(
+            probes.automations || {
+              state: "unknown",
+              reason: "probe-missing",
+              message: "Automations probe was omitted from /api/status",
+            }
+          );
           applyLisaVersion(probes);
+          const repoResult = normalizeLiveStatusResult(
+            probes["github-repo"] || {
+              state: "unknown",
+              reason: "probe-missing",
+              message: "GitHub repository probe did not run",
+            }
+          );
+          applyGithubRepoPanel(repoResult);
+          reRenderAfterGithubRepoHydration();
+          applyDeployPipelineStages(probes);
+          applyObservabilityProviders(probes);
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
@@ -6330,8 +6982,21 @@
             message,
           };
           renderLiveStatuses({ transport: unavailable });
+          applyEnabledPlugins({ "enabled-plugins": unavailable });
           applyCiQualityJobs({ "ci-quality-jobs": unavailable });
+          hydrateAutomationsSection(unavailable);
           applyLisaVersion({ "lisa-version": unavailable });
+          applyGithubRepoPanel(unavailable);
+          reRenderAfterGithubRepoHydration();
+          applyDeployPipelineStages({
+            "deploy-pipeline-stages": unavailable,
+          });
+          applyObservabilityProviders({
+            sentry: unavailable,
+            "cloudwatch-alarms": unavailable,
+            "x-ray": unavailable,
+          });
+          markStacksUnreachable(error);
         }
       }