feat(layout): plan 03 — frontend plugin ABI + handshake + load lifecycle

3 files changed, 106 insertions, 1 deletions

diff --git a/src/features/plugins/logic/types.ts b/src/features/plugins/logic/types.ts
index 702483b..d5fa4bb 100644
--- a/src/features/plugins/logic/types.ts
+++ b/src/features/plugins/logic/types.ts
@@ -25,6 +25,13 @@ export interface PluginNode {
   readonly dependsOn: readonly string[];
   /** Why the plugin is not loaded (disabled-with-reason) or gone (missing). */
   readonly reason: string | null;
+  /**
+   * The frontend-plugin (plan 03) issue line for the manager row, when the
+   * plugin's FE half is incompatible ("incompatible frontend plugin") or
+   * failed (`frontend failed: <error>`). Absent = the FE half is fine (or
+   * the plugin declares no frontend section).
+   */
+  readonly frontendIssue?: string;
   readonly section: PluginSection;
 }
 
diff --git a/src/features/plugins/logic/view-model.test.ts b/src/features/plugins/logic/view-model.test.ts
index 680ba94..661cade 100644
--- a/src/features/plugins/logic/view-model.test.ts
+++ b/src/features/plugins/logic/view-model.test.ts
@@ -1,7 +1,7 @@
 import type { PluginListResponse, PluginTier } from "@dispatch/transport-contract";
 import { describe, expect, it } from "vitest";
 import { emptyListResponse, node } from "./test-fixtures";
-import { groupByTier, pluginNodes, splitSections } from "./view-model";
+import { groupByTier, pluginNodes, splitSections, withFrontendStates } from "./view-model";
 
 function listResponse(overrides: Partial<PluginListResponse> = {}): PluginListResponse {
   return {
@@ -225,3 +225,72 @@ describe("splitSections", () => {
     expect(sections.missing.map((n) => n.id)).toEqual(["gone"]);
   });
 });
+
+// ── withFrontendStates (plan 03) — the manager rows' FE-half issues ─────────
+
+describe("withFrontendStates", () => {
+  function listWith(...ids: readonly string[]): PluginListResponse {
+    return {
+      loaded: ids.map((id) => ({
+        id,
+        name: id,
+        version: "1.0.0",
+        tier: "standard" as const,
+        trust: "local" as const,
+        locked: false,
+        dependsOn: [],
+      })),
+      disabledWithReason: [],
+      discovered: [],
+      missing: [],
+    };
+  }
+
+  it("renders the plan-mandated grammar for an incompatible FE half", () => {
+    const nodes = pluginNodes(listWith("bad"));
+    const states = new Map([["bad", { kind: "incompatible", apiVersion: "^2" } as const]]);
+    const out = withFrontendStates(nodes, states);
+    expect(out[0]?.frontendIssue).toBe("incompatible frontend plugin");
+  });
+
+  it("renders the activation error for a failed FE half", () => {
+    const nodes = pluginNodes(listWith("broken"));
+    const states = new Map([["broken", { kind: "failed", error: "boom" } as const]]);
+    const out = withFrontendStates(nodes, states);
+    expect(out[0]?.frontendIssue).toBe("frontend failed: boom");
+  });
+
+  it("a loaded FE half adds no issue line; absent states add none", () => {
+    const nodes = pluginNodes(listWith("ok", "no-fe"));
+    const states = new Map([["ok", { kind: "loaded" } as const]]);
+    const out = withFrontendStates(nodes, states);
+    expect(out.find((n) => n.id === "ok")?.frontendIssue).toBeUndefined();
+    expect(out.find((n) => n.id === "no-fe")?.frontendIssue).toBeUndefined();
+  });
+
+  it("never annotates non-loaded sections (discovered / missing rows)", () => {
+    const response: PluginListResponse = {
+      loaded: [],
+      disabledWithReason: [],
+      discovered: [
+        {
+          id: "dis",
+          name: "dis",
+          version: "1.0.0",
+          tier: "standard",
+          trust: "local",
+          dir: "/plugins/dis",
+        },
+      ],
+      missing: [],
+    };
+    const states = new Map([["dis", { kind: "failed", error: "boom" } as const]]);
+    const out = withFrontendStates(pluginNodes(response), states);
+    expect(out[0]?.frontendIssue).toBeUndefined();
+  });
+
+  it("an empty state map is the identity (no allocation on the hot path)", () => {
+    const nodes = pluginNodes(listWith("a"));
+    expect(withFrontendStates(nodes, new Map())).toBe(nodes);
+  });
+});
diff --git a/src/features/plugins/logic/view-model.ts b/src/features/plugins/logic/view-model.ts
index 20d7d68..5a66ffa 100644
--- a/src/features/plugins/logic/view-model.ts
+++ b/src/features/plugins/logic/view-model.ts
@@ -1,4 +1,5 @@
 import type { PluginListResponse } from "@dispatch/transport-contract";
+import type { FrontendPluginState } from "../../../core/plugin-abi";
 import { normalizeTier, type PluginNode, type PluginSection, TIER_ORDER } from "./types";
 
 /**
@@ -79,6 +80,34 @@ export function pluginNodes(response: PluginListResponse): readonly PluginNode[]
 }
 
 /**
+ * Merge the frontend-plugin (plan 03) per-plugin FE states into the node
+ * list — the manager rows' `frontendIssue` line. Pure input → output:
+ * - `incompatible` → the plan-mandated "incompatible frontend plugin"
+ *   grammar (the backend apiVersion-mismatch wording, FE half);
+ * - `failed` → the activation error (the FE half failed; the backend half
+ *   stays loaded).
+ * Loaded rows only — the FE states never apply to discovered/missing rows.
+ */
+export function withFrontendStates(
+  nodes: readonly PluginNode[],
+  states: ReadonlyMap<string, FrontendPluginState>,
+): readonly PluginNode[] {
+  if (states.size === 0) return nodes;
+  return nodes.map((node) => {
+    if (node.section !== "loaded") return node;
+    const state = states.get(node.id);
+    if (state === undefined) return node;
+    const issue =
+      state.kind === "incompatible"
+        ? "incompatible frontend plugin"
+        : state.kind === "failed"
+          ? `frontend failed: ${state.error}`
+          : null;
+    return issue === null ? node : { ...node, frontendIssue: issue };
+  });
+}
+
+/**
  * Cluster nodes for one manager table: tier groups in display order (Core →
  * Providers → Standard), each tier's rows sorted by id. Tiers with no rows
  * are omitted. Used by the loaded table's tier grouping (plan 07 §7.2).