Add rows layout toggle and C Protocol candidate data model

Circular/Rows layout toggle in the pipeline workspace (layered
top-down DAG as an alternative to the radial view). Added the C
Protocol (Code, Claim, Consensus, Cost, Connectivity, each 0-1, Code
gates the tier below 0.3) as the candidate-repo scoring model,
seeded with real GitHub data for the Avatar node's six candidates.
First worked-example report (Avatar) written to docs/reports/.

docs/reports/avatar.md

@@ -0,0 +1,121 @@
+# Node Report: Avatar (Talking-Head Generation)
+
+**Pipeline:** Beryl — Live Conversational Avatar
+**Category:** avatar (face/body synthesis — lip sync, expression, head motion)
+**Report generated:** 2026-07-13
+**Auditor:** Samantha (LAYER pipeline-audit rubric, 5 failure modes)
+**Status:** Tier B — see §5
+
+---
+
+## 1. Abstract
+
+The Avatar node converts a driving audio signal and a static reference image into
+a photorealistic video stream of a talking human. It is the node where two of the
+rubric's five failure modes — the Uncanny Valley and the End-of-Speech Pop —
+originate, and consequently the node that decides whether the finished pipeline
+reads as "alive" or "off." This report surveys six candidate implementations
+under the **C Protocol** — Code, Claim, Consensus, Cost, Connectivity, each
+scored 0–1 and rendered live as stars as each is verified — and separately
+audits the currently-selected implementation, LivePortrait via
+FasterLivePortrait, against the five documented failure modes.
+
+## 2. Background
+
+Talking-head generation (THG) research since 2023 has split into two lineages:
+
+- **Warping/GAN-based** (LivePortrait and its derivatives): a reference-image
+  keypoint-warping approach. Cheap, real-time capable, moderate photorealism
+  ceiling.
+- **Diffusion-based** (EchoMimic, Hallo, JoyVASA): higher photorealism ceiling,
+  substantially higher per-frame compute cost, generally not real-time without
+  further distillation work.
+
+Beryl's live-conversation requirement (sub-frame-budget latency, streaming
+output) makes the warping/GAN lineage the default starting point, with
+diffusion-based approaches held as a quality upgrade path once (and only once)
+their latency is independently measured against the real-time budget.
+
+## 3. Mechanism
+
+A THG stage generally decomposes into three sub-stages, mirrored in this
+pipeline's own node children:
+
+1. **Motion extraction** — derive keypoint or motion-coefficient deltas from the
+   driving audio (via phoneme/viseme timing) and, for identity-lock, from
+   periodic Vision re-checks of the reference frame.
+2. **Warping** — apply the extracted motion to the reference image's feature
+   representation. This is the most compute-expensive sub-stage and the first
+   place to look when frame rate drops.
+3. **Generation** — render the final RGB frame from the warped feature
+   representation. Smaller generators trade fidelity for speed.
+
+## 4. Candidate Implementations — the C Protocol
+
+Five axes, each scored 0–1: **Code** (does it run, is it official — a gate, not
+just an average input: below 0.3 caps the tier at C regardless of the other
+four), **Claim** (research credibility), **Consensus** (community stars/traction),
+**Cost** (compute/financial efficiency), **Connectivity** (fit into a real-time
+pipeline).
+
+| Candidate | Stars | Paper | Code | Claim | Consensus | Cost | Connectivity | Tier |
+|---|---:|---|---:|---:|---:|---:|---:|:-:|
+| **LiveTalking** (lipku) | 8,378 | — (engineering) | 0.95 | 0.55 | 0.95 | 0.85 | 0.95 | A |
+| **FasterLivePortrait** (warmshao) | 1,153 | — (engineering) | 0.90 | 0.60 | 0.70 | 0.90 | 0.85 | A |
+| **EchoMimicV2** (antgroup) | 4,614 | CVPR 2025 | 0.85 | 0.90 | 0.85 | 0.55 | 0.65 | A |
+| **Hallo2** (fudan-generative-vision) | 3,718 | ICLR 2025 | 0.85 | 0.95 | 0.90 | 0.35 | 0.55 | B |
+| **JoyVASA** (jdh-algo) | 874 | — | 0.75 | 0.65 | 0.70 | 0.45 | 0.50 | B |
+| **VASA-1** (no official release) | 105† | Microsoft Research | 0.05 | 0.80 | 0.20 | 0.00 | 0.00 | C |
+
+† Largest of three competing *unofficial* reproduction attempts; none endorsed
+by the original authors. See §5, Failure 5.
+
+**Reading this table**: look at VASA-1's row first — 0.80 on Claim, 0.05 on Code.
+That mismatch *is* the finding: a paper can look excellent and still be a Tier C
+pipeline dependency because nothing exists to run. Hallo2 shows the softer
+version of the same lesson — the strongest Claim in the set (ICLR 2025) paired
+with the weakest Cost, because it was built for offline quality, not live
+latency. A high Claim score is a reason to *read* the paper, not a reason to
+skip measuring the code.
+
+## 5. Failure-Mode Audit (Current Selection: LivePortrait / FasterLivePortrait)
+
+| # | Failure | Verdict | Finding |
+|---|---|:-:|---|
+| 1 | Uncanny Valley | **AT-RISK** | Architecture-inherent to audio-driven THG generally, not disproved by choice of model. Requires a real measurement — frame-to-frame head-pose variance and upper-face action-unit activation range — not an assumption of solved-ness. |
+| 2 | End-of-Speech Pop | **AT-RISK** | Known integration failure class for exactly this pattern: compositing a generated mouth region back onto a static source image. Must be verified experimentally at the silence transition. |
+| 3 | Cascaded Latency | **PASS** (node-local) | ~33ms/frame (~30fps) in isolation is within budget. This node is the *last hop* of the pipeline-level cascade, not an offender on its own — see the pipeline-level audit for the FAIL verdict on the architecture as a whole. |
+| 4 | VRAM Death | **PASS** | 8GB fp16, comfortably fits alongside the rest of the stack on a single 24GB GPU. |
+| 5 | VASA-1 Problem | **PASS** | LivePortrait and FasterLivePortrait are both public, open-source, and independently reproducible — unlike Maxine ARA (Enterprise-gated, can't even run it to check) and unlike VASA-1 itself (no official repo at all). |
+
+**Net tier: B.** Not because anything measured has failed, but because two of
+the five failure modes are honestly unresolved rather than falsely marked safe.
+A Tier A verdict here would be the rubber-stamping Samantha's rubric exists to
+prevent.
+
+## 6. Open Questions (feed into knowledge graph)
+
+1. Run the frame-to-frame head-pose variance measurement (Failure 1) against
+   FasterLivePortrait's actual output — currently asserted as a risk, not yet
+   measured.
+2. Run the silence-transition color/saturation delta measurement (Failure 2)
+   against the TTS→Avatar handoff specifically.
+3. Independently benchmark EchoMimicV2 and Hallo2 latency/VRAM against the
+   real-time budget rather than accepting the "likely too slow" inference in
+   §4 — the claim strength of both papers means this is worth confirming, not
+   dismissing.
+4. Study LiveTalking's architecture directly — it is the closest existing
+   real-world implementation of what Beryl is attempting, and may shortcut
+   integration work at the Avatar↔TTS boundary specifically.
+
+## 7. References
+
+- LiveTalking — https://github.com/lipku/LiveTalking
+- FasterLivePortrait — https://github.com/warmshao/FasterLivePortrait
+- EchoMimicV2 (CVPR 2025) — https://github.com/antgroup/echomimic_v2
+- Hallo2 (ICLR 2025) — https://github.com/fudan-generative-vision/hallo2
+- JoyVASA — https://github.com/jdh-algo/JoyVASA
+- VASA-1 (unofficial reproduction, no official release) — https://github.com/vasavatar/VASA-1
+
+*Star/fork counts pulled live from the GitHub API on 2026-07-13. Re-verify
+before treating as current.*

src/app/pipeline/Workspace.tsx

@@ -9,6 +9,7 @@ import NodeDetails from "@/components/NodeDetails";
 import ExpertChat from "@/components/ExpertChat";
 import { berylPipeline } from "@/lib/beryl-pipeline";
 import { FAILURE_MODES, type ImplementationMode } from "@/lib/types";
+import type { LayoutMode } from "@/lib/graph-layout";
 
 export default function Workspace() {
   const searchParams = useSearchParams();
@@ -21,6 +22,7 @@ export default function Workspace() {
   const [showMetrics, setShowMetrics] = useState(true);
   const [tab, setTab] = useState<"details" | "expert">("details");
   const [auditOpen, setAuditOpen] = useState(false);
+  const [layoutMode, setLayoutMode] = useState<LayoutMode>("circular");
 
   const failingAudit = pipeline.pipelineAudit?.some((a) => a.verdict === "fail");
 
@@ -71,9 +73,12 @@ export default function Workspace() {
           >
             <SlidersHorizontal size={12} /> Metrics
           </button>
-          <span className="flex items-center gap-1.5 text-xs px-3 py-1.5 rounded-full border border-[var(--panel-border)] text-[var(--muted)]">
-            <LayoutGrid size={12} /> Circular
-          </span>
+          <button
+            onClick={() => setLayoutMode((m) => (m === "circular" ? "rows" : "circular"))}
+            className="flex items-center gap-1.5 text-xs px-3 py-1.5 rounded-full border border-[var(--panel-border)] text-[var(--muted)] hover:text-white transition"
+          >
+            <LayoutGrid size={12} /> {layoutMode === "circular" ? "Circular" : "Rows"}
+          </button>
         </div>
       </header>
 
@@ -124,6 +129,7 @@ export default function Workspace() {
             selectedId={selectedId}
             activeModes={activeModes}
             showMetrics={showMetrics}
+            layoutMode={layoutMode}
             onSelect={selectNode}
             onToggleExpand={toggleExpand}
             onSetMode={setMode}

src/components/PipelineGraph.tsx

@@ -11,7 +11,7 @@ import {
 } from "@xyflow/react";
 import "@xyflow/react/dist/style.css";
 import type { ImplementationMode, Pipeline } from "@/lib/types";
-import { computeLayout } from "@/lib/graph-layout";
+import { computeLayout, type LayoutMode } from "@/lib/graph-layout";
 import StageNode from "./nodes/StageNode";
 
 const nodeTypes = { stage: StageNode };
@@ -22,6 +22,7 @@ export default function PipelineGraph({
   selectedId,
   activeModes,
   showMetrics,
+  layoutMode,
   onSelect,
   onToggleExpand,
   onSetMode,
@@ -31,12 +32,13 @@ export default function PipelineGraph({
   selectedId: string | null;
   activeModes: Record<string, ImplementationMode>;
   showMetrics: boolean;
+  layoutMode: LayoutMode;
   onSelect: (id: string) => void;
   onToggleExpand: (id: string) => void;
   onSetMode: (id: string, mode: ImplementationMode) => void;
 }) {
   const { nodes, edges } = useMemo(() => {
-    const { positions, flatChildren } = computeLayout(pipeline, expandedIds);
+    const { positions, flatChildren } = computeLayout(pipeline, expandedIds, layoutMode);
     const nodes: Node[] = [];
 
     pipeline.nodes.forEach((n) => {
@@ -115,10 +117,11 @@ export default function PipelineGraph({
     });
 
     return { nodes, edges };
-  }, [pipeline, expandedIds, selectedId, activeModes, showMetrics, onSelect, onToggleExpand, onSetMode]);
+  }, [pipeline, expandedIds, selectedId, activeModes, showMetrics, layoutMode, onSelect, onToggleExpand, onSetMode]);
 
   return (
     <ReactFlow
+      key={layoutMode}
       nodes={nodes}
       edges={edges}
       nodeTypes={nodeTypes}

src/lib/candidates.ts

@@ -0,0 +1,248 @@
+// The C Protocol — five evaluation axes, each scored 0-1, rendered as stars.
+// Code is a gate, not just an average input: a candidate with near-zero Code
+// cannot score above Tier C regardless of how strong its other four axes look.
+// That rule exists specifically to encode Failure 5 (the VASA-1 Problem) as
+// arithmetic, not just prose: a brilliant claim with no repo doesn't count.
+
+export type CScore = {
+  value: number; // 0-1
+  note: string;
+};
+
+export const C_PROTOCOL_DIMENSIONS = ["code", "claim", "consensus", "cost", "connectivity"] as const;
+export type CDimension = (typeof C_PROTOCOL_DIMENSIONS)[number];
+
+// Fixed color order — never reassigned per candidate, per dimension identity.
+export const C_PROTOCOL_COLOR: Record<CDimension, string> = {
+  code: "#3987e5", // blue
+  claim: "#199e70", // aqua
+  consensus: "#c98500", // yellow
+  cost: "#008300", // green
+  connectivity: "#9085e9", // violet
+};
+
+export const C_PROTOCOL_LABEL: Record<CDimension, string> = {
+  code: "Code",
+  claim: "Claim",
+  consensus: "Consensus",
+  cost: "Cost",
+  connectivity: "Connectivity",
+};
+
+export type Candidate = {
+  id: string;
+  name: string;
+  org: string;
+  githubUrl: string;
+  category: "avatar" | "asr" | "llm" | "tts" | "keyframer" | "orchestration";
+  paperVenue?: string;
+  stars?: number;
+  forks?: number;
+  verifiedAt: string;
+  hasOfficialRepo: boolean;
+  scores: Record<CDimension, CScore>;
+  verdict: string;
+};
+
+function tierFromScores(scores: Record<CDimension, CScore>): "A" | "B" | "C" {
+  // Code gate: no reproducible code caps the tier at C, full stop.
+  if (scores.code.value < 0.3) return "C";
+  const avg =
+    (scores.code.value +
+      scores.claim.value +
+      scores.consensus.value +
+      scores.cost.value +
+      scores.connectivity.value) /
+    5;
+  if (avg >= 0.75) return "A";
+  if (avg >= 0.5) return "B";
+  return "C";
+}
+
+// Star/fork counts pulled live from the GitHub API. Re-verify before treating
+// as current — this is exactly the discipline Failure 5 demands.
+const RAW: Array<Omit<Candidate, "verdict"> & { verdictDraft: string }> = [
+  {
+    id: "live-talking",
+    name: "LiveTalking",
+    org: "lipku",
+    githubUrl: "https://github.com/lipku/LiveTalking",
+    category: "avatar",
+    stars: 8378,
+    forks: 1350,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.95, note: "Real, official, actively maintained (commits within the last day). Runs as-is." },
+      claim: { value: 0.55, note: "No peer-reviewed paper attached — this is an engineering integration project, proven in production rather than in a journal." },
+      consensus: { value: 0.95, note: "8,378 stars, 1,350 forks — one of the most active repos in this comparison." },
+      cost: { value: 0.85, note: "Built on lightweight methods (wav2lip/MuseTalk/ER-NeRF class) explicitly chosen for low VRAM and real-time throughput." },
+      connectivity: { value: 0.95, note: "Built explicitly as an end-to-end real-time streaming pipeline (lip-sync + TTS + LLM chat) — closest real-world reference to Beryl's own architecture." },
+    },
+    verdictDraft: "The single closest real-world reference for what Beryl is trying to build. Study its architecture before writing new THG code.",
+  },
+  {
+    id: "faster-live-portrait",
+    name: "FasterLivePortrait",
+    org: "warmshao",
+    githubUrl: "https://github.com/warmshao/FasterLivePortrait",
+    category: "avatar",
+    stars: 1153,
+    forks: 130,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.9, note: "Real, official, updated within the last day. ONNX/TensorRT paths both run." },
+      claim: { value: 0.6, note: "Builds on LivePortrait's peer-reviewed base; this repo itself is an engineering optimization, not new research." },
+      consensus: { value: 0.7, note: "1,153 stars — smaller than headline projects, but real and current." },
+      cost: { value: 0.9, note: "Purpose-built for speed — this is the actual fix for LivePortrait's latency, not a theoretical one." },
+      connectivity: { value: 0.85, note: "Drop-in acceleration of LivePortrait with explicit real-time support." },
+    },
+    verdictDraft: "Best-in-class for the Avatar node specifically on the cost/latency axis Beryl needs.",
+  },
+  {
+    id: "echomimic-v2",
+    name: "EchoMimicV2",
+    org: "antgroup",
+    githubUrl: "https://github.com/antgroup/echomimic_v2",
+    category: "avatar",
+    paperVenue: "CVPR 2025",
+    stars: 4614,
+    forks: 540,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.85, note: "Real, official, actively maintained. Runs as published." },
+      claim: { value: 0.9, note: "CVPR 2025 peer-reviewed — a top-tier venue, real published results." },
+      consensus: { value: 0.85, note: "4,614 stars, 540 forks, real ComfyUI ecosystem." },
+      cost: { value: 0.55, note: "Diffusion-based — heavier per-frame cost than GAN/warping derivatives. Needs a measured latency/VRAM check before assuming real-time fit." },
+      connectivity: { value: 0.65, note: "Semi-body diffusion output is richer but not architected for a tight real-time loop the way LiveTalking is." },
+    },
+    verdictDraft: "Credible and well-cited, but cost profile needs verification against Beryl's real-time budget before adoption.",
+  },
+  {
+    id: "hallo2",
+    name: "Hallo2",
+    org: "fudan-generative-vision",
+    githubUrl: "https://github.com/fudan-generative-vision/hallo2",
+    category: "avatar",
+    paperVenue: "ICLR 2025",
+    stars: 3718,
+    forks: 536,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.85, note: "Real, official, actively maintained. Runs as published." },
+      claim: { value: 0.95, note: "ICLR 2025 — one of the top peer-reviewed venues in ML. The strongest research claim in this entire set." },
+      consensus: { value: 0.9, note: "3,718 stars for Hallo2 alone; sibling Hallo has 8,655 — a very strong ecosystem." },
+      cost: { value: 0.35, note: "High-resolution diffusion pipeline built for quality over speed — likely a poor fit for Beryl's live-conversation latency budget as-is." },
+      connectivity: { value: 0.55, note: "Optimized for long-duration, high-resolution offline generation, not a tight conversational real-time loop." },
+    },
+    verdictDraft: "The best research claim in this set does not automatically mean the best fit. Don't let Failure 5's inverse — great paper, wrong use case — trip you.",
+  },
+  {
+    id: "joyvasa",
+    name: "JoyVASA",
+    org: "jdh-algo",
+    githubUrl: "https://github.com/jdh-algo/JoyVASA",
+    category: "avatar",
+    stars: 874,
+    forks: 87,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.75, note: "Real, official, actively maintained, runs as published." },
+      claim: { value: 0.65, note: "Real code, no major top-tier venue publication found in this pass — credible but not independently peer-reviewed here." },
+      consensus: { value: 0.7, note: "874 stars, actively updated." },
+      cost: { value: 0.45, note: "Diffusion-based — likely needs further optimization before real-time use, similar to EchoMimicV2's tradeoff." },
+      connectivity: { value: 0.5, note: "Generalizes to animal animation too — flexible, but not built for a real-time streaming loop." },
+    },
+    verdictDraft: "Interesting for its generalization (portrait + animal), but not a clear win over LiveTalking/FasterLivePortrait for Beryl's specific use case.",
+  },
+  {
+    id: "vasa-1",
+    name: "VASA-1",
+    org: "Microsoft Research (no official release)",
+    githubUrl: "https://github.com/vasavatar/VASA-1",
+    category: "avatar",
+    paperVenue: "Microsoft Research",
+    stars: 105,
+    forks: 14,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: false,
+    scores: {
+      code: { value: 0.05, note: "No official repo exists. Every GitHub result for 'VASA-1' is an unofficial, unendorsed reproduction attempt (105, 318, and 22 stars respectively) — none complete, none authoritative." },
+      claim: { value: 0.8, note: "The paper's presented results are genuinely impressive on their own terms — this high score is the trap: a strong claim paired with near-zero Code is exactly the pattern Failure 5 exists to catch." },
+      consensus: { value: 0.2, note: "The largest unofficial attempt (johndpope/VASA-1-hack, 318 stars) is explicitly labeled 'wip — running some training with overfitting.' Fragmented, not consolidated." },
+      cost: { value: 0, note: "Cannot be measured — there is no runnable reference implementation." },
+      connectivity: { value: 0, note: "No official code exists to connect to anything." },
+    },
+    verdictDraft: "This is Failure 5's namesake for a reason. Brilliant claim, zero official reproduction. Archive it as a research reference only — never as a pipeline dependency.",
+  },
+  {
+    id: "glm-4-voice",
+    name: "GLM-4-Voice",
+    org: "zai-org",
+    githubUrl: "https://github.com/zai-org/GLM-4-Voice",
+    category: "llm",
+    stars: 3203,
+    forks: 281,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.85, note: "Real, official, updated within the last few days." },
+      claim: { value: 0.7, note: "From a reputable lab (Zhipu/Z.ai), no single top-tier venue confirmed in this pass but a credible, active org." },
+      consensus: { value: 0.8, note: "3,203 stars, active." },
+      cost: { value: 0.65, note: "One end-to-end model likely avoids the redundant encode/decode hops of three separate models — needs a direct VRAM/latency measurement against the current stack." },
+      connectivity: { value: 0.7, note: "Architecturally different, not a drop-in node swap: an end-to-end speech-to-speech model that COLLAPSES ASR->LLM->TTS into one call — the single most important find in this comparison for the Cascaded Latency problem." },
+    },
+    verdictDraft: "Worth a serious architecture-level evaluation: does replacing three pipeline nodes with one end-to-end model actually solve Failure 3, or just relocate it?",
+  },
+  {
+    id: "wan2-1",
+    name: "Wan2.1",
+    org: "Wan-Video",
+    githubUrl: "https://github.com/Wan-Video/Wan2.1",
+    category: "keyframer",
+    stars: 16543,
+    forks: 2957,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.95, note: "Real, official, updated within hours." },
+      claim: { value: 0.85, note: "Real, open, from Alibaba, extensively used and cited." },
+      consensus: { value: 0.98, note: "16,543 stars, 2,957 forks — the most active repo in this entire comparison." },
+      cost: { value: 0.7, note: "Ships multiple model sizes (1.3B/14B) — an actual quantization/scale path, not a 32GB+ dead end." },
+      connectivity: { value: 0.7, note: "Text/image-to-video generation with a real ComfyUI ecosystem — fits the offline/async Keyframer role well." },
+    },
+    verdictDraft: "The clear flagship choice for the Keyframer node. No competing claim in this set comes close on consensus or activity.",
+  },
+  {
+    id: "triton",
+    name: "Triton Inference Server",
+    org: "triton-inference-server",
+    githubUrl: "https://github.com/triton-inference-server/server",
+    category: "orchestration",
+    stars: 10823,
+    forks: 1807,
+    verifiedAt: "2026-07-13",
+    hasOfficialRepo: true,
+    scores: {
+      code: { value: 0.95, note: "Real, official, NVIDIA-maintained, daily commit activity." },
+      claim: { value: 0.9, note: "NVIDIA-maintained since 2018, extremely mature, no reproducibility question here." },
+      consensus: { value: 0.95, note: "10,823 stars, 1,807 forks, daily commit activity." },
+      cost: { value: 0.9, note: "The serving layer itself has minimal overhead; it reduces aggregate cost by enabling shared-GPU concurrency." },
+      connectivity: { value: 0.95, note: "Purpose-built to orchestrate multi-model serving with dynamic batching — exactly the Orchestration node's job." },
+    },
+    verdictDraft: "No real alternative needed here — this is the settled choice.",
+  },
+];
+
+export const CANDIDATES: Candidate[] = RAW.map(({ verdictDraft, ...c }) => ({
+  ...c,
+  verdict: verdictDraft,
+}));
+
+export function candidateTier(c: Candidate): "A" | "B" | "C" {
+  return tierFromScores(c.scores);
+}

src/lib/graph-layout.ts

@@ -1,5 +1,7 @@
 import type { Pipeline, PipelineNode } from "./types";
 
+export type LayoutMode = "circular" | "rows";
+
 export type LayoutResult = {
   positions: Record<string, { x: number; y: number }>;
   flatChildren: Record<string, PipelineNode>;
@@ -8,10 +10,7 @@ export type LayoutResult = {
 const RING_1_RADIUS = 460;
 const RING_2_RADIUS = 230;
 
-export function computeLayout(
-  pipeline: Pipeline,
-  expandedIds: Set<string>,
-): LayoutResult {
+function computeCircularLayout(pipeline: Pipeline, expandedIds: Set<string>): LayoutResult {
   const top = pipeline.nodes.filter((n) => n.category !== "orchestration");
   const hub = pipeline.nodes.find((n) => n.category === "orchestration");
   const count = top.length;
@@ -44,3 +43,68 @@ export function computeLayout(
 
   return { positions, flatChildren };
 }
+
+// Rows: nodes grouped into horizontal bands by pipeline order (top-down DAG),
+// matching a layered "structural" view rather than a circular loop.
+const ROW_ORDER: Record<string, number> = {
+  vision: 0,
+  asr: 0,
+  llm: 1,
+  tts: 2,
+  keyframer: 3,
+  avatar: 3,
+  video: 4,
+  orchestration: 5,
+};
+
+const ROW_HEIGHT = 190;
+const COLUMN_WIDTH = 260;
+const CHILD_ROW_HEIGHT = 110;
+
+function computeRowsLayout(pipeline: Pipeline, expandedIds: Set<string>): LayoutResult {
+  const positions: Record<string, { x: number; y: number }> = {};
+  const flatChildren: Record<string, PipelineNode> = {};
+
+  const rows = new Map<number, PipelineNode[]>();
+  pipeline.nodes.forEach((n) => {
+    const row = ROW_ORDER[n.category] ?? 0;
+    if (!rows.has(row)) rows.set(row, []);
+    rows.get(row)!.push(n);
+  });
+
+  const sortedRowIndices = Array.from(rows.keys()).sort((a, b) => a - b);
+
+  sortedRowIndices.forEach((rowIndex) => {
+    const nodesInRow = rows.get(rowIndex)!;
+    const rowWidth = (nodesInRow.length - 1) * COLUMN_WIDTH;
+    nodesInRow.forEach((n, i) => {
+      const x = i * COLUMN_WIDTH - rowWidth / 2;
+      const y = rowIndex * ROW_HEIGHT;
+      positions[n.id] = { x, y };
+
+      if (expandedIds.has(n.id) && n.children?.length) {
+        const childCount = n.children.length;
+        const childRowWidth = (childCount - 1) * (COLUMN_WIDTH * 0.7);
+        n.children.forEach((child, ci) => {
+          flatChildren[child.id] = child;
+          positions[child.id] = {
+            x: x + ci * (COLUMN_WIDTH * 0.7) - childRowWidth / 2,
+            y: y + CHILD_ROW_HEIGHT,
+          };
+        });
+      }
+    });
+  });
+
+  return { positions, flatChildren };
+}
+
+export function computeLayout(
+  pipeline: Pipeline,
+  expandedIds: Set<string>,
+  mode: LayoutMode = "circular",
+): LayoutResult {
+  return mode === "rows"
+    ? computeRowsLayout(pipeline, expandedIds)
+    : computeCircularLayout(pipeline, expandedIds);
+}