refactor: dedupe preview-exposure source lookups via store helpers

Four sites re-implemented the same
getExposures(...).some/find(e => e.sourceNodeId === X && e.sourcePreviewName === Y)
predicate. Add findExposure/hasExposure to previewExposureStore, normalizing
sourceNodeId via toNodeId internally, and route all four callers through them.

apps/website/e2e/customers-detail.spec.ts

@@ -70,4 +70,39 @@ test.describe('Customer story detail @smoke', () => {
       '/customers/series-entertainment'
     )
   })
+
+  test('renders a Creative Campus story with its education blocks', async ({
+    page
+  }) => {
+    await page.goto('/customers/xindi-zhang')
+
+    await expect(
+      page.getByRole('heading', {
+        level: 1,
+        name: /The tool that expands my art/i
+      })
+    ).toBeVisible()
+
+    const nav = page.getByRole('navigation', { name: 'Category filter' })
+    await expect(nav.getByRole('button', { name: 'INTRO' })).toBeVisible()
+    await expect(nav.getByRole('button', { name: 'AT A GLANCE' })).toBeVisible()
+
+    // At a glance block (AtAGlance component) with its spec rows.
+    await expect(
+      page.getByRole('heading', { name: 'At a glance' })
+    ).toBeVisible()
+    await expect(page.getByText('Program', { exact: true })).toBeVisible()
+
+    // Workflow download button (Download component).
+    await expect(
+      page.getByRole('link', {
+        name: /Download Xindi's style transfer workflow/i
+      })
+    ).toBeVisible()
+
+    // Shared education call to action (EducationCta component).
+    await expect(
+      page.getByRole('link', { name: /Explore the Education Program/i })
+    ).toBeVisible()
+  })
 })

apps/website/public/icons/node-link.svg

@@ -1,3 +1,3 @@
-<svg preserveAspectRatio="none" width="100%" height="100%" overflow="visible" style="display: block;" viewBox="0 0 20 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path id="Vector" d="M20 32V0C20 5.39616 15.5172 9.78053 10 9.78053C4.48276 9.78053 0 5.416 0 0V32C0 26.6038 4.48276 22.2195 10 22.2195C15.5172 22.2195 20 26.6038 20 32Z" fill="var(--fill-0, #F2FF59)"/>
+<svg width="20" height="32" viewBox="0 0 20 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20 32V0C20 5.39616 15.5172 9.78053 10 9.78053C4.48276 9.78053 0 5.416 0 0V32C0 26.6038 4.48276 22.2195 10 22.2195C15.5172 22.2195 20 26.6038 20 32Z" fill="#F2FF59"/>
 </svg>

apps/website/src/components/customers/CustomerArticle.astro

@@ -4,16 +4,24 @@ import { render } from 'astro:content'
 import type { Locale } from '../../i18n/translations'
 import type { CustomerStoryEntry } from '../../utils/customers'
 import ArticleNav from './ArticleNav.vue'
+import AtAGlance from './content/AtAGlance.astro'
+import AuthorBio from './content/AuthorBio.astro'
 import BulletList from './content/BulletList.astro'
 import Contributors from './content/Contributors.astro'
+import Download from './content/Download.astro'
+import EducationCta from './content/EducationCta.astro'
+import Embed from './content/Embed.astro'
 import Figure from './content/Figure.astro'
 import Heading from './content/Heading.astro'
+import Heading4 from './content/Heading4.astro'
+import Link from './content/Link.astro'
 import ListItem from './content/ListItem.astro'
 import Paragraph from './content/Paragraph.astro'
 import Quote from './content/Quote.astro'
 import ReadMore from './content/ReadMore.vue'
 import Section from './content/Section.astro'
 import Steps from './content/Steps.astro'
+import Video from './content/Video.astro'
 
 interface Props {
   entry: CustomerStoryEntry
@@ -34,18 +42,26 @@ const categories = entry.data.sections.map((section) => ({
 // components (Section, Figure, ...) are used directly inside the MDX body.
 const contentComponents = {
   p: Paragraph,
+  a: Link,
   h3: Heading,
+  h4: Heading4,
   ul: BulletList,
   li: ListItem,
   Section,
   Figure,
   Quote,
   Contributors,
-  Steps
+  Steps,
+  AtAGlance,
+  AuthorBio,
+  Download,
+  EducationCta,
+  Embed,
+  Video
 }
 ---
 
-<section class="px-4 pt-8 pb-24 lg:px-20 lg:pt-24 lg:pb-40">
+<section class="max-w-9xl mx-auto px-4 pt-8 pb-24 lg:px-20 lg:pt-24 lg:pb-40">
   <div class="lg:flex lg:gap-16">
     <aside class="hidden scrollbar-none lg:block lg:w-48 lg:shrink-0">
       <div class="sticky top-32">

apps/website/src/components/customers/content/AtAGlance.astro

@@ -0,0 +1,29 @@
+---
+interface Row {
+  label: string
+  value: string
+}
+
+interface Props {
+  rows: Row[]
+}
+
+const { rows } = Astro.props
+---
+
+<div
+  class="my-8 overflow-hidden rounded-2xl border border-white/10 bg-site-bg-soft"
+>
+  <dl class="divide-y divide-white/10">
+    {
+      rows.map((row) => (
+        <div class="flex flex-col gap-1 p-5 sm:flex-row sm:gap-6">
+          <dt class="text-primary-comfy-yellow shrink-0 text-xs font-bold tracking-widest uppercase sm:w-44">
+            {row.label}
+          </dt>
+          <dd class="text-sm/relaxed text-primary-comfy-canvas">{row.value}</dd>
+        </div>
+      ))
+    }
+  </dl>
+</div>

apps/website/src/components/customers/content/AuthorBio.astro

@@ -0,0 +1,60 @@
+---
+interface Author {
+  name?: string
+  role?: string
+  photo?: string
+  bio?: string
+}
+
+interface Props {
+  label?: string
+  people: Author[]
+}
+
+const { label, people } = Astro.props
+const hasBioSlot = Astro.slots.has('default')
+---
+
+<div class="mt-12 border-t border-white/10 pt-8">
+  {
+    label && (
+      <span class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase">
+        {label}
+      </span>
+    )
+  }
+  <div class="mt-4 space-y-8">
+    {
+      people.map((person) => (
+        <div class="flex flex-col gap-4 sm:flex-row sm:items-start sm:gap-6">
+          {person.photo && (
+            <img
+              src={person.photo}
+              alt={person.name ?? ''}
+              class="size-20 shrink-0 rounded-full object-cover"
+            />
+          )}
+          <div>
+            {person.name && (
+              <p class="text-sm font-semibold text-primary-comfy-canvas">
+                {person.name}
+                {person.role && (
+                  <span class="text-primary-warm-gray"> · {person.role}</span>
+                )}
+              </p>
+            )}
+            {person.bio ? (
+              <p class="mt-2 text-sm/relaxed text-primary-comfy-canvas italic">
+                {person.bio}
+              </p>
+            ) : hasBioSlot ? (
+              <p class="mt-2 text-sm/relaxed text-primary-comfy-canvas italic">
+                <slot />
+              </p>
+            ) : null}
+          </div>
+        </div>
+      ))
+    }
+  </div>
+</div>

apps/website/src/components/customers/content/Contributors.astro

@@ -14,7 +14,7 @@ interface Props {
 const { label, people } = Astro.props
 ---
 
-<div class="mt-8 rounded-2xl bg-(--site-bg-soft) p-6">
+<div class="mt-8 rounded-2xl bg-site-bg-soft p-6">
   <span
     class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase"
   >

apps/website/src/components/customers/content/Download.astro

@@ -0,0 +1,19 @@
+---
+interface Props {
+  href: string
+  label: string
+  newTab?: boolean
+}
+
+const { href, label, newTab = false } = Astro.props
+---
+
+<a
+  href={href}
+  download={newTab ? undefined : true}
+  target={newTab ? '_blank' : undefined}
+  rel={newTab ? 'noopener noreferrer' : undefined}
+  class="text-primary-comfy-yellow my-4 inline-block text-sm font-semibold underline underline-offset-2 transition-opacity hover:opacity-80"
+>
+  {label}
+</a>

apps/website/src/components/customers/content/EducationCta.astro

@@ -0,0 +1,15 @@
+---
+import Link from './Link.astro'
+---
+
+<div
+  class="border-primary-comfy-yellow mt-12 rounded-2xl border-l-4 bg-site-bg-soft p-8"
+>
+  <p class="text-base/relaxed text-primary-comfy-canvas">
+    <strong class="font-semibold">Teaching with ComfyUI?</strong> The Comfy Education
+    Program is live: educational pricing, classroom cloud accounts on one invoice,
+    <Link href="https://comfy.org/education">Explore the Education Program</Link> or
+    <Link href="https://tally.so/r/Xx97lL">apply to be a part of the Creative
+    Campus program</Link> if you're interested in exploring a deeper partnership with Comfy.
+  </p>
+</div>

apps/website/src/components/customers/content/Embed.astro

@@ -0,0 +1,22 @@
+---
+interface Props {
+  src: string
+  title: string
+}
+
+const { src, title } = Astro.props
+---
+
+<div
+  class="my-8 aspect-video overflow-hidden rounded-2xl border border-white/10 bg-black"
+>
+  <iframe
+    src={src}
+    title={title}
+    class="size-full"
+    loading="lazy"
+    allow="autoplay; fullscreen; picture-in-picture; clipboard-write"
+    referrerpolicy="strict-origin-when-cross-origin"
+    sandbox="allow-scripts allow-same-origin allow-presentation allow-popups"
+  ></iframe>
+</div>

apps/website/src/components/customers/content/Figure.astro

@@ -6,14 +6,15 @@ interface Props {
 }
 
 const { src, alt, caption } = Astro.props
+const hasCaptionSlot = Astro.slots.has('default')
 ---
 
 <figure class="my-8">
   <img src={src} alt={alt} class="w-full rounded-2xl object-cover" />
   {
-    caption && (
+    (hasCaptionSlot || caption) && (
       <figcaption class="mt-3 text-xs text-primary-comfy-canvas">
-        {caption}
+        {hasCaptionSlot ? <slot /> : caption}
       </figcaption>
     )
   }

apps/website/src/components/customers/content/Heading4.astro

@@ -0,0 +1,6 @@
+---
+---
+
+<h4 class="mt-6 mb-2 text-base font-semibold text-primary-comfy-canvas">
+  <slot />
+</h4>

apps/website/src/components/customers/content/Link.astro

@@ -0,0 +1,15 @@
+---
+interface Props {
+  href: string
+}
+
+const { href } = Astro.props
+const isExternal = /^https?:\/\//.test(href)
+---
+
+<a
+  href={href}
+  target={isExternal ? '_blank' : undefined}
+  rel={isExternal ? 'noopener noreferrer' : undefined}
+  class="text-primary-comfy-yellow underline underline-offset-2 transition-opacity hover:opacity-80"
+><slot /></a>

apps/website/src/components/customers/content/Quote.astro

@@ -1,16 +1,20 @@
 ---
 interface Props {
-  name: string
+  name?: string
 }
 
 const { name } = Astro.props
 ---
 
 <blockquote
-  class="border-primary-comfy-yellow my-8 rounded-2xl border-l-4 bg-(--site-bg-soft) p-8"
+  class="border-primary-comfy-yellow my-8 rounded-2xl border-l-4 bg-site-bg-soft p-8"
 >
   <p class="text-lg/relaxed font-light text-primary-comfy-canvas italic">
     "<slot />"
   </p>
-  <p class="text-primary-comfy-yellow mt-4 text-sm font-semibold">{name}</p>
+  {
+    name && (
+      <p class="text-primary-comfy-yellow mt-4 text-sm font-semibold">{name}</p>
+    )
+  }
 </blockquote>

apps/website/src/components/customers/content/Video.astro

@@ -0,0 +1,22 @@
+---
+import VideoPlayer from '../../common/VideoPlayer.vue'
+
+interface Props {
+  src: string
+  poster?: string
+  caption?: string
+}
+
+const { src, poster, caption } = Astro.props
+---
+
+<figure class="my-8">
+  <VideoPlayer src={src} poster={poster} client:visible />
+  {
+    caption && (
+      <figcaption class="mt-3 text-xs text-primary-comfy-canvas">
+        {caption}
+      </figcaption>
+    )
+  }
+</figure>

apps/website/src/content/customers.content.test.ts

@@ -63,8 +63,12 @@ function bodySectionIds(body: string): string[] {
 
 const stories = loadStories()
 
-it('finds all ten customer stories', () => {
-  expect(stories).toHaveLength(10)
+it('finds customer stories in every locale', () => {
+  for (const locale of locales) {
+    const prefix = `${locale}/`
+    const inLocale = stories.filter((story) => story.file.startsWith(prefix))
+    expect(inLocale.length).toBeGreaterThan(0)
+  }
 })
 
 describe.for(stories)('$file', ({ frontmatter, body }) => {

apps/website/src/content/customers/en/golan-levin.mdx

@@ -0,0 +1,148 @@
+---
+title: "Seeing the world in new ways: how Prof. Golan Levin teaches with ComfyUI at Carnegie Mellon University"
+category: "CREATIVE CAMPUS SHOWCASE"
+description: "\"For me, ComfyUI is not just about generative AI. It's an image-processing workstation for completely new kinds of work.\""
+cover: "https://media.comfy.org/website/customers/golan-levin/cover.png"
+order: 7
+sections:
+  - id: topic-1
+    label: "INTRO"
+  - id: topic-2
+    label: "WHERE COMFYUI FITS"
+  - id: topic-3
+    label: "IMAGE SYNTHESIS"
+  - id: topic-4
+    label: "IMAGE ANALYSIS"
+  - id: topic-5
+    label: "THE CV LAB"
+  - id: topic-6
+    label: "AT A GLANCE"
+  - id: topic-7
+    label: "STUDENT WORK"
+---
+
+<Section id="topic-1">
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/augmented-hand.jpg" alt="Golan Levin, Augmented Hand Series" caption="Golan Levin, Augmented Hand Series (2014), with Chris Sugrue and Kyle McDonald. Photo: Gerlinde de Geus, courtesy Cinekid." />
+
+For many people, AI in the arts means image generation. But Levin has spent much of the past two decades teaching artists how computers can interpret, analyze, and measure the visual world. His own artworks have long explored machine perception through real-time computer vision systems, and since 2024 he has increasingly used ComfyUI to teach these principles.
+
+For Levin, ComfyUI is less an image generator than an image-processing workbench. Students use it to assemble custom workflows for segmentation, tracking, depth estimation, and other forms of computational perception. The result is an environment where artists can experiment directly with research-grade machine learning tools and combine them into systems of their own design.
+
+</Section>
+
+<Section id="topic-2">
+
+### Where does ComfyUI fit in what you're trying to do?
+
+I'm training creative technologists and technologically literate artists. The typical student in my Creative Coding class is a true hybrid: an art or design undergraduate who is also studying computer science, human-computer interaction, or information science. They have strong visual abilities, strong cultural literacy, and strong algorithmic thinking skills, but my course may be the first time they've had the opportunity to bring those together.
+
+To me, that means giving students tools they can understand, modify, and remix to make systems of their own design, rather than treating creative software as a fixed given. That's why I'm such a proponent of community-driven, open-source software development toolkits for the arts.
+
+<Quote>ComfyUI is the first AI tool I've found with both a low floor and a high ceiling. It's incredibly powerful and flexible, in terms of allowing artists to design their own AI workflows with the latest cutting-edge algorithms. But it also leapfrogs the headaches of coping with quirky GitHub repos and obsolete Colab notebooks.</Quote>
+
+### What were students stuck on before?
+
+Students often found themselves caught between two worlds. On one side were commercial AI tools that produced impressive results but offered limited opportunities for customization. On the other side were research projects published by universities and laboratories, where the software was often difficult to install, poorly documented, or already out of date.
+
+ComfyUI bridges that gap. It gives students access to state-of-the-art algorithms through an environment they can understand, modify, and extend. Instead of adapting their ideas to fit a tool's built-in workflow, they can build workflows that reflect their own interests and questions.
+
+<Quote>My students are explorers. They're artists who can write code and want to build systems that haven't existed before.</Quote>
+
+</Section>
+
+<Section id="topic-3">
+
+### The first exercise: a p5.js sketch driving image synthesis, inside ComfyUI
+
+In one of Levin's introductory exercises — students' first exposure to the ComfyUI environment — they write a simple p5.js sketch directly inside ComfyUI, then use the shapes they draw, plus a text prompt, to guide a Stable Diffusion image synthesis. They document the pairs of images it produces: their JavaScript canvas drawing on the left, and the AI synthesis on the right. Having already spent a few weeks fighting to get nuance out of p5.js, they're tickled to get these results from simple shapes, and they learn a lot about how Stable Diffusion works.
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/p5-landscape.png" alt="p5.js ellipses guiding a Stable Diffusion synthesis" caption={`Some wide ellipses drawn in p5.js (left) guiding a Stable Diffusion synthesis with the prompt "rolling hills, foggy day" (right).`} />
+
+It runs on a node-based canvas that art students pick up quickly, because it works like tools they already know.
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/p5-workflow.png" alt="Template ComfyUI workflow using the ComfyUI-p5js-node" caption="The template ComfyUI workflow students receive. It uses the custom ComfyUI-p5js-node by Ben Fox. From Levin's 60-212 course repo." />
+
+*Try it yourself: [json file](https://media.comfy.org/website/customers/golan-levin/p5-in-comfy.json) (Comfy Local only)*
+
+</Section>
+
+<Section id="topic-4">
+
+### Many artists start off by using ComfyUI for generative AI. You use it differently.
+
+Maybe so. I'm interested in AI as a framework for expanded perception, so a lot of how I've used machine learning and computer vision over the past 25 years has been for image analysis, rather than image synthesis. Essentially, I use computer vision to understand video and images, and then use the information I extract to create new kinds of interactive experiences. In the classroom, I use ComfyUI to help teach students how to "see like a machine." So I have students use ComfyUI as a framework for analyzing images, not just generating them. For example, I ask them to take an input image and then use AI to compute new ones from it, such as a semantic segmentation ("which pixels belong to the elephant?") and a monocular depth estimate ("how far away is each pixel?"). Then the students build an interactive piece that interprets the original image, but using five channels of information instead of three: the usual red, green, and blue, plus depth, plus segmentation. In my demo project, the segmentation colors the elephant pink, and the background pixels change size based on how far away the AI thinks they are.
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/depth-segmentation.png" alt="Semantic segmentation and monocular depth analysis in ComfyUI" caption={`An input image analyzed inside ComfyUI: semantic segmentation and monocular depth, feeding a five-channel "Custom Pixel" exercise. From Levin's 60-212 course repo.`} />
+
+*Try it yourself: [demo project](https://editor.p5js.org/golan/sketches/-_cFmLtoP) · [lesson plan & workflow](https://github.com/golanlevin/60-212/tree/main/lectures/comfy/image_analysis#3-segment-the-image-with-ai)*
+
+*Workflow files: download the [.json](https://media.comfy.org/website/customers/golan-levin/image-analysis-workflow.json), or the [.png with the workflow embedded in its metadata](https://media.comfy.org/website/customers/golan-levin/image-analysis-workflow.png) (drag it into ComfyUI to load the graph).*
+
+<Quote>I want students to understand that AI is not only a tool for generating images. It's also a tool for perception, measurement, and analysis.</Quote>
+
+The computer vision tools built for this are usually aimed at developers and enterprises. They assume an engineering workflow. I wanted my art students to get to segmentation, depth, and tracking inside an environment they already think in, without standing up a production pipeline first.
+
+### What changed once ComfyUI was in the workflow?
+
+Two things. First, it runs on a node-based canvas that many art students already understand from environments like TouchDesigner, Max/MSP, and Grasshopper — except it runs in a browser and it's for AI. As a result, students can focus on the ideas behind machine learning workflows instead of first learning an entirely new interaction paradigm. Second, it collapses the distance between a research lab and a classroom.
+
+<Quote>There's a fast pipeline from the lab to your classroom. It's become commonplace for enthusiasts to convert AI research code into Comfy nodes, often within days of their release.</Quote>
+
+One of the most remarkable things about the ComfyUI ecosystem is how quickly new research becomes accessible. A computer-vision paper might appear at CVPR or ICCV, and within days someone in the community has wrapped it as a reusable ComfyUI node. For educators, that dramatically shortens the distance between a research laboratory and a classroom. Instead of spending weeks reconstructing an experimental software environment, students can begin exploring the underlying ideas almost immediately.
+
+The cloud matters for accessibility and equity, too. Most of my students don't have big GPU workstations, and I don't want their access to advanced tools to depend on the caliber of their personal hardware. Cloud platforms make it possible for everyone in a class to work in the same environment, with the same models, regardless of what laptop they happen to own.
+
+</Section>
+
+<Section id="topic-5">
+
+### In your advanced Experimental Capture studio, you've turned ComfyUI into a computer-vision lab.
+
+The goal of this course is to use technologies to help us see the world in new ways: the very fast, the very slow, the very small, the very large, and in spectra beyond human perception, like IR and UV. It's about cultivating the students' curiosity. But the limitation in this studio is hardware. We have one camera that can shoot 100,000 frames per second, one high-resolution thermal camera, and access to one electron microscope — but we've got 20 students. We can't always queue them all up for one exotic camera; it's a bottleneck.
+
+<Quote>I need to give them tools they can use to see the world in new ways, that they can all run on their own hardware.</Quote>
+
+ComfyUI allows students to use their own phones to ask questions they couldn't before. So they duct-tape their phone camera to a window, record the world going by, and then track things with the LocateAnything and SAM3 ComfyUI nodes, producing data files that distill what the camera saw. ComfyUI becomes a laboratory for computational observation, allowing students to ask questions of images and videos that would otherwise be difficult to formulate.
+
+### You also wrap niche research libraries into ComfyUI nodes yourself.
+
+One of the remarkable things about the ComfyUI ecosystem is the community that forms around it. There's a hero of mine on GitHub, Kijai, who keeps taking libraries from computer vision labs and turning them into ComfyUI nodes. He's made hundreds, probably doing more than anyone to turn lab-grade models into tools anyone can use. My students and I are starting to do this too. Niche is the right word. Right now I have my eye on a zoology lab that released a good library for tracking insect legs. The people who made it probably don't even know what ComfyUI is. But I want that algorithm for my students, and there's gotta be someone else out there who would love it too.
+
+### What's the bigger pattern you see in your students?
+
+My students are explorers. They see a new tool and immediately start wondering what else it could be connected to. They explore: I should be able to combine this thing with that other thing. That's the whole reason to give them a system they can build on, instead of a tool that tells them what they're allowed to do.
+
+<Quote>We're educating students who want to invent new forms and experiences, not just reproduce existing ones.</Quote>
+
+</Section>
+
+<Section id="topic-6" title="At a glance">
+
+<AtAGlance rows={[
+  { label: "Courses", value: "Intermediate Studio: Creative Coding (60-212); Experimental Capture (co-taught with Nica Ross)" },
+  { label: "Level", value: "Undergraduate (sophomore studio + advanced studio, ~20 students)" },
+  { label: "Setup", value: "Cloud-hosted ComfyUI; runs on students' own laptops" },
+  { label: "Core techniques", value: "p5.js-driven synthesis; semantic segmentation; monocular depth; LocateAnything + SAM3 tracking" },
+  { label: "Distinctive angle", value: "ComfyUI as computer-vision lab, not just a generator" }
+]} />
+
+</Section>
+
+<Section id="topic-7" title="Student work">
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/student-tippi.png" alt="Student work by Tippi Li" caption={`"nuclear explosion" by Tippi Li`} />
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/student-xiao.png" alt="Student work by Xiao Yuan" caption={`"Chinese painting, plants, ink, transparent" by Xiao Yuan`} />
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/student-aarnav.png" alt="Student work by Aarnav Patel" caption={`"NASA space image of a new cosmos detected" by Aarnav Patel`} />
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/student-jeffrey.png" alt="Student work by Jeffrey Wang" caption={`"Dream Scene Painting" by Jeffrey Wang`} />
+
+<Figure src="https://media.comfy.org/website/customers/golan-levin/student-kai.gif" alt="Student work by Kai Okorodudu" caption={`"Electric hand" by Kai Okorodudu`} />
+
+</Section>
+
+<AuthorBio people={[{ name: "Golan Levin", photo: "https://media.comfy.org/website/customers/golan-levin/author-golan.png" }]}>Golan Levin is a Professor of Computational Art at Carnegie Mellon University and co-author, with Tega Brain, of "Code as Creative Medium." This fall he is teaching two CMU courses with ComfyUI: "Intermediate Studio: Creative Coding" (60-212), built around p5.js, and "Experimental Capture," a studio in computational and expanded photography he co-teaches with Nica Ross. Levin is also widely known for interactive art installations driven by real-time machine vision, such as his [Augmented Hand Series](https://flong.com/archive/projects/augmented-hand-series/index.html) (2014), created with Kyle McDonald and Christine Sugrue.</AuthorBio>
+
+<EducationCta />

apps/website/src/content/customers/en/ina-conradi.mdx

@@ -0,0 +1,149 @@
+---
+title: "From Node Graph to Building Façade: how Ina Conradi's NTU students compose architectural-scale public art with ComfyUI"
+category: "CREATIVE CAMPUS SHOWCASE"
+description: "At NTU in Singapore, Ina Conradi's students compose 90-second films for building-sized LED walls that prompt boxes cannot render but ComfyUI can, work that travels from campus to Hangzhou's West Lake Media Façade and a million viewers a day."
+cover: "https://media.comfy.org/website/customers/ina-conradi/cover.png"
+order: 6
+sections:
+  - id: topic-1
+    label: "INTRO"
+  - id: topic-2
+    label: "THE CANVAS"
+  - id: topic-3
+    label: "WHY COMFYUI"
+  - id: topic-4
+    label: "THE 2026 BRIEF"
+  - id: topic-5
+    label: "STUDENT WORK"
+  - id: topic-6
+    label: "PUBLIC SCREENS"
+  - id: topic-7
+    label: "AT A GLANCE"
+---
+
+<Section id="topic-1">
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig1-quantum-logos.jpg" alt="Quantum Logos (Vision Serpent) on the Media Art Nexus LED screen" caption="Quantum Logos (Vision Serpent), Mark Chavez and Ina Conradi. Experimental animation, Media Art Nexus LED screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
+
+### Building an AI art pipeline from studio to screen
+
+Ina Conradi has written and taught NTU's two AI courses since 2022: DM2012, Explorations in AI-Generated Art (undergraduate), and AP7055, Art in the Age of the Creative Machine (postgraduate). Each runs about 30 students a semester. Working alongside her on the production pipeline is Mark Chavez, an animation veteran (DreamWorks, Rhythm & Hues) and early ComfyUI adopter. Together they co-curate the platform those courses build for: a 15-metre by 2-metre LED wall installed at NTU's North Spine in 2016 as Media Art Nexus, now run by NTU Museum as NTU Index and still taking new work each semester.
+
+Work from the wall has travelled to giant public screens in Singapore (Ten Square), Hangzhou, and Chongqing, and into collaborations with Bauhaus University, the University of the Arts Berlin, and the Elbphilharmonie in Hamburg.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig2-nature-sanctuary.jpg" alt="Nature Sanctuary 3000 on the West Lake Media Façade" caption="Nature Sanctuary 3000, Sowmya Sreeshna. Experimental animation, West Lake Media Façade (170 m × 18 m), Hangzhou, China. Photo: Limpid Art." />
+
+</Section>
+
+<Section id="topic-2">
+
+### Ina, your students don't make films for laptops. Why screens the size of buildings?
+
+Because the format teaches. A 90-second film at 6K across, in an 8:1 panorama, cannot be a lucky prompt. It has to be composed. And the screens are real: the strongest student work plays on NTU Index, our 15-metre by 2-metre wall on campus, and travels to urban façades in China and Europe through the City Digital Skin Art Festival (CDSA). When a student knows a million people a day might walk past their film in Hangzhou, the conversation about craft changes.
+
+### Mark, describe the canvas.
+
+Basically, we do compositions for really large media LED screens in Singapore and China. We have a screen that's eight by one in Singapore. It's 5,888 by 768 pixels.Students create images in the class, usually about 6K resolution across, a long landscape panorama. The output is 90-second short films. Two minutes, 90 seconds. I'm not going to change. I love that format because it's manageable within the class.
+
+</Section>
+
+<Section id="topic-3">
+
+### That format breaks most AI tools. What happened?
+
+Runway is one of the tools we use, on an educational plan that has worked well for the school. The constraint we hit is format: Runway works in 16:9, and our 6K panoramas fall outside that. Last semester Midjourney gave us trouble at our resolution, and the upscale was difficult. So we're expanding the palette and bringing in ComfyUI alongside what we already run.
+
+<Quote>ComfyUI gave the cleanest results. Upscaling to 8K at a 1-by-8 panorama after composition is genuinely hard, and ComfyUI is the only pipeline that lets students compose image, motion, and upscale models together.</Quote>
+
+### What about the budget side?
+
+Budget will keep being an issue. The school supports us well, but new tools arrive every semester and students want to try them and build their own pipelines. Monthly per-seat licenses don't fit how a semester runs. Running ComfyUI locally is hard for students: most laptops don't have a GPU with enough VRAM, and getting it working takes real trial and error. Many would rather work from home, but the hardware blocks them, so they come into the lab. Others used Comfy Cloud. It charges a subscription, but it still cost significantly less than the prepaid tools, and the results were better. Either way they're chasing the same thing: a pipeline they can keep working on, wherever they are.
+
+### Ina, you insist these courses are not about tools. What are they about?
+
+My class isn’t about teaching a single tool. It is the responsive system students interact with across platforms, directing, critiquing, and shaping outputs through ongoing dialogue. ComfyUI fits this: a node graph is an argument you can read, question, and rebuild. A prompt box is not. Singaporean students become technically fluent very fast. What they need from arts education is the language to question what they're making, not just the skill to make it.
+
+</Section>
+
+<Section id="topic-4">
+
+### Ina, the 2026 brief sends students to the ocean. What's the assignment?
+
+The project is The Liquid Commons: Bringing Ocean Science into Global Media Architecture, developed in dialogue with OceanX, the organization behind the OceanXplorer research vessel, and the CDSA 2026 festival theme. The brief is strict: do not illustrate the science, translate it. The 2026 cohort is the first to build these films in ComfyUI with Topaz upscaling, working towards two real deadlines at once. Their pieces are in consideration for the OceanX Summit in Singapore this October, and jury-selected works will screen during the City Digital Skin Art Festival on Hangzhou's West Lake Media Façade: 170 metres by 18 metres, around a million viewers a day.
+
+<Quote>The delivery spec tells you why the tooling matters: final exports at 5,888 × 768 px, 8K where required. That's the brief no prompt box can fill.</Quote>
+
+</Section>
+
+<Section id="topic-5">
+
+### Mark, what does the student work look like?
+
+About eight students have built their films through Comfy so far, and they're all pretty cool. They're surprising and insightful, because they're not limited by game-engine graphics. One student was the standout: he tried every model in Comfy and pushed the furthest.
+
+Three projects from the 2026 cohort show the range.
+
+**The Tao of Water** (Wang Zilin, AP7055) reads the ocean through the Tao Te Ching, a three-part arc from water to marine plant to void and back to origin. The pipeline moves from Pinterest research boards through Midjourney into ComfyUI, where Nano Banana extends single frames into seamless panoramas and Kling 3.0 animates first-frame-to-last-frame motion at full 5,888-pixel width, before a Premiere edit.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig3-tao-of-water.jpg" alt="The Tao of Water on the NTU Index screen" caption="The Tao of Water, Wang Zilin. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
+
+**microscophony** (Jiin Ko, AP7055) fuses *microscopic* and *micropolyphony*, Ligeti's term for dense webs of voices that blur into a single cloud of sound. The source is based on OceanX microscope footage of deep-sea microbes, translated into the visual logic of graphic notation (Ligeti, Xenakis, Cardew) so the panorama becomes a listening score. Images ran through Midjourney and Nano Banana, video through ComfyUI with Vidu Q2, sound design in Ableton Live, with distinct sonic textures mapped to distinct visual forms.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig4-microscophony.jpg" alt="microscophony on the NTU Index screen" caption="microscophony, Jiin Ko. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
+
+**GO! PLASTIC** (Jianwei Hoe, DM2012) is an ocean-plastics piece whose production log reads like studio paperwork, not prompt history. It opens with a one-line art direction (every project states its idea in a single line, with embedded irony, before a frame is generated), then walks through model selection, a platform-versus-local cost comparison (cost per clip and per scene on an RTX 5090 against a cloud B200, render times included), and a shot-by-shot sheet pairing every source image with its full prompt and settings.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig5-go-plastic.jpg" alt="GO! PLASTIC on the NTU Index screen" caption="GO! PLASTIC, Hoe Jianwei. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
+
+</Section>
+
+<Section id="topic-6">
+
+### Ina, where does the work go after the classroom?
+
+Onto public screens, and into juried international competition. The City Digital Skin Art Festival was established in 2023, initiated by the China Academy of Art's School of Sculpture and Public Art and co-curated with Public Art Lab Berlin, MEET Digital Culture Center Milan, and NTU ADM, with a network of more than 29 art academies across China and Europe.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig6-cdsa-awards.jpg" alt="CDSA Festival award winners on the West Lake Media Façade" caption="CDSA Festival award winners, curators, and organizers. West Lake Media Façade (170 m × 18 m), Hangzhou, China. Photo: Limpid Art. Asia's largest high-definition outdoor screen" />
+
+The 2024 edition ran across 11 LED screens in 9 cities in 5 countries and reached over 100 million views. The 2025–2026 edition, themed Memory Coexistence, drew over 200 international submissions, with the top 40 selected by a 16-member jury. I curate the Singapore programme across NTU Index and the Ten Square landmark façade. A student composing at 6K in our classroom is composing for that circuit.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig7-crispr.jpg" alt="Crispr on the Ten Square Landmark Façade" caption="Crispr, Lee Chaewon. Experimental animation, Ten Square Landmark Façade (21.2 m × 14.4 m), Singapore. Photo: Quek Jia Liang." />
+
+NTU ADM students have already won at this level. At CDSA 2025, the majority of the top awards went to students from these two courses: Gold (Sun Yutong, *Echoes of Her*), Silver (Tan Yu Yan Cheerie, *Eternal Flux*), Bronze (Shah Pranjal Kirti, *Mumbai Miniatures*), Business (Ong Sze Ching, *Nuwa*), and Creative (Leah Chakola, *Caravan of Memory*). The courses have also taken NTU to Ars Electronica in Linz as the only Singapore campus partner since 2023, first with *Butterfly's Dreams* (2023, "Who Owns the Truth?") and then in 2025 with *Beyond the Screen*, a joint exhibition with the China Academy of Art and Bauhaus-Universität Weimar.
+
+### Mark, you spent a decade at DreamWorks. Why does this tool fit art students?
+
+I come from visual effects. I was at DreamWorks about ten years, then Rhythm & Hues, then the game industry and big interactive installations. I'm not a programmer, so I love ComfyUI.
+
+<Quote>Everybody I know who does graphics now is using this, because it's so adaptable. Sometimes we use Comfy as just a back end. That's what everybody's doing.</Quote>
+
+We got this large 15-metre by 2-metre screen in an art installation at the university, and it let us explore media and different techniques. We found students weren't technical enough to handle TouchDesigner, so they just started making movies. Then I started playing with AI, and now everything's AI. What I'd love next is templates custom-made for these screens.
+
+Take *Echoes, Whispers and Memories*, the piece Ina and I made. We don't use Comfy to spit out finished illustrations. We build workflows that keep recomposing the image, breaking it apart and putting it back together so it evolves on screen, which is the whole point: entropy, memory, things falling apart and reforming. Then we push those outputs into real-time and projection systems for big rooms, places like Ars Electronica's Deep Space 8K and MEET in Milan.
+
+<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig8-echoes.jpg" alt="Echoes, Whispers and Memories at Ars Electronica Deep Space 8K" caption="Echoes, Whispers and Memories, Mark Chavez and Ina Conradi. AI-generated immersive installation using ComfyUI, Deep Space 8K, Ars Electronica, Linz, Austria. Photo: Wolfgang Simlinger." />
+
+### The signal from the industry
+
+<Quote>I hear from my students looking for internships or jobs that the first question over there is, "Do you know Comfy?" Because they want to hire kids who know the pipeline.</Quote>
+
+</Section>
+
+<Section id="topic-7" title="At a glance">
+
+<AtAGlance rows={[
+  { label: "Institution", value: "Nanyang Technological University, School of Art, Design and Media (Singapore)" },
+  { label: "Courses", value: "DM2012: Explorations in AI-Generated Art (UG) and AP7055: Art in the Age of the Creative Machine (PG), written and taught by Ina Conradi since 2022; ~30 students/semester" },
+  { label: "The canvas", value: "6K-wide, 8:1 LED walls in Singapore and China; NTU Index wall on campus (15 m × 2 m, 5,888 × 768 px)" },
+  { label: "Core technique", value: "ComfyUI compositions with Topaz upscaling for ultra-wide panoramic output; production logs with per-clip cost and prompt sheets" },
+  { label: "Why Comfy won", value: "Hosted tools locked to 16:9; upscaling to 8K at a 1-by-8 panorama after composition needed a multi-model pipeline; per-seat monthly renewals didn't fit the semester" }
+]} />
+
+</Section>
+
+<AuthorBio label="About the authors" people={[
+  { name: "Ina Conradi", photo: "https://media.comfy.org/website/customers/ina-conradi/author-ina.jpg", bio: `Ina Conradi is an artist and curator based between Singapore and Los Angeles. She is founding faculty at NTU's School of Art, Design and Media (est. 2005), where she has written and taught the school's AI courses since 2022. Her film Moirai: Thread of Life won Best in Show at the SIGGRAPH Asia Computer Animation Festival 2023, a first for Singapore.` },
+  { name: "Mark Chavez", photo: "https://media.comfy.org/website/customers/ina-conradi/author-mark.jpg", bio: `Mark Chavez is an animator, director, and founding faculty at NTU's School of Art, Design and Media in Singapore. After a decade at DreamWorks Animation and visual effects work at the original Rhythm & Hues Studios, he established NTU's Digital Animation area (2005) and an animation research think-tank funded by Singapore's National Research Foundation and the Media Development Authority.` }
+]} />
+
+<EducationCta />

apps/website/src/content/customers/en/kathy-smith.mdx

@@ -0,0 +1,138 @@
+---
+title: "Built for AI: Prof. Kathy Smith on USC's Expanded Animation program and ComfyUI"
+category: "CREATIVE CAMPUS SHOWCASE"
+description: "Inside the experimental USC MFA that put AI into animation pedagogy from day one, and the student pipelines it produced."
+cover: "https://media.comfy.org/website/customers/kathy-smith/cover.png"
+order: 8
+sections:
+  - id: topic-1
+    label: "THE PROGRAM"
+  - id: topic-2
+    label: "TEACHING WITH AI"
+  - id: topic-3
+    label: "WHY COMFYUI"
+  - id: topic-4
+    label: "STUDENT WORK"
+  - id: topic-5
+    label: "AT A GLANCE"
+  - id: topic-6
+    label: "WHAT'S NEXT"
+---
+
+<Section id="topic-1">
+
+### You built the Expanded Animation program in 2022 specifically to put AI into the curriculum from day one. What did you see that other programs missed?
+
+We created Expanded Animation: Research and Practice specifically to focus on creative process and AI as part of how animators learn to make work. The thesis at the start was that AI was going to reshape animation as a medium, and the question was not whether to teach it but how to embed it in the curriculum so students learn it as part of their creative process rather than as a separate technical specialty.
+
+USC's School of Cinematic Arts already had decades of cinematic storytelling tradition. What we did with XA was put AI inside that tradition. The conceptual thinking, the storytelling, the cinematic history come first. AI is one of the many tools available to them, sitting alongside hand-drawing, paint, 3D, and live-action footage. Students do not learn AI in one course and animation in another. They learn both side by side.
+
+The students who arrive at the program are usually self-selected for it. They show up technically fluent, with their own GPU-equipped laptops. What we offer them is the storytelling, the cinematic history, and the conceptual frame. They bring the technical nimbleness.
+
+<Quote>They are way ahead of the curve. They are ahead of the faculty in the way they work, technically, but not so much artistically. That is what we are there to deliver.</Quote>
+
+<Figure src="https://media.comfy.org/website/customers/kathy-smith/usc-campus.png" alt="USC School of Cinematic Arts" caption="USC School of Cinematic Arts. Source: USC Today" />
+
+</Section>
+
+<Section id="topic-2">
+
+### How do you actually structure an AI assignment? Walk us through one.
+
+In my Animation, Dreams, and Consciousness class, I have the students document their dreams and then use the dream as the source. Some of them draw, some of them write. The dream becomes the prompt, and they generate the image and emotion of the dream. I love when you get six fingers and weird stuff happening in the algorithms. Our human perception in dreams is often doing the same thing. Therefore, AI is evolving and dreaming with us.
+
+That structure is deliberate. The students are not asking the model to produce work for them. They are using it as a layer of their process, alongside hand-drawing and painting and 3D rendering and live-action footage. The work that comes out is theirs because the creative decisions are theirs. The tool just gives them new ways to reach what they were trying to make.
+
+There is a fear factor around AI, and I understand it. There has been a lot of scraping of artists' work, and that conversation is real and is going to take time to resolve. But I have been working with AI conceptually since 1998, and the way I describe the data sets to my students is that they are a repository of all of our creation. It is like the collective unconscious of the human mind. Artists have always drawn from everything around them.
+
+<Quote>What really matters is what the artist does with it, *intentionality*.</Quote>
+
+</Section>
+
+<Section id="topic-3">
+
+### Why does ComfyUI specifically fit the way your students work?
+
+It is the node-based system. Those who have done Houdini feel very at home in Comfy. You can work with the prompts, but it is very visual. That is what they are used to. They are not asking a black box for an output. They are building a workflow.
+
+And it stays in its lane. The students are not using Comfy to make AI art. They are using Comfy as one node graph alongside Blender, hand-drawn frames, paint, and live-action footage. The reason it fits is that it does not try to be the whole pipeline. It is one stage of a creative practice that still has cinema at its core.
+
+What also matters is that Comfy is open and inspectable. The students can see what the model is doing at each step, fork a workflow, swap a sampler, drop in a custom node, and share what they built with the next cohort. That is closer to how an animation studio tradition has always behaved, with techniques passed along and improved rather than hidden behind a paywall.
+
+They also work across whatever hardware they have: Comfy Cloud at home and when they are mobile, the portable version on their personal laptops, and the research computer in my office for the high-end runs. Animation students do not sit in one cubicle for a thesis project. They work everywhere.
+
+</Section>
+
+<Section id="topic-4">
+
+### Tell us about the work coming out of the program.
+
+The pattern shows up across the cohort: the AI is in service of the cinematic story, not in place of it. Three students walked us through how Comfy actually sits inside their pipelines.
+
+#### Sijia Zheng — Ori & Kiddo
+
+<Figure src="https://media.comfy.org/website/customers/kathy-smith/ori-kiddo.png" alt="Sijia Zheng, Ori & Kiddo" />
+
+**What Comfy enabled:** an oil-paint, brush-stroke dream look that "other AI tools cannot possibly make," held consistent across shots with IP-Adapter style transfer and a custom LoRA.
+
+*Ori & Kiddo* follows two ghosts who, after the universe dies, search for old human memories, rediscover love, and reverse the universe back into being. Most of the film is hand-drawn 2D. Comfy enters in the dream sequences, where the ghost Kiddo dreams of past lives and the look had to be unlike anything else in the film. Sijia drew stylized reference images first, then used them as the style reference over video clips through an IP-Adapter workflow to produce long, oil-painted, brush-stroke sequences. The same control shows up in shots where Sijia appears on screen: real footage, masked in Comfy to change the haircut and swap the background. For a look that has to stay locked, Sijia trains a LoRA and runs it through Comfy.
+
+Sijia found Comfy in early 2025 while hunting for a style-transfer tool that Midjourney and DALL-E could not deliver, testing it on a stylized animated-film-look conversion.
+
+<Quote>It totally broke my mind. Most of the time, I think I'll just stand on other people's shoulders. The workflows are already pretty amazing, and I'll base on the workflows and add something that I want.</Quote>
+
+Since *Ori & Kiddo*, Sijia has taken the same Comfy-anchored workflow into professional commercial video work, on deadlines as tight as four days.
+
+#### Ion Yunyang Li — L1LY
+
+<Figure src="https://media.comfy.org/website/customers/kathy-smith/l1ly.gif" alt="Ion Yunyang Li, L1LY" />
+
+**What Comfy enabled:** a repeatable multi-step pipeline that drops the filmmaker into a photorealistic world, because "a sequence of a prompt is not the only thing you need."
+
+Ion taught himself ComfyUI in early 2025, from tutorials in the generative-AI community, and built his most distinctive Comfy work in a body-and-environment project: start from 3D-model stills, convert them to a pencil-sketch style so the model would not over-study the original 3D aesthetic, generate photorealistic frames from the sketches, build character T-poses, composite himself into the scene, and animate the stills with a video model.
+
+<Quote>A sequence of a prompt is not the only thing you need. You need many different settings, and it is very hard to redo those settings every time.</Quote>
+
+What he values as much as the pipeline is where it can run: the same Comfy setup moves across a workstation in his school cubicle, a remote session from his apartment laptop, and fully cloud-based instances, depending on where he is.
+
+#### Sihan Wu — Scary Coaster
+
+<Figure src="https://media.comfy.org/website/customers/kathy-smith/scary-coaster.gif" alt="Sihan Wu, Scary Coaster" />
+
+**What Comfy enabled:** roughly 100 hand-drawn keyframes carried through a single workflow so a two-to-three-minute film stays visually consistent, on his first-ever AI project.
+
+*Scary Coaster* (December 2024) was Sihan's first project ever made with AI. Coming from a digital-media and game-development undergrad, Sihan joined Professor Smith's Expanded Animation class and wanted something more controllable than the prompt-only tools on offer. The workflow he built: draw roughly 100 rough keyframes by hand, run them through Comfy to find a stylized Chinese-horror look, pick the favorite, then generate the in-betweens to produce the full sequence.
+
+<Quote>I want to have a more controllable flow. I don't want to just use prompts and generate random images. I just use one workflow to create the whole two or three minutes, and I can make everything look very consistent.</Quote>
+
+Sihan is honest that the on-ramp was steep: learning from the official ComfyUI GitHub workflows, combining them, and debugging Python environments along the way. His ask was specific: an official, beginner-to-advanced tutorial series. And his view on where AI should head next was equally specific: aim it at "the very time-consuming but not that creative process, like creating in-betweens," and leave the creative decisions to the artist.
+
+</Section>
+
+<Section id="topic-5" title="At a glance">
+
+<AtAGlance rows={[
+  { label: "Program", value: "Expanded Animation: Research + Practice (XA), USC School of Cinematic Arts" },
+  { label: "Founded", value: "2022, AI embedded in the MFA curriculum from day one" },
+  { label: "Setup", value: "Students' own GPU laptops + Comfy Cloud + lab research machine" },
+  { label: "Core techniques", value: "IP-Adapter style transfer, custom LoRAs, masked compositing, keyframe-to-in-between pipelines" },
+  { label: "Outcomes", value: "Amazing student works from Sihan, and Ion, Sijia" }
+]} />
+
+</Section>
+
+<Section id="topic-6">
+
+### What excites you about where this is going?
+
+I have a philosophy that everyone is an artist. They just forget that they are an artist. Creativity drives everything, and the tools we are getting now make it possible for more people to find that capacity in themselves. ComfyUI, because it is node-based and visual and open, gives non-programmers a way forward that is honest about how the model works. It does not pretend the AI is doing something magical. It shows the artist what is happening at each step.
+
+The two basic rights of human life are health and education. The work Comfy is doing on the education side is touching something integral. The students who came through XA are already extending the work in directions the program did not anticipate, and the next generation of educators and students will keep doing the same.
+
+<Quote>Everyone is an artist. They just forget that they are an artist.</Quote>
+
+</Section>
+
+<AuthorBio people={[{ name: "Kathy Smith", photo: "https://media.comfy.org/website/customers/kathy-smith/kathy-smith.jpg", bio: `Kathy Smith is Professor of Cinematic Arts at USC's School of Cinematic Arts and inaugural director (2022-2023) of Expanded Animation: Research + Practice (XA), the experimental MFA program she helped found in 2022 to integrate AI into animation pedagogy from the first day of the degree. To date she is the longest-serving chair of combined USC animation programs and has been exploring concepts of AI in her creative practice since 1998.` }]} />
+
+<EducationCta />

apps/website/src/content/customers/en/ual-cci.mdx

@@ -0,0 +1,56 @@
+---
+title: "Comfy and UAL's Creative Computing Institute Announce Creative Campus Partnership"
+category: "CREATIVE CAMPUS PARTNERSHIP"
+description: "Comfy announces Creative Campus Partnership to support teaching and research across UAL CCI's masters, PhD, and industry programmes"
+cover: "https://media.comfy.org/website/customers/ual-cci/cover.png"
+order: 9
+sections:
+  - id: topic-1
+    label: "INTRO"
+  - id: topic-2
+    label: "WHAT CCI DOES"
+  - id: topic-3
+    label: "THE PARTNERSHIP"
+  - id: topic-4
+    label: "ABOUT CCI"
+---
+
+<Section id="topic-1">
+
+Comfy Org, the team behind ComfyUI, the open-source node-based interface for generative AI, and the Creative Computing Institute (CCI) at University of the Arts London today announced a Creative Campus partnership, making CCI a founding partner of the [Comfy Education Initiative](https://comfy.org/education).
+
+</Section>
+
+<Section id="topic-2">
+
+CCI already runs ComfyUI at every level of the institute. On the Applied Machine Learning for Creatives masters course, students build image, video, audio, and text workflows, train their own models, and construct interactive pipelines. PhD researchers use Comfy for fine-tuning, custom datasets, and custom node development. The institute also uses ComfyUI in industry training, where its node-based interface gives non-technical collaborators a way into generative AI that code alone does not.
+
+<Quote name="Prof Mick Grierson, Research Leader, UAL Creative Computing Institute">ComfyUI has become part of how we teach, research, and work with industry. It is one of the few generative AI environments where the workflows our students build are portable, inspectable, and forkable, and that open-source foundation is exactly what a university should be teaching on.</Quote>
+
+</Section>
+
+<Section id="topic-3">
+
+Through the partnership, CCI educators and students gain access to classroom licenses with central billing & administration, educational discounts, early access to upcoming team features, a dedicated educator community with direct support from the Comfy team, and a voice in shaping the future of the education program.
+
+Creative Campus partnerships are the deepest tier of the program: a direct, ongoing collaboration in which an institution works hand in hand with the Comfy team to roll out ComfyUI across teaching, research, and industry training.
+
+<Quote name="The Comfy Team">CCI is the model we hope every creative campus follows: ComfyUI in the masters classroom, in PhD research, and in industry collaboration, all at once. As our first Creative Campus Partner, they are helping us design an education program that works the way universities actually work.</Quote>
+
+<Figure src="https://media.comfy.org/website/customers/ual-cci/cci-camberwell.jpg" alt="Creative Computing Institute campus at UAL" caption="Creative Computing Institute Campus. Photo: Ana Escobar, courtesy UAL." />
+
+The institute is leading a major £1.5 million publicly funded research programme developing copyright-compliant audiovisual foundation models for the UK's creative industries. Bringing together expertise in sound, image, and artificial intelligence, the project is building open tools and responsible AI national infrastructure designed to support UK creative production, research, and experimentation across the sector.
+
+The outputs of the research will explore wider dissemination and adoption through open, node-based tools such as ComfyUI to support experimentation, workflows, and collaboration around emerging multimodal AI systems.
+
+UAL CCI joins a founding cohort of educators and institutions featured at the launch of the Comfy Education Initiative, alongside researchers such as CCI co-founder Dr. Phoenix Perry, whose Antigravity Machine project Comfy supports as an industry partner.
+
+</Section>
+
+<Section id="topic-4" title="About the Creative Computing Institute at UAL">
+
+The Creative Computing Institute at University of the Arts London applies computing to creativity and social impact, operating at the intersection of computational technologies and creative practice, teaching undergraduate, postgraduate, and PhD students alongside research and industry collaboration.
+
+</Section>
+
+<EducationCta />

apps/website/src/content/customers/en/xindi-zhang.mdx

@@ -0,0 +1,103 @@
+---
+title: "The tool that expands my art: Xindi Zhang's Oscar-shortlisted thesis, built in ComfyUI"
+category: "CREATIVE CAMPUS SHOWCASE"
+description: "How a USC Expanded Animation thesis became a Student Academy Award winner, an Oscar shortlist entry, and helped land a job at Amazon — with the artist's own illustrations as the style guide."
+cover: "https://media.comfy.org/website/customers/xindi-zhang/cover.webp"
+order: 5
+sections:
+  - id: topic-1
+    label: "INTRO"
+  - id: topic-2
+    label: "WHY COMFYUI"
+  - id: topic-3
+    label: "THE PIPELINE"
+  - id: topic-4
+    label: "AT A GLANCE"
+  - id: topic-5
+    label: "WHAT'S NEXT"
+---
+
+<Section id="topic-1">
+
+<Embed src="https://player.vimeo.com/video/1131160045" title="The Song of Drifters by Xindi Zhang" />
+
+*From The Song of Drifters. Film images: Xindi Zhang.*
+
+### Tell us about The Song of Drifters. What is it about, and where did it start?
+
+The Song of Drifters is a documentary animation about people caught between leaving and returning, wanderers who drift through unfamiliar cities, holding onto memories of a homeland out of reach and searching for a sense of belonging. The title is a direct translation from an ancient Chinese poem about a mother's love for a child who leaves her hometown. My version takes the opposite point of view, from the child's perspective.
+
+I built the film in ComfyUI. When I started, I was not trying to show what AI could do. I was trying to prove something almost opposite.
+
+<Quote>It started as a challenge to the stereotype that AI-generated work is generic and cheap. I wanted to prove that AI could be an amplifier for personal vision, not a replacement for it.</Quote>
+
+</Section>
+
+<Section id="topic-2">
+
+### You came to this from illustration, not engineering. How did you end up in ComfyUI?
+
+I started as an illustrator. I earned my BFA in illustration at the Rhode Island School of Design, then worked as a game concept artist, where I picked up shaders, Unity, and Unreal. That technical side made me a fast learner with new tools. Later I went to USC's School of Cinematic Arts for an MFA in Expanded Animation, where I studied with Professor Kathy Smith.
+
+By my thesis year I had moved from Stable Diffusion's standard interfaces to ComfyUI, because I think in node-based structures and I wanted to control every step. Most AI tools are one click: you prompt, you click, you get a result. That is not what I wanted.
+
+<Quote>I want to control the process, and the process is even more important than the result itself. For artists like me, I don't want to automate anything. I want to participate in every single stage of designing the workflow. That's the fun part of it.</Quote>
+
+</Section>
+
+<Section id="topic-3">
+
+### Walk us through the pipeline. What were you actually feeding the model?
+
+<Figure src="https://media.comfy.org/website/customers/xindi-zhang/balloon-workflow.png" alt="Xindi's ComfyUI workflow for the balloon sequence">Xindi's ComfyUI workflow for the balloon sequence. Source: [xindizhangart.com](https://xindizhangart.com).</Figure>
+
+My core technique was style transfer in Stable Diffusion 1.5, driven by IP-Adapter and ControlNet. What mattered most was what I fed it: my own work. The base materials were live-action footage I shot on an iPhone 15 Pro and 3D animation I built in Blender. The AI restyled imagery I had already made. It did not invent it.
+
+<Figure src="https://media.comfy.org/website/customers/xindi-zhang/film-still.jpg" alt="Style-guide still from The Song of Drifters">Style-guide still from The Song of Drifters. Source: [xindizhangart.com](https://xindizhangart.com).</Figure>
+
+<Quote>Unlike most AI-generated videos, which use other artists' works from the model, I use my own illustrations as the style guide.</Quote>
+
+<Download href="https://media.comfy.org/website/customers/xindi-zhang/workflows/style-transfer-workflow.json" label="Download Xindi's style transfer workflow (json) on ComfyUI" />
+
+I also trained custom LoRAs on my own video, footage of the cities I had lived in. Capturing that footage became a vital part of the documentary process. Wandering through the streets where I once lived let me reconnect with those cities. Most of it never appears in the final cut, but it lives in the visuals as training data. The hybrid pipeline made rendering the final look more efficient and saved more time for ideation.
+
+For the dream sequences I combined animated 3D with AI morphing, moving from abstract to concrete to mimic the feeling of being half awake.
+
+<Video src="https://media.comfy.org/website/customers/xindi-zhang/bts-clip.mp4" poster="https://media.comfy.org/website/customers/xindi-zhang/bts-poster.jpg" caption="BTS clip, AI morphing. Source: Xindi Zhang." />
+
+<Download href="https://media.comfy.org/website/customers/xindi-zhang/workflows/morphing-workflow.json" label="Download Xindi's AI morphing workflow (json) on ComfyUI" />
+
+</Section>
+
+<Section id="topic-4" title="At a glance">
+
+<AtAGlance rows={[
+  { label: "Program", value: "USC School of Cinematic Arts — MFA Expanded Animation (thesis)" },
+  { label: "Base materials", value: "iPhone 15 Pro live-action; her own Blender 3D animation" },
+  { label: "Core technique", value: "Style transfer in SD 1.5 via IP-Adapter + ControlNet, in ComfyUI" },
+  { label: "Style source", value: "Her own illustrations + custom LoRAs trained on her own city footage" },
+  { label: "Finishing", value: "Depth, mask, and fade passes in After Effects; heavy compositing" },
+  { label: "Outcome", value: "Student Academy Awards Golden Award (2025); 98th Academy Awards shortlist; AI Creative role at Amazon AI Studio" }
+]} />
+
+</Section>
+
+<Section id="topic-5">
+
+### The film won gold at the Student Academy Awards and was shortlisted for the Oscars. What's next?
+
+I made the film for creative reasons, not career ones. I honestly did not expect it to connect to a job at all. Then it won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the Oscars, and the calls started.
+
+<Figure src="https://media.comfy.org/website/customers/xindi-zhang/awards.png" alt="Xindi Zhang at the 2025 Student Academy Awards" caption="Xindi Zhang at the 2025 Student Academy Awards. Source: Oscars Press Office." />
+
+What people wanted was the combination: someone who understands both traditional craft and AI tools. I now work as an AI Creative at Amazon AI Studio building custom production pipelines. I see that same demand across the industry, with ComfyUI experience starting to show up as a requirement in job postings at major studios and design agencies.
+
+<Quote>It's not the tool that steals my art. It's the tool that expands my art.</Quote>
+
+My advice to other students is not really about software. AI is just another tool to convey ideas, but nothing is more important than the story itself. If you use AI, use it on purpose. The more you understand it, the more freedom you have to make work that is genuinely yours.
+
+</Section>
+
+<AuthorBio people={[{ name: "Xindi Zhang", photo: "https://media.comfy.org/website/customers/xindi-zhang/profile.jpg", bio: `Xindi Zhang is a Chinese animation director and visual artist (RISD BFA in illustration, 2020; USC MFA in Expanded Animation, 2025). The Song of Drifters won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the 98th Academy Awards. She works as an AI Creative at Amazon AI Studio, has collaborated with Sony Music's immersive studio, and is now on the faculty at the University of South Florida.` }]} />
+
+<EducationCta />

apps/website/src/styles/global.css

@@ -61,6 +61,11 @@
 
 @theme {
   --color-site-dropdown: #332b38;
+  --color-site-bg-soft: color-mix(
+    in srgb,
+    var(--color-primary-comfy-ink) 88%,
+    black 12%
+  );
   --color-primary-comfy-yellow: #f2ff59;
   --color-primary-comfy-ink: #211927;
   --color-primary-comfy-ink-light: #2a2330;
@@ -261,6 +266,6 @@ video::-webkit-media-controls-panel {
 
 :root {
   --site-bg: var(--color-primary-comfy-ink);
-  --site-bg-soft: color-mix(in srgb, var(--site-bg) 88%, black 12%);
+  --site-bg-soft: var(--color-site-bg-soft);
   --site-border-subtle: rgb(255 255 255 / 0.1);
 }

browser_tests/tests/dialogs/pricingTableDeepLink.spec.ts

@@ -28,7 +28,12 @@ const APP_URL = process.env.PLAYWRIGHT_TEST_URL || 'http://localhost:8188'
 // matches it against the members self-row.
 const SELF_EMAIL = 'e2e@test.comfy.org'
 
-const BOOT_FEATURES = { team_workspaces_enabled: true } satisfies RemoteConfig
+// consolidated_billing_enabled routes personal workspaces to the unified
+// pricing table asserted here; without it they fall back to the legacy table.
+const BOOT_FEATURES = {
+  team_workspaces_enabled: true,
+  consolidated_billing_enabled: true
+} satisfies RemoteConfig
 // Disable the experimental Asset API: with it on (cloud default) the unmocked
 // asset endpoints 403 and workflow restore throws uncaught, aborting the
 // GraphCanvas onMounted chain before the deep-link loader.

src/components/dialog/content/TopUpCreditsDialogContentLegacy.vue

@@ -158,8 +158,8 @@ import { creditsToUsd, usdToCredits } from '@/base/credits/comfyCredits'
 import Button from '@/components/ui/button/Button.vue'
 import FormattedNumberStepper from '@/components/ui/stepper/FormattedNumberStepper.vue'
 import { useAuthActions } from '@/composables/auth/useAuthActions'
+import { useBillingRouting } from '@/composables/billing/useBillingRouting'
 import { useExternalLink } from '@/composables/useExternalLink'
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { useSubscription } from '@/platform/cloud/subscription/composables/useSubscription'
 import { useTelemetry } from '@/platform/telemetry'
 import { clearTopupTracking } from '@/platform/telemetry/topupTracker'
@@ -178,7 +178,7 @@ const settingsDialog = useSettingsDialog()
 const telemetry = useTelemetry()
 const toast = useToast()
 const { buildDocsUrl, docsPaths } = useExternalLink()
-const { flags } = useFeatureFlags()
+const { shouldUseWorkspaceBilling } = useBillingRouting()
 
 const { isSubscriptionEnabled } = useSubscription()
 // Constants
@@ -260,9 +260,9 @@ async function handleBuy() {
     // Close top-up dialog (keep tracking) and open credits panel to show updated balance
     handleClose(false)
 
-    // In workspace mode (personal workspace), show workspace settings panel
-    // Otherwise, show legacy subscription/credits panel
-    const settingsPanel = flags.teamWorkspacesEnabled
+    // On the consolidated (workspace) billing flow, show the workspace settings
+    // panel; otherwise show the legacy subscription/credits panel.
+    const settingsPanel = shouldUseWorkspaceBilling.value
       ? 'workspace'
       : isSubscriptionEnabled()
         ? 'subscription'

src/components/dialog/content/setting/UsageLogsTable.test.ts

@@ -2,12 +2,11 @@ import { createTestingPinia } from '@pinia/testing'
 import PrimeVue from 'primevue/config'
 import Tooltip from 'primevue/tooltip'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { defineComponent, onMounted, ref } from 'vue'
+import { defineComponent, nextTick, onMounted, ref } from 'vue'
 import { createI18n } from 'vue-i18n'
 
 import { render, screen, waitFor } from '@testing-library/vue'
 
-import type * as DistributionTypes from '@/platform/distribution/types'
 import type { AuditLog } from '@/services/customerEventsService'
 import { EventType } from '@/services/customerEventsService'
 
@@ -35,19 +34,29 @@ vi.mock('@/services/customerEventsService', () => ({
   }
 }))
 
+const mockTelemetry = vi.hoisted(() => ({
+  checkForCompletedTopup: vi.fn()
+}))
 vi.mock('@/platform/telemetry', () => ({
-  useTelemetry: () => null
+  useTelemetry: () => mockTelemetry
 }))
 
-const mockFlags = vi.hoisted(() => ({ teamWorkspacesEnabled: false }))
-vi.mock('@/composables/useFeatureFlags', () => ({
-  useFeatureFlags: () => ({ flags: mockFlags })
-}))
-
-vi.mock('@/platform/distribution/types', async (importOriginal) => ({
-  ...(await importOriginal<typeof DistributionTypes>()),
-  isCloud: true
+const mockBillingRouting = vi.hoisted(() => ({
+  shouldUseWorkspaceBilling: false
 }))
+vi.mock('@/composables/billing/useBillingRouting', async () => {
+  const { ref } = await import('vue')
+  const shouldUseWorkspaceBilling = ref(false)
+  Object.defineProperty(mockBillingRouting, 'shouldUseWorkspaceBilling', {
+    get: () => shouldUseWorkspaceBilling.value,
+    set: (value: boolean) => {
+      shouldUseWorkspaceBilling.value = value
+    }
+  })
+  return {
+    useBillingRouting: () => ({ shouldUseWorkspaceBilling })
+  }
+})
 
 const mockWorkspaceApi = vi.hoisted(() => ({
   getBillingEvents: vi.fn()
@@ -68,7 +77,10 @@ const i18n = createI18n({
         additionalInfo: 'Additional Info',
         added: 'Added',
         accountInitialized: 'Account initialized',
-        model: 'Model'
+        model: 'Model',
+        loadEventsError: 'Failed to load activity. Please try again.',
+        loadEventsUnknownError:
+          'Something went wrong while loading activity. Please refresh and try again.'
       }
     }
   }
@@ -95,6 +107,11 @@ const AutoRefreshWrapper = defineComponent({
   template: '<UsageLogsTable ref="tableRef" />'
 })
 
+async function flushMicrotasks() {
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  await nextTick()
+}
+
 function makeEventsResponse(
   events: Partial<AuditLog>[],
   overrides: Record<string, unknown> = {}
@@ -137,7 +154,7 @@ describe('UsageLogsTable', () => {
 
     mockCustomerEventsService.getMyEvents.mockResolvedValue(mockEventsResponse)
     mockWorkspaceApi.getBillingEvents.mockResolvedValue(mockEventsResponse)
-    mockFlags.teamWorkspacesEnabled = false
+    mockBillingRouting.shouldUseWorkspaceBilling = false
     mockCustomerEventsService.formatEventType.mockImplementation(
       (type: string) => {
         switch (type) {
@@ -228,7 +245,7 @@ describe('UsageLogsTable', () => {
       })
     })
 
-    it('shows error message when service throws', async () => {
+    it('shows a localized fallback instead of a raw Error message', async () => {
       mockCustomerEventsService.getMyEvents.mockRejectedValue(
         new Error('Network error')
       )
@@ -236,7 +253,25 @@ describe('UsageLogsTable', () => {
       renderWithAutoRefresh()
 
       await waitFor(() => {
-        expect(screen.getByText('Network error')).toBeInTheDocument()
+        expect(
+          screen.getByText(
+            'Something went wrong while loading activity. Please refresh and try again.'
+          )
+        ).toBeInTheDocument()
+      })
+      expect(screen.queryByText('Network error')).not.toBeInTheDocument()
+    })
+
+    it('shows a localized fallback when the service reports no message', async () => {
+      mockCustomerEventsService.getMyEvents.mockResolvedValue(null)
+      mockCustomerEventsService.error.value = null
+
+      renderWithAutoRefresh()
+
+      await waitFor(() => {
+        expect(
+          screen.getByText('Failed to load activity. Please try again.')
+        ).toBeInTheDocument()
       })
     })
 
@@ -341,8 +376,8 @@ describe('UsageLogsTable', () => {
   })
 
   describe('billing events source', () => {
-    it('uses workspaceApi.getBillingEvents when teamWorkspacesEnabled is on', async () => {
-      mockFlags.teamWorkspacesEnabled = true
+    it('uses workspaceApi.getBillingEvents on the workspace billing flow', async () => {
+      mockBillingRouting.shouldUseWorkspaceBilling = true
 
       await renderLoaded()
 
@@ -352,6 +387,90 @@ describe('UsageLogsTable', () => {
       })
       expect(mockCustomerEventsService.getMyEvents).not.toHaveBeenCalled()
     })
+
+    it('discards a stale legacy response when routing flips mid-fetch', async () => {
+      let resolveLegacy!: (value: ReturnType<typeof makeEventsResponse>) => void
+      mockCustomerEventsService.getMyEvents.mockReturnValue(
+        new Promise((resolve) => {
+          resolveLegacy = resolve
+        })
+      )
+      mockWorkspaceApi.getBillingEvents.mockResolvedValue(
+        makeEventsResponse([
+          {
+            event_id: 'workspace-1',
+            event_type: EventType.API_USAGE_COMPLETED,
+            params: { api_name: 'WorkspaceAPI', model: 'workspace-model' },
+            createdAt: '2024-02-01T10:00:00Z'
+          }
+        ])
+      )
+
+      renderWithAutoRefresh()
+
+      mockBillingRouting.shouldUseWorkspaceBilling = true
+      await waitFor(() => {
+        expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
+      })
+
+      resolveLegacy(
+        makeEventsResponse([
+          {
+            event_id: 'legacy-1',
+            event_type: EventType.API_USAGE_COMPLETED,
+            params: { api_name: 'LegacyAPI', model: 'legacy-model' },
+            createdAt: '2024-01-01T10:00:00Z'
+          }
+        ])
+      )
+
+      await flushMicrotasks()
+
+      expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
+      expect(screen.queryByText('LegacyAPI')).not.toBeInTheDocument()
+    })
+
+    it('runs top-up completion telemetry for a superseded response', async () => {
+      let resolveLegacy!: (value: ReturnType<typeof makeEventsResponse>) => void
+      mockCustomerEventsService.getMyEvents.mockReturnValue(
+        new Promise((resolve) => {
+          resolveLegacy = resolve
+        })
+      )
+      mockWorkspaceApi.getBillingEvents.mockResolvedValue(
+        makeEventsResponse([
+          {
+            event_id: 'workspace-1',
+            event_type: EventType.API_USAGE_COMPLETED,
+            params: { api_name: 'WorkspaceAPI', model: 'workspace-model' },
+            createdAt: '2024-02-01T10:00:00Z'
+          }
+        ])
+      )
+
+      renderWithAutoRefresh()
+
+      mockBillingRouting.shouldUseWorkspaceBilling = true
+      await waitFor(() => {
+        expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
+      })
+
+      const legacyResponse = makeEventsResponse([
+        {
+          event_id: 'legacy-1',
+          event_type: EventType.CREDIT_ADDED,
+          params: { amount: 1000 },
+          createdAt: '2024-01-01T10:00:00Z'
+        }
+      ])
+      resolveLegacy(legacyResponse)
+
+      await waitFor(() => {
+        expect(mockTelemetry.checkForCompletedTopup).toHaveBeenCalledWith(
+          legacyResponse.events
+        )
+      })
+    })
   })
 
   describe('EventType integration', () => {

src/components/dialog/content/setting/UsageLogsTable.vue

@@ -96,11 +96,11 @@ import Column from 'primevue/column'
 import DataTable from 'primevue/datatable'
 import Message from 'primevue/message'
 import ProgressSpinner from 'primevue/progressspinner'
-import { computed, ref } from 'vue'
+import { computed, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
 
 import Button from '@/components/ui/button/Button.vue'
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
-import { isCloud } from '@/platform/distribution/types'
+import { useBillingRouting } from '@/composables/billing/useBillingRouting'
 import { useTelemetry } from '@/platform/telemetry'
 import { workspaceApi } from '@/platform/workspace/api/workspaceApi'
 import type { AuditLog } from '@/services/customerEventsService'
@@ -109,14 +109,15 @@ import {
   useCustomerEventsService
 } from '@/services/customerEventsService'
 
+const { t } = useI18n()
+
 const events = ref<AuditLog[]>([])
 const loading = ref(true)
 const error = ref<string | null>(null)
 
 const customerEventService = useCustomerEventsService()
 
-const { flags } = useFeatureFlags()
-const useBillingApi = computed(() => isCloud && flags.teamWorkspacesEnabled)
+const { shouldUseWorkspaceBilling } = useBillingRouting()
 
 const pagination = ref({
   page: 1,
@@ -139,7 +140,12 @@ const tooltipContentMap = computed(() => {
   return map
 })
 
+// A billing-route flip can overlap two loads against different backends; only
+// the latest may mutate state, so a superseded response is discarded.
+let latestLoadToken = 0
+
 const loadEvents = async () => {
+  const loadToken = ++latestLoadToken
   loading.value = true
   error.value = null
 
@@ -148,10 +154,17 @@ const loadEvents = async () => {
       page: pagination.value.page,
       limit: pagination.value.limit
     }
-    const response = useBillingApi.value
+    const response = shouldUseWorkspaceBilling.value
       ? await workspaceApi.getBillingEvents(params)
       : await customerEventService.getMyEvents(params)
 
+    // Completion telemetry must run even when a mid-checkout route flip
+    // supersedes this load, since legacy and workspace backends emit different
+    // top-up events and the winning fetch may not carry the completion yet.
+    useTelemetry()?.checkForCompletedTopup(response?.events)
+
+    if (loadToken !== latestLoadToken) return
+
     if (response) {
       if (response.events) {
         events.value = response.events
@@ -165,24 +178,25 @@ const loadEvents = async () => {
         pagination.value.limit = response.limit
       }
 
-      if (response.total) {
+      if (response.total != null) {
         pagination.value.total = response.total
       }
 
-      if (response.totalPages) {
+      if (response.totalPages != null) {
         pagination.value.totalPages = response.totalPages
       }
-
-      // Check if a pending top-up has completed
-      useTelemetry()?.checkForCompletedTopup(response.events)
     } else {
-      error.value = customerEventService.error.value || 'Failed to load events'
+      const legacyError = shouldUseWorkspaceBilling.value
+        ? null
+        : customerEventService.error.value
+      error.value = legacyError || t('credits.loadEventsError')
     }
   } catch (err) {
-    error.value = err instanceof Error ? err.message : 'Unknown error'
+    if (loadToken !== latestLoadToken) return
+    error.value = t('credits.loadEventsUnknownError')
     console.error('Error loading events:', err)
   } finally {
-    loading.value = false
+    if (loadToken === latestLoadToken) loading.value = false
   }
 }
 
@@ -198,6 +212,12 @@ const refresh = async () => {
   await loadEvents()
 }
 
+watch(shouldUseWorkspaceBilling, () => {
+  refresh().catch((error) => {
+    console.error('Error loading events:', error)
+  })
+})
+
 defineExpose({
   refresh
 })

src/composables/billing/useBillingContext.test.ts

@@ -19,6 +19,7 @@ const DEFAULT_BILLING_STATUS: BillingStatusResponse = {
 
 const {
   mockTeamWorkspacesEnabled,
+  mockConsolidatedBillingEnabled,
   mockIsPersonal,
   mockPlans,
   mockPurchaseCredits,
@@ -26,6 +27,7 @@ const {
   mockBillingStatus
 } = vi.hoisted(() => ({
   mockTeamWorkspacesEnabled: { value: false },
+  mockConsolidatedBillingEnabled: { value: false },
   mockIsPersonal: { value: true },
   mockPlans: { value: [] as Plan[] },
   mockPurchaseCredits: vi.fn(),
@@ -57,11 +59,23 @@ vi.mock('@/composables/useFeatureFlags', async () => {
       teamWorkspacesEnabledRef.value = value
     }
   })
+  const consolidatedBillingEnabledRef = ref(
+    mockConsolidatedBillingEnabled.value
+  )
+  Object.defineProperty(mockConsolidatedBillingEnabled, 'value', {
+    get: () => consolidatedBillingEnabledRef.value,
+    set: (value: boolean) => {
+      consolidatedBillingEnabledRef.value = value
+    }
+  })
   return {
     useFeatureFlags: () => ({
       flags: {
         get teamWorkspacesEnabled() {
           return mockTeamWorkspacesEnabled.value
+        },
+        get consolidatedBillingEnabled() {
+          return mockConsolidatedBillingEnabled.value
         }
       }
     })
@@ -151,6 +165,7 @@ describe('useBillingContext', () => {
     setActivePinia(createPinia())
     vi.clearAllMocks()
     mockTeamWorkspacesEnabled.value = false
+    mockConsolidatedBillingEnabled.value = false
     mockIsPersonal.value = true
     mockPlans.value = []
     mockBillingStatus.value = { ...DEFAULT_BILLING_STATUS }
@@ -162,16 +177,27 @@ describe('useBillingContext', () => {
     expect(type.value).toBe('legacy')
   })
 
-  it('selects workspace type for personal when team workspaces are enabled', () => {
+  it('keeps personal on legacy when consolidated billing is disabled', () => {
     mockTeamWorkspacesEnabled.value = true
+    mockConsolidatedBillingEnabled.value = false
+    mockIsPersonal.value = true
+
+    const { type } = useBillingContext()
+    expect(type.value).toBe('legacy')
+  })
+
+  it('selects workspace type for personal when consolidated billing is enabled', () => {
+    mockTeamWorkspacesEnabled.value = true
+    mockConsolidatedBillingEnabled.value = true
     mockIsPersonal.value = true
 
     const { type } = useBillingContext()
     expect(type.value).toBe('workspace')
   })
 
-  it('selects workspace type for team when team workspaces are enabled', () => {
+  it('selects workspace type for team regardless of consolidated billing', () => {
     mockTeamWorkspacesEnabled.value = true
+    mockConsolidatedBillingEnabled.value = false
     mockIsPersonal.value = false
 
     const { type } = useBillingContext()
@@ -272,6 +298,7 @@ describe('useBillingContext', () => {
     expect(workspaceApi.getBillingStatus).not.toHaveBeenCalled()
 
     // Authenticated remote config resolves the flag on for the same workspace
+    mockConsolidatedBillingEnabled.value = true
     mockTeamWorkspacesEnabled.value = true
 
     await vi.waitFor(() => {
@@ -280,9 +307,27 @@ describe('useBillingContext', () => {
     })
   })
 
+  it('moves a personal workspace to workspace billing when consolidated billing flips on', async () => {
+    mockTeamWorkspacesEnabled.value = true
+    mockConsolidatedBillingEnabled.value = false
+    mockIsPersonal.value = true
+
+    const { type } = useBillingContext()
+    await nextTick()
+    expect(type.value).toBe('legacy')
+
+    mockConsolidatedBillingEnabled.value = true
+
+    await vi.waitFor(() => {
+      expect(type.value).toBe('workspace')
+      expect(workspaceApi.getBillingStatus).toHaveBeenCalled()
+    })
+  })
+
   describe('subscription mirror to workspace store', () => {
-    it('mirrors subscription for personal workspaces when team workspaces are enabled', async () => {
+    it('mirrors subscription for personal workspaces on the consolidated billing flow', async () => {
       mockTeamWorkspacesEnabled.value = true
+      mockConsolidatedBillingEnabled.value = true
       mockIsPersonal.value = true
 
       const { initialize } = useBillingContext()
@@ -294,6 +339,20 @@ describe('useBillingContext', () => {
         subscriptionPlan: null
       })
     })
+
+    it('never clobbers the list-derived store when a subscription is absent', async () => {
+      mockTeamWorkspacesEnabled.value = true
+      mockIsPersonal.value = false
+
+      const { initialize } = useBillingContext()
+      await initialize()
+      await nextTick()
+
+      expect(mockUpdateActiveWorkspace).not.toHaveBeenCalledWith({
+        isSubscribed: false,
+        subscriptionPlan: null
+      })
+    })
   })
 
   describe('getMaxSeats', () => {

src/composables/billing/useBillingContext.ts

@@ -1,7 +1,6 @@
 import { computed, ref, shallowRef, toValue, watch } from 'vue'
 import { createSharedComposable } from '@vueuse/core'
 
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import {
   KEY_TO_TIER,
   getTierFeatures
@@ -18,10 +17,10 @@ import type {
   BalanceInfo,
   BillingActions,
   BillingContext,
-  BillingType,
   BillingState,
   SubscriptionInfo
 } from './types'
+import { useBillingRouting } from './useBillingRouting'
 import { useLegacyBilling } from './useLegacyBilling'
 import { useWorkspaceBilling } from '@/platform/workspace/composables/useWorkspaceBilling'
 
@@ -35,8 +34,9 @@ const LEGACY_TEAM_PLAN_SLUG_PREFIX = 'team-'
  * Unified billing context that selects the billing implementation by build/flag.
  *
  * - Team workspaces disabled (OSS/Desktop): legacy billing via /customers/*
- * - Team workspaces enabled: workspace billing via /api/billing/* for both
- *   personal (single-seat workspace) and team workspaces
+ * - Team workspaces enabled: workspace billing via /api/billing/* for team
+ *   workspaces, and for personal workspaces once consolidated billing is
+ *   enabled; personal workspaces otherwise stay on legacy billing
  *
  * The context automatically initializes when the workspace changes and provides
  * a unified interface for subscription status, balance, and billing actions.
@@ -69,7 +69,7 @@ const LEGACY_TEAM_PLAN_SLUG_PREFIX = 'team-'
  */
 function useBillingContextInternal(): BillingContext {
   const store = useTeamWorkspaceStore()
-  const { flags } = useFeatureFlags()
+  const { type } = useBillingRouting()
 
   const legacyBillingRef = shallowRef<(BillingState & BillingActions) | null>(
     null
@@ -96,16 +96,6 @@ function useBillingContextInternal(): BillingContext {
   const isLoading = ref(false)
   const error = ref<string | null>(null)
 
-  /**
-   * Determines which billing type to use, keyed only on the build/flag:
-   * - Team workspaces feature disabled (OSS/Desktop): legacy (/customers)
-   * - Team workspaces feature enabled: workspace (/api/billing), for both
-   *   personal (single-seat workspace) and team workspaces
-   */
-  const type = computed<BillingType>(() =>
-    flags.teamWorkspacesEnabled ? 'workspace' : 'legacy'
-  )
-
   const activeContext = computed(() =>
     type.value === 'legacy' ? getLegacyBilling() : getWorkspaceBilling()
   )
@@ -170,9 +160,12 @@ function useBillingContextInternal(): BillingContext {
     return plan?.max_seats ?? getTierFeatures(tierKey).maxMembers
   }
 
-  // Sync subscription info to workspace store for display in workspace switcher
-  // A subscription is considered "subscribed" for workspace purposes if it's active AND not cancelled
-  // This ensures the delete button is enabled after cancellation, even before the period ends
+  // Sync subscription info to workspace store for display in workspace switcher.
+  // Subscribed means active AND not cancelled, so the delete button enables
+  // after cancellation, even before the period ends. A null subscription means
+  // "not loaded yet" (adapters are discarded on every workspace/type switch);
+  // skip it so the transient reinit gap can't clobber the list-derived baseline
+  // (personal workspaces and subscribed teams already read subscribed there).
   watch(
     subscription,
     (sub) => {
@@ -186,24 +179,27 @@ function useBillingContextInternal(): BillingContext {
     { immediate: true }
   )
 
+  // Discarding the adapter instances forces a fresh fetch and lets an in-flight
+  // init detect that it was superseded (its captured adapter is no longer the
+  // active one), so a stale response can't resolve into a ready state for the
+  // wrong workspace.
   function resetBillingState() {
+    legacyBillingRef.value = null
+    workspaceBillingRef.value = null
     isInitialized.value = false
+    isLoading.value = false
     error.value = null
   }
 
-  // type can flip after setup when the team-workspaces flag resolves from
-  // authenticated config, swapping the active backend; a fresh init is needed.
-  // The watch fires only when id or type actually changes, so any fire with a
-  // workspace selected warrants a reinit.
+  // type flips when the team-workspaces or consolidated-billing flag resolves
+  // from authenticated config, swapping the active backend. Reset then reinit
+  // on every workspace-id or type change.
   watch(
     [() => store.activeWorkspace?.id, () => type.value],
     async ([newWorkspaceId]) => {
-      if (!newWorkspaceId) {
-        resetBillingState()
-        return
-      }
+      resetBillingState()
+      if (!newWorkspaceId) return
 
-      isInitialized.value = false
       try {
         await initialize()
       } catch (err) {
@@ -216,17 +212,20 @@ function useBillingContextInternal(): BillingContext {
   async function initialize(): Promise<void> {
     if (isInitialized.value) return
 
+    const adapter = activeContext.value
     isLoading.value = true
     error.value = null
     try {
-      await activeContext.value.initialize()
+      await adapter.initialize()
+      if (activeContext.value !== adapter) return
       isInitialized.value = true
     } catch (err) {
+      if (activeContext.value !== adapter) return
       error.value =
         err instanceof Error ? err.message : 'Failed to initialize billing'
       throw err
     } finally {
-      isLoading.value = false
+      if (activeContext.value === adapter) isLoading.value = false
     }
   }
 

src/composables/billing/useBillingRouting.test.ts

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useBillingRouting } from './useBillingRouting'
+
+const { mockFlags, mockActiveWorkspace } = vi.hoisted(() => ({
+  mockFlags: {
+    teamWorkspacesEnabled: false,
+    consolidatedBillingEnabled: false
+  },
+  mockActiveWorkspace: {
+    value: null as { id: string; type: 'personal' | 'team' } | null
+  }
+}))
+
+vi.mock('@/composables/useFeatureFlags', () => ({
+  useFeatureFlags: () => ({ flags: mockFlags })
+}))
+
+vi.mock('@/platform/workspace/stores/teamWorkspaceStore', () => ({
+  useTeamWorkspaceStore: () => ({
+    get activeWorkspace() {
+      return mockActiveWorkspace.value
+    }
+  })
+}))
+
+const personal = { id: 'w-personal', type: 'personal' as const }
+const team = { id: 'w-team', type: 'team' as const }
+
+describe('useBillingRouting', () => {
+  beforeEach(() => {
+    mockFlags.teamWorkspacesEnabled = false
+    mockFlags.consolidatedBillingEnabled = false
+    mockActiveWorkspace.value = personal
+  })
+
+  it('uses legacy billing when team workspaces are disabled', () => {
+    mockFlags.teamWorkspacesEnabled = false
+    mockActiveWorkspace.value = team
+
+    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
+
+    expect(type.value).toBe('legacy')
+    expect(shouldUseWorkspaceBilling.value).toBe(false)
+  })
+
+  it('keeps personal on legacy when consolidated billing is disabled', () => {
+    mockFlags.teamWorkspacesEnabled = true
+    mockFlags.consolidatedBillingEnabled = false
+    mockActiveWorkspace.value = personal
+
+    const { type } = useBillingRouting()
+
+    expect(type.value).toBe('legacy')
+  })
+
+  it('moves personal to workspace billing when consolidated billing is enabled', () => {
+    mockFlags.teamWorkspacesEnabled = true
+    mockFlags.consolidatedBillingEnabled = true
+    mockActiveWorkspace.value = personal
+
+    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
+
+    expect(type.value).toBe('workspace')
+    expect(shouldUseWorkspaceBilling.value).toBe(true)
+  })
+
+  it('uses workspace billing for team workspaces regardless of consolidated billing', () => {
+    mockFlags.teamWorkspacesEnabled = true
+    mockFlags.consolidatedBillingEnabled = false
+    mockActiveWorkspace.value = team
+
+    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
+
+    expect(type.value).toBe('workspace')
+    expect(shouldUseWorkspaceBilling.value).toBe(true)
+  })
+
+  it('uses workspace billing for team workspaces with consolidated billing enabled', () => {
+    mockFlags.teamWorkspacesEnabled = true
+    mockFlags.consolidatedBillingEnabled = true
+    mockActiveWorkspace.value = team
+
+    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
+
+    expect(type.value).toBe('workspace')
+    expect(shouldUseWorkspaceBilling.value).toBe(true)
+  })
+
+  it('defaults to legacy while the workspace has not loaded', () => {
+    mockFlags.teamWorkspacesEnabled = true
+    mockFlags.consolidatedBillingEnabled = true
+    mockActiveWorkspace.value = null
+
+    const { type } = useBillingRouting()
+
+    expect(type.value).toBe('legacy')
+  })
+})

src/composables/billing/useBillingRouting.ts

@@ -0,0 +1,36 @@
+import { computed } from 'vue'
+
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
+import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore'
+
+import type { BillingType } from './types'
+
+/**
+ * Selects the billing backend for the active workspace: legacy user-scoped
+ * (`/customers/*`) or workspace-scoped (`/api/billing/*`). Personal workspaces
+ * stay legacy until `consolidatedBillingEnabled`; team workspaces are always
+ * workspace-scoped. The routing matrix is covered in useBillingRouting.test.ts.
+ */
+export function useBillingRouting() {
+  const { flags } = useFeatureFlags()
+  const workspaceStore = useTeamWorkspaceStore()
+
+  const type = computed<BillingType>(() => {
+    if (!flags.teamWorkspacesEnabled) return 'legacy'
+
+    // An unloaded workspace has no type yet; stay legacy so bootstrap never
+    // eagerly routes to workspace billing.
+    const workspaceType = workspaceStore.activeWorkspace?.type
+    if (!workspaceType) return 'legacy'
+
+    if (workspaceType === 'personal' && !flags.consolidatedBillingEnabled) {
+      return 'legacy'
+    }
+
+    return 'workspace'
+  })
+
+  const shouldUseWorkspaceBilling = computed(() => type.value === 'workspace')
+
+  return { type, shouldUseWorkspaceBilling }
+}

src/composables/queue/useJobActions.test.ts

@@ -1,132 +0,0 @@
-import { fromPartial } from '@total-typescript/shoehorn'
-import { createApp, h, ref } from 'vue'
-import { createI18n } from 'vue-i18n'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useJobActions } from '@/composables/queue/useJobActions'
-import type { JobListItem } from '@/composables/queue/useJobList'
-import type { TaskItemImpl } from '@/stores/queueStore'
-import type { Ref } from 'vue'
-
-const { cancelJob, removeFailedJob, wrapWithErrorHandlingAsync } = vi.hoisted(
-  () => ({
-    cancelJob: vi.fn(),
-    removeFailedJob: vi.fn(),
-    wrapWithErrorHandlingAsync: vi.fn(
-      <T extends (...args: never[]) => Promise<unknown>>(fn: T) => fn
-    )
-  })
-)
-
-vi.mock('@/composables/useErrorHandling', () => ({
-  useErrorHandling: () => ({ wrapWithErrorHandlingAsync })
-}))
-
-vi.mock('@/composables/queue/useJobMenu', () => ({
-  useJobMenu: () => ({ cancelJob, removeFailedJob })
-}))
-
-function mountJobActions(job: Ref<JobListItem | null | undefined>) {
-  let result: ReturnType<typeof useJobActions> | undefined
-  const app = createApp({
-    setup() {
-      result = useJobActions(job)
-      return () => h('div')
-    }
-  })
-  app.use(
-    createI18n({
-      legacy: false,
-      locale: 'en',
-      messages: { en: {} }
-    })
-  )
-  app.mount(document.createElement('div'))
-  if (!result) throw new Error('useJobActions did not initialize')
-  return {
-    result,
-    unmount: () => app.unmount()
-  }
-}
-
-function job(overrides: Partial<JobListItem> = {}): JobListItem {
-  return {
-    id: 'job-1',
-    title: 'Job 1',
-    meta: '',
-    state: 'pending',
-    ...overrides
-  }
-}
-
-beforeEach(() => {
-  cancelJob.mockReset().mockResolvedValue(undefined)
-  removeFailedJob.mockReset().mockResolvedValue(undefined)
-  wrapWithErrorHandlingAsync.mockClear()
-})
-
-describe('useJobActions', () => {
-  it('exposes localized action metadata', () => {
-    const { result, unmount } = mountJobActions(ref(job()))
-
-    expect(result.cancelAction).toMatchObject({
-      icon: 'icon-[lucide--x]',
-      label: 'sideToolbar.queueProgressOverlay.cancelJobTooltip',
-      variant: 'destructive'
-    })
-    expect(result.deleteAction).toMatchObject({
-      icon: 'icon-[lucide--circle-minus]',
-      label: 'queue.jobMenu.removeJob',
-      variant: 'destructive'
-    })
-    expect(wrapWithErrorHandlingAsync).toHaveBeenCalledTimes(2)
-
-    unmount()
-  })
-
-  it('cancels active jobs unless clearing is hidden', async () => {
-    const currentJob = ref(job({ state: 'running' }))
-    const { result, unmount } = mountJobActions(currentJob)
-
-    expect(result.canCancelJob.value).toBe(true)
-    await result.runCancelJob()
-    expect(cancelJob).toHaveBeenCalledWith(currentJob.value)
-
-    currentJob.value = job({ state: 'pending', showClear: false })
-    expect(result.canCancelJob.value).toBe(false)
-
-    unmount()
-  })
-
-  it('ignores cancel and delete requests without a current job or task', async () => {
-    const currentJob = ref<JobListItem | null>(null)
-    const { result, unmount } = mountJobActions(currentJob)
-
-    expect(result.canCancelJob.value).toBe(false)
-    expect(result.canDeleteJob.value).toBe(false)
-    await result.runCancelJob()
-    await result.runDeleteJob()
-
-    currentJob.value = job({ state: 'failed' })
-    await result.runDeleteJob()
-
-    expect(cancelJob).not.toHaveBeenCalled()
-    expect(removeFailedJob).not.toHaveBeenCalled()
-
-    unmount()
-  })
-
-  it('removes failed jobs through their queue task', async () => {
-    const task = fromPartial<TaskItemImpl>({ job: { id: 'prompt-1' } })
-    const { result, unmount } = mountJobActions(
-      ref(job({ state: 'failed', taskRef: task }))
-    )
-
-    expect(result.canDeleteJob.value).toBe(true)
-    await result.runDeleteJob()
-
-    expect(removeFailedJob).toHaveBeenCalledWith(task)
-
-    unmount()
-  })
-})

src/composables/queue/useJobMenu.test.ts

@@ -280,20 +280,6 @@ describe('useJobMenu', () => {
     expect(copyToClipboardMock).not.toHaveBeenCalled()
   })
 
-  it('uses an empty menu with the default current item getter', async () => {
-    const { jobMenuEntries, openJobWorkflow, copyJobId, cancelJob } =
-      useJobMenu()
-
-    await openJobWorkflow()
-    await copyJobId()
-    await cancelJob()
-
-    expect(jobMenuEntries.value).toEqual([])
-    expect(getJobWorkflowMock).not.toHaveBeenCalled()
-    expect(copyToClipboardMock).not.toHaveBeenCalled()
-    expect(queueStoreMock.update).not.toHaveBeenCalled()
-  })
-
   it.for([['running'], ['initialization'], ['pending']])(
     'cancels %s job via the state-agnostic jobs-namespace endpoint',
     async ([state]) => {
@@ -407,26 +393,6 @@ describe('useJobMenu', () => {
     expect(optionsArg).toEqual({ reportType: 'queueJobError' })
   })
 
-  it('ignores failed report action when item disappears before click', async () => {
-    const { jobMenuEntries } = mountJobMenu()
-    setCurrentItem(
-      createJobItem({
-        state: 'failed',
-        taskRef: {
-          errorMessage: 'Job failed with error'
-        } as Partial<TaskItemImpl>
-      })
-    )
-
-    await nextTick()
-    const entry = findActionEntry(jobMenuEntries.value, 'report-error')
-    setCurrentItem(null)
-    await entry?.onClick?.()
-
-    expect(dialogServiceMock.showExecutionErrorDialog).not.toHaveBeenCalled()
-    expect(dialogServiceMock.showErrorDialog).not.toHaveBeenCalled()
-  })
-
   it('ignores error actions when message missing', async () => {
     const { jobMenuEntries } = mountJobMenu()
     setCurrentItem(
@@ -578,74 +544,6 @@ describe('useJobMenu', () => {
     expect(createAnnotatedPathMock).not.toHaveBeenCalled()
   })
 
-  it('uses no root folder when preview type is not an API result type', async () => {
-    const node = {
-      widgets: [{ name: 'image', value: null, callback: vi.fn() }],
-      graph: { setDirtyCanvas: vi.fn() }
-    }
-    litegraphServiceMock.addNodeOnGraph.mockReturnValueOnce(node)
-    const { jobMenuEntries } = mountJobMenu()
-    setCurrentItem(
-      createJobItem({
-        state: 'completed',
-        taskRef: {
-          previewOutput: {
-            isImage: true,
-            filename: 'foo.png',
-            subfolder: 'bar',
-            type: 'archive',
-            url: 'http://asset'
-          }
-        }
-      })
-    )
-
-    await nextTick()
-    const entry = findActionEntry(jobMenuEntries.value, 'add-to-current')
-    await entry?.onClick?.()
-
-    expect(createAnnotatedPathMock).toHaveBeenCalledWith(
-      {
-        filename: 'foo.png',
-        subfolder: 'bar',
-        type: undefined
-      },
-      { rootFolder: undefined },
-      undefined
-    )
-    expect(node.graph.setDirtyCanvas).toHaveBeenCalledWith(true, true)
-  })
-
-  it('marks graph dirty when created loader node has no matching widget', async () => {
-    const node = {
-      widgets: [{ name: 'other', value: null, callback: vi.fn() }],
-      graph: { setDirtyCanvas: vi.fn() }
-    }
-    litegraphServiceMock.addNodeOnGraph.mockReturnValueOnce(node)
-    const { jobMenuEntries } = mountJobMenu()
-    setCurrentItem(
-      createJobItem({
-        state: 'completed',
-        taskRef: {
-          previewOutput: {
-            isImage: true,
-            filename: 'foo.png',
-            subfolder: '',
-            type: 'output'
-          }
-        }
-      })
-    )
-
-    await nextTick()
-    const entry = findActionEntry(jobMenuEntries.value, 'add-to-current')
-    await entry?.onClick?.()
-
-    expect(node.widgets[0].value).toBeNull()
-    expect(node.widgets[0].callback).not.toHaveBeenCalled()
-    expect(node.graph.setDirtyCanvas).toHaveBeenCalledWith(true, true)
-  })
-
   it('ignores add-to-current entry when preview missing entirely', async () => {
     const { jobMenuEntries } = mountJobMenu()
     setCurrentItem(
@@ -696,45 +594,6 @@ describe('useJobMenu', () => {
     expect(downloadFileMock).not.toHaveBeenCalled()
   })
 
-  it('ignores completed asset actions when item disappears before click', async () => {
-    const inspectSpy = vi.fn()
-    const { jobMenuEntries } = mountJobMenu(inspectSpy)
-    setCurrentItem(
-      createJobItem({
-        state: 'completed',
-        taskRef: {
-          previewOutput: {
-            isImage: true,
-            filename: 'foo.png',
-            subfolder: '',
-            type: 'output',
-            url: 'https://asset'
-          }
-        }
-      })
-    )
-
-    await nextTick()
-    const inspectEntry = findActionEntry(jobMenuEntries.value, 'inspect-asset')
-    const addEntry = findActionEntry(jobMenuEntries.value, 'add-to-current')
-    const downloadEntry = findActionEntry(jobMenuEntries.value, 'download')
-    const exportEntry = findActionEntry(jobMenuEntries.value, 'export-workflow')
-    const deleteEntry = findActionEntry(jobMenuEntries.value, 'delete')
-    setCurrentItem(null)
-
-    void inspectEntry?.onClick?.()
-    await addEntry?.onClick?.()
-    void downloadEntry?.onClick?.()
-    await exportEntry?.onClick?.()
-    await deleteEntry?.onClick?.()
-
-    expect(inspectSpy).not.toHaveBeenCalled()
-    expect(litegraphServiceMock.addNodeOnGraph).not.toHaveBeenCalled()
-    expect(downloadFileMock).not.toHaveBeenCalled()
-    expect(getJobWorkflowMock).not.toHaveBeenCalled()
-    expect(mediaAssetActionsMock.deleteAssets).not.toHaveBeenCalled()
-  })
-
   it('exports workflow with default filename when prompting disabled', async () => {
     const workflow = { foo: 'bar' }
     getJobWorkflowMock.mockResolvedValue(workflow)
@@ -759,17 +618,6 @@ describe('useJobMenu', () => {
     )
   })
 
-  it('does not export workflow when workflow data is unavailable', async () => {
-    const { jobMenuEntries } = mountJobMenu()
-    setCurrentItem(createJobItem({ state: 'completed' }))
-
-    await nextTick()
-    const entry = findActionEntry(jobMenuEntries.value, 'export-workflow')
-    await entry?.onClick?.()
-
-    expect(downloadBlobMock).not.toHaveBeenCalled()
-  })
-
   it('prompts for filename when setting enabled', async () => {
     settingStoreMock.get.mockReturnValue(true)
     dialogServiceMock.prompt.mockResolvedValue('custom-name')
@@ -865,24 +713,6 @@ describe('useJobMenu', () => {
     expect(queueStoreMock.update).not.toHaveBeenCalled()
   })
 
-  it('does not delete asset when preview disappears before click', async () => {
-    const { jobMenuEntries } = mountJobMenu()
-    setCurrentItem(
-      createJobItem({
-        state: 'completed',
-        taskRef: { previewOutput: {} }
-      })
-    )
-
-    await nextTick()
-    const entry = findActionEntry(jobMenuEntries.value, 'delete')
-    setCurrentItem(createJobItem({ state: 'completed', taskRef: {} }))
-    await entry?.onClick?.()
-
-    expect(mediaAssetActionsMock.deleteAssets).not.toHaveBeenCalled()
-    expect(queueStoreMock.update).not.toHaveBeenCalled()
-  })
-
   it('removes failed job via menu entry', async () => {
     const taskRef = { id: 'task-1' }
     const { jobMenuEntries } = mountJobMenu()

src/composables/queue/useQueueNotificationBanners.test.ts

@@ -79,10 +79,12 @@ describe(useQueueNotificationBanners, () => {
       isImage?: boolean
     } = {}
   ): MockTask => {
-    const { state = 'Completed', previewUrl, isImage = true } = options
-    // Only default the timestamp when the caller omitted the key, so an
-    // explicit `ts: undefined` really produces a task without a timestamp.
-    const ts = 'ts' in options ? options.ts : Date.now()
+    const {
+      state = 'Completed',
+      ts = Date.now(),
+      previewUrl,
+      isImage = true
+    } = options
 
     const task: MockTask = {
       displayStatus: state,
@@ -184,75 +186,6 @@ describe(useQueueNotificationBanners, () => {
     }
   })
 
-  it('converts a queued-pending notification waiting behind the active one', async () => {
-    const { unmount, composable } = mountComposable()
-
-    try {
-      mockApi.dispatchEvent(
-        new CustomEvent('promptQueued', {
-          detail: { requestId: 1, batchCount: 1 }
-        })
-      )
-      await nextTick()
-
-      mockApi.dispatchEvent(
-        new CustomEvent('promptQueueing', {
-          detail: { requestId: 2, batchCount: 3 }
-        })
-      )
-      mockApi.dispatchEvent(
-        new CustomEvent('promptQueued', {
-          detail: { requestId: 2, batchCount: 5 }
-        })
-      )
-      await nextTick()
-
-      expect(composable.currentNotification.value).toEqual({
-        type: 'queued',
-        count: 1,
-        requestId: 1
-      })
-
-      await vi.advanceTimersByTimeAsync(4000)
-      await nextTick()
-
-      expect(composable.currentNotification.value).toEqual({
-        type: 'queued',
-        count: 5,
-        requestId: 2
-      })
-    } finally {
-      unmount()
-    }
-  })
-
-  it('converts queued-pending notifications without request ids', async () => {
-    const { unmount, composable } = mountComposable()
-
-    try {
-      mockApi.dispatchEvent(
-        new CustomEvent('promptQueueing', {
-          detail: { batchCount: 2 }
-        })
-      )
-      await nextTick()
-
-      mockApi.dispatchEvent(
-        new CustomEvent('promptQueued', {
-          detail: { batchCount: 3 }
-        })
-      )
-      await nextTick()
-
-      expect(composable.currentNotification.value).toEqual({
-        type: 'queued',
-        count: 3
-      })
-    } finally {
-      unmount()
-    }
-  })
-
   it('falls back to 1 when queued batch count is invalid', async () => {
     const { unmount, composable } = mountComposable()
 
@@ -373,64 +306,6 @@ describe(useQueueNotificationBanners, () => {
     }
   })
 
-  it('shows failed notifications for failed-only batches', async () => {
-    const { unmount, composable } = mountComposable()
-
-    try {
-      await runBatch({
-        start: 5_000,
-        finish: 5_200,
-        tasks: [createTask({ state: 'Failed', ts: 5_050 })]
-      })
-
-      expect(composable.currentNotification.value).toEqual({
-        type: 'failed',
-        count: 1
-      })
-    } finally {
-      unmount()
-    }
-  })
-
-  it('does not notify for old or unfinished history entries', async () => {
-    const { unmount, composable } = mountComposable()
-
-    try {
-      await runBatch({
-        start: 6_000,
-        finish: 6_200,
-        tasks: [
-          createTask({ ts: 5_999 }),
-          createTask({ state: 'Running', ts: 6_050 }),
-          createTask({ state: 'Pending', ts: undefined })
-        ]
-      })
-
-      expect(composable.currentNotification.value).toBeNull()
-    } finally {
-      unmount()
-    }
-  })
-
-  it('keeps no notification visible when an idle window has no finished tasks', async () => {
-    const { unmount, composable } = mountComposable()
-
-    try {
-      vi.setSystemTime(7_000)
-      executionStore().isIdle = false
-      await nextTick()
-
-      vi.setSystemTime(7_100)
-      executionStore().isIdle = true
-      queueStore().historyTasks = []
-      await nextTick()
-
-      expect(composable.currentNotification.value).toBeNull()
-    } finally {
-      unmount()
-    }
-  })
-
   it('uses up to two completion thumbnails for notification icon previews', async () => {
     const { unmount, composable } = mountComposable()
 

src/composables/useFeatureFlags.test.ts

@@ -6,6 +6,12 @@ import {
   useFeatureFlags
 } from '@/composables/useFeatureFlags'
 import * as distributionTypes from '@/platform/distribution/types'
+import {
+  cachedConsolidatedBillingEnabled,
+  cachedTeamWorkspacesEnabled,
+  remoteConfig,
+  remoteConfigState
+} from '@/platform/remoteConfig/remoteConfig'
 import { api } from '@/scripts/api'
 
 // Mock the API module
@@ -219,6 +225,86 @@ describe('useFeatureFlags', () => {
       const { flags } = useFeatureFlags()
       expect(flags.teamWorkspacesEnabled).toBe(true)
     })
+
+    it('consolidatedBillingEnabled override bypasses isCloud and isAuthenticatedConfigLoaded guards', () => {
+      vi.mocked(distributionTypes).isCloud = false
+      localStorage.setItem('ff:consolidated_billing_enabled', 'true')
+
+      const { flags } = useFeatureFlags()
+      expect(flags.consolidatedBillingEnabled).toBe(true)
+    })
+
+    it('consolidatedBillingEnabled is false off-cloud even without an override', () => {
+      vi.mocked(distributionTypes).isCloud = false
+
+      const { flags } = useFeatureFlags()
+      expect(flags.consolidatedBillingEnabled).toBe(false)
+    })
+  })
+
+  describe('auth-gated flags on cloud', () => {
+    beforeEach(() => {
+      vi.mocked(distributionTypes).isCloud = true
+      remoteConfigState.value = 'unloaded'
+      remoteConfig.value = {}
+      cachedTeamWorkspacesEnabled.value = undefined
+      cachedConsolidatedBillingEnabled.value = undefined
+      localStorage.clear()
+    })
+
+    afterEach(() => {
+      vi.mocked(distributionTypes).isCloud = false
+      remoteConfigState.value = 'unloaded'
+      remoteConfig.value = {}
+      cachedTeamWorkspacesEnabled.value = undefined
+      cachedConsolidatedBillingEnabled.value = undefined
+      localStorage.clear()
+    })
+
+    it('returns the cached session value during the auth window', () => {
+      cachedTeamWorkspacesEnabled.value = false
+      cachedConsolidatedBillingEnabled.value = true
+
+      const { flags } = useFeatureFlags()
+      expect(flags.teamWorkspacesEnabled).toBe(false)
+      expect(flags.consolidatedBillingEnabled).toBe(true)
+    })
+
+    it('defaults to false during the auth window when nothing is cached', () => {
+      const { flags } = useFeatureFlags()
+      expect(flags.teamWorkspacesEnabled).toBe(false)
+      expect(flags.consolidatedBillingEnabled).toBe(false)
+    })
+
+    it('prefers authenticated remoteConfig over the server feature fallback', () => {
+      remoteConfigState.value = 'authenticated'
+      remoteConfig.value = {
+        team_workspaces_enabled: true,
+        consolidated_billing_enabled: true
+      }
+      vi.mocked(api.getServerFeature).mockReturnValue(false)
+
+      const { flags } = useFeatureFlags()
+      expect(flags.teamWorkspacesEnabled).toBe(true)
+      expect(flags.consolidatedBillingEnabled).toBe(true)
+    })
+
+    it('falls back to api.getServerFeature when authenticated config omits the flag', () => {
+      remoteConfigState.value = 'authenticated'
+      remoteConfig.value = {}
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (path, defaultValue) => {
+          if (path === ServerFeatureFlag.TEAM_WORKSPACES_ENABLED) return true
+          if (path === ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED)
+            return true
+          return defaultValue
+        }
+      )
+
+      const { flags } = useFeatureFlags()
+      expect(flags.teamWorkspacesEnabled).toBe(true)
+      expect(flags.consolidatedBillingEnabled).toBe(true)
+    })
   })
 
   describe('signupTurnstileMode', () => {

src/composables/useFeatureFlags.ts

@@ -1,7 +1,9 @@
 import { computed, reactive, readonly } from 'vue'
+import type { Ref } from 'vue'
 
 import { isCloud, isNightly } from '@/platform/distribution/types'
 import {
+  cachedConsolidatedBillingEnabled,
   cachedTeamWorkspacesEnabled,
   isAuthenticatedConfigLoaded,
   remoteConfig
@@ -30,6 +32,7 @@ export enum ServerFeatureFlag {
   COMFYHUB_PROFILE_GATE_ENABLED = 'comfyhub_profile_gate_enabled',
   SHOW_SIGNIN_BUTTON = 'show_signin_button',
   UNIFIED_CLOUD_AUTH = 'unified_cloud_auth',
+  CONSOLIDATED_BILLING_ENABLED = 'consolidated_billing_enabled',
   SIGNUP_TURNSTILE = 'signup_turnstile'
 }
 
@@ -46,6 +49,26 @@ function resolveFlag<T>(
   return remoteConfigValue ?? api.getServerFeature(flagKey, defaultValue)
 }
 
+/**
+ * Resolves a per-user, Cloud-only flag that selects backend behavior. Off the
+ * Cloud build it is always false; during the auth window it falls back to the
+ * cached session value so anonymous bootstrap config cannot route the user to
+ * the wrong backend before authenticated config confirms the flag.
+ */
+function resolveAuthGatedFlag(
+  flagKey: string,
+  remoteConfigValue: boolean | undefined,
+  cachedValue: Ref<boolean | undefined>
+): boolean {
+  const override = getDevOverride<boolean>(flagKey)
+  if (override !== undefined) return override
+
+  if (!isCloud) return false
+  if (!isAuthenticatedConfigLoaded.value) return cachedValue.value ?? false
+
+  return remoteConfigValue ?? api.getServerFeature(flagKey, false)
+}
+
 /**
  * Composable for reactive access to server-side feature flags
  */
@@ -104,18 +127,10 @@ export function useFeatureFlags() {
      * and prevents race conditions during initialization.
      */
     get teamWorkspacesEnabled() {
-      const override = getDevOverride<boolean>(
-        ServerFeatureFlag.TEAM_WORKSPACES_ENABLED
-      )
-      if (override !== undefined) return override
-
-      if (!isCloud) return false
-      if (!isAuthenticatedConfigLoaded.value)
-        return cachedTeamWorkspacesEnabled.value ?? false
-
-      return (
-        remoteConfig.value.team_workspaces_enabled ??
-        api.getServerFeature(ServerFeatureFlag.TEAM_WORKSPACES_ENABLED, false)
+      return resolveAuthGatedFlag(
+        ServerFeatureFlag.TEAM_WORKSPACES_ENABLED,
+        remoteConfig.value.team_workspaces_enabled,
+        cachedTeamWorkspacesEnabled
       )
     },
     get userSecretsEnabled() {
@@ -175,6 +190,18 @@ export function useFeatureFlags() {
         false
       )
     },
+    /**
+     * Whether personal workspaces use the consolidated (workspace-scoped)
+     * billing flow. While false (default), personal workspaces stay on the
+     * legacy per-user billing flow; team workspaces are unaffected.
+     */
+    get consolidatedBillingEnabled() {
+      return resolveAuthGatedFlag(
+        ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED,
+        remoteConfig.value.consolidated_billing_enabled,
+        cachedConsolidatedBillingEnabled
+      )
+    },
     get signupTurnstileMode() {
       return resolveFlag(
         ServerFeatureFlag.SIGNUP_TURNSTILE,

src/core/graph/subgraph/migration/proxyWidgetMigration.ts

@@ -725,13 +725,10 @@ function migratePreview(
   }
 
   const hostNodeLocator = String(hostNode.id)
-  const existing = store
-    .getExposures(hostNode.rootGraph.id, hostNodeLocator)
-    .find(
-      (exposure) =>
-        exposure.sourceNodeId === entry.normalized.sourceNodeId &&
-        exposure.sourcePreviewName === plan.sourcePreviewName
-    )
+  const existing = store.findExposure(hostNode.rootGraph.id, hostNodeLocator, {
+    sourceNodeId: entry.normalized.sourceNodeId,
+    sourcePreviewName: plan.sourcePreviewName
+  })
   if (existing) return { ok: true, previewName: existing.name }
 
   const added = store.addExposure(hostNode.rootGraph.id, hostNodeLocator, {

src/core/graph/subgraph/promotionUtils.ts

@@ -186,13 +186,14 @@ function isPreviewExposed(
   source: PromotedWidgetSource
 ): boolean {
   const hostLocator = String(subgraphNode.id)
-  return usePreviewExposureStore()
-    .getExposures(subgraphNode.rootGraph.id, hostLocator)
-    .some(
-      (exposure) =>
-        exposure.sourceNodeId === source.sourceNodeId &&
-        exposure.sourcePreviewName === source.sourceWidgetName
-    )
+  return usePreviewExposureStore().hasExposure(
+    subgraphNode.rootGraph.id,
+    hostLocator,
+    {
+      sourceNodeId: source.sourceNodeId,
+      sourcePreviewName: source.sourceWidgetName
+    }
+  )
 }
 
 export function isWidgetPromotedOnSubgraphNode(
@@ -307,19 +308,10 @@ function promotePreviewViaExposure(
   const store = usePreviewExposureStore()
   const rootGraphId = subgraphNode.rootGraph.id
   const hostLocator = String(subgraphNode.id)
-  const existing = store
-    .getExposures(rootGraphId, hostLocator)
-    .some(
-      (exposure) =>
-        exposure.sourceNodeId === String(sourceNode.id) &&
-        exposure.sourcePreviewName === sourcePreviewName
-    )
-  if (existing) return
+  const source = { sourceNodeId: sourceNode.id, sourcePreviewName }
+  if (store.hasExposure(rootGraphId, hostLocator, source)) return
 
-  store.addExposure(rootGraphId, hostLocator, {
-    sourceNodeId: sourceNode.id,
-    sourcePreviewName
-  })
+  store.addExposure(rootGraphId, hostLocator, source)
 }
 
 const PREVIEW_WIDGET_TYPES = new Set(['preview', 'video', 'audioUI'])
@@ -402,13 +394,14 @@ export function demoteWidget(
     if (isPreviewPseudoWidget(widget)) {
       const previewStore = usePreviewExposureStore()
       const hostLocator = String(parent.id)
-      const exposure = previewStore
-        .getExposures(parent.rootGraph.id, hostLocator)
-        .find(
-          (entry) =>
-            entry.sourceNodeId === source.sourceNodeId &&
-            entry.sourcePreviewName === source.sourceWidgetName
-        )
+      const exposure = previewStore.findExposure(
+        parent.rootGraph.id,
+        hostLocator,
+        {
+          sourceNodeId: source.sourceNodeId,
+          sourcePreviewName: source.sourceWidgetName
+        }
+      )
       if (exposure) {
         previewStore.removeExposure(
           parent.rootGraph.id,

src/locales/en/main.json

@@ -2484,6 +2484,8 @@
     "model": "Model",
     "added": "Added",
     "accountInitialized": "Account initialized",
+    "loadEventsError": "Failed to load activity. Please try again.",
+    "loadEventsUnknownError": "Something went wrong while loading activity. Please refresh and try again.",
     "eventTypes": {
       "creditAdded": "Credits Added",
       "accountCreated": "Account Created",

src/platform/cloud/subscription/components/SubscriptionPanel.vue

@@ -18,7 +18,7 @@
       </div>
 
       <!-- Workspace mode: workspace-aware subscription content (renders its own footer) -->
-      <SubscriptionPanelContentWorkspace v-if="teamWorkspacesEnabled" />
+      <SubscriptionPanelContentWorkspace v-if="shouldUseWorkspaceBilling" />
       <!-- Legacy mode: user-level subscription content -->
       <template v-else>
         <SubscriptionPanelContentLegacy />
@@ -29,24 +29,20 @@
 </template>
 
 <script setup lang="ts">
-import { computed, defineAsyncComponent } from 'vue'
+import { defineAsyncComponent } from 'vue'
 
 import CloudBadge from '@/components/topbar/CloudBadge.vue'
 import { useBillingContext } from '@/composables/billing/useBillingContext'
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
+import { useBillingRouting } from '@/composables/billing/useBillingRouting'
 import SubscriptionFooterLinks from '@/platform/cloud/subscription/components/SubscriptionFooterLinks.vue'
 import SubscriptionPanelContentLegacy from '@/platform/cloud/subscription/components/SubscriptionPanelContentLegacy.vue'
-import { isCloud } from '@/platform/distribution/types'
 
 const SubscriptionPanelContentWorkspace = defineAsyncComponent(
   () =>
     import('@/platform/workspace/components/SubscriptionPanelContentWorkspace.vue')
 )
 
-const { flags } = useFeatureFlags()
-const teamWorkspacesEnabled = computed(
-  () => isCloud && flags.teamWorkspacesEnabled
-)
+const { shouldUseWorkspaceBilling } = useBillingRouting()
 
 const { isActiveSubscription } = useBillingContext()
 </script>

src/platform/cloud/subscription/composables/useSubscriptionDialog.test.ts

@@ -9,7 +9,7 @@ const mockTrackSubscription = vi.hoisted(() => vi.fn())
 const mockIsInPersonalWorkspace = vi.hoisted(() => ({ value: true }))
 const mockIsFreeTier = vi.hoisted(() => ({ value: false }))
 const mockTier = vi.hoisted(() => ({ value: 'FREE' as string | null }))
-const mockTeamWorkspacesEnabled = vi.hoisted(() => ({ value: false }))
+const mockShouldUseWorkspaceBilling = vi.hoisted(() => ({ value: false }))
 const mockIsCloud = vi.hoisted(() => ({ value: true }))
 const mockIsLegacyTeamPlan = vi.hoisted(() => ({ value: false }))
 const mockCanManageSubscription = vi.hoisted(() => ({ value: true }))
@@ -35,12 +35,10 @@ vi.mock('@/services/dialogService', () => ({
   })
 }))
 
-vi.mock('@/composables/useFeatureFlags', () => ({
-  useFeatureFlags: () => ({
-    flags: {
-      get teamWorkspacesEnabled() {
-        return mockTeamWorkspacesEnabled.value
-      }
+vi.mock('@/composables/billing/useBillingRouting', () => ({
+  useBillingRouting: () => ({
+    get shouldUseWorkspaceBilling() {
+      return mockShouldUseWorkspaceBilling
     }
   })
 }))
@@ -88,7 +86,7 @@ describe('useSubscriptionDialog', () => {
     mockIsInPersonalWorkspace.value = true
     mockIsFreeTier.value = false
     mockTier.value = 'FREE'
-    mockTeamWorkspacesEnabled.value = false
+    mockShouldUseWorkspaceBilling.value = false
     mockIsLegacyTeamPlan.value = false
     mockCanManageSubscription.value = true
 
@@ -119,7 +117,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('does not wire onChooseTeam on the unified table (personal subscribes directly)', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -131,7 +129,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('sizes the unified pricing dialog via the Reka contentClass, not the ignored PrimeVue style', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -146,7 +144,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('defaults to the personal tab in a personal workspace', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -157,7 +155,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('opens the team tab when planMode is forced from a personal workspace', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -167,8 +165,9 @@ describe('useSubscriptionDialog', () => {
       expect(props.initialPlanMode).toBe('team')
     })
 
-    it('uses the legacy table (with onChooseTeam) when team workspaces are disabled', () => {
-      mockTeamWorkspacesEnabled.value = false
+    it('uses the legacy table (with onChooseTeam) on the legacy billing flow', () => {
+      mockShouldUseWorkspaceBilling.value = false
+      mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
       showPricingTable()
@@ -178,7 +177,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('routes an existing per-member (legacy) team subscriber to the old team table', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = false
       mockIsLegacyTeamPlan.value = true
       const { showPricingTable } = useSubscriptionDialog()
@@ -196,7 +195,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('keeps a non-legacy (credit-slider) team subscriber on the unified table', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = false
       mockIsLegacyTeamPlan.value = false
       const { showPricingTable } = useSubscriptionDialog()
@@ -220,7 +219,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('tracks modal_opened on the workspace (unified) path too', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
       showPricingTable({ reason: 'subscribe_to_run' })
@@ -232,7 +231,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('does not track modal_opened for the inactive member dialog', () => {
-      mockTeamWorkspacesEnabled.value = true
+      mockShouldUseWorkspaceBilling.value = true
       mockIsInPersonalWorkspace.value = false
       mockCanManageSubscription.value = false
       const { showPricingTable } = useSubscriptionDialog()

src/platform/cloud/subscription/composables/useSubscriptionDialog.ts

@@ -2,7 +2,7 @@ import { defineAsyncComponent } from 'vue'
 import { useDialogService } from '@/services/dialogService'
 import { useDialogStore } from '@/stores/dialogStore'
 import { useBillingContext } from '@/composables/billing/useBillingContext'
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
+import { useBillingRouting } from '@/composables/billing/useBillingRouting'
 import { isCloud } from '@/platform/distribution/types'
 import { useTelemetry } from '@/platform/telemetry'
 import type { PaymentIntentSource } from '@/platform/telemetry/types'
@@ -24,7 +24,7 @@ export interface SubscriptionDialogOptions {
 }
 
 export const useSubscriptionDialog = () => {
-  const { flags } = useFeatureFlags()
+  const { shouldUseWorkspaceBilling } = useBillingRouting()
   const dialogService = useDialogService()
   const dialogStore = useDialogStore()
   const workspaceStore = useTeamWorkspaceStore()
@@ -57,7 +57,7 @@ export const useSubscriptionDialog = () => {
     // small read-only "ask your owner to reactivate" modal instead of the
     // pricing table. Out-of-credits still routes everyone to the credits flow.
     if (
-      flags.teamWorkspacesEnabled &&
+      shouldUseWorkspaceBilling.value &&
       !workspaceStore.isInPersonalWorkspace &&
       !permissions.value.canManageSubscription &&
       options?.reason !== 'out_of_credits'
@@ -95,9 +95,10 @@ export const useSubscriptionDialog = () => {
     }
 
     // Jun-5 model: a single unified pricing table (personal/team plan toggle on
-    // one workspace) when team workspaces are enabled. Replaces the old
-    // personal-vs-team workspace fork. Flag-off keeps the legacy table.
-    if (flags.teamWorkspacesEnabled) {
+    // one workspace) for workspaces on the consolidated billing flow. Replaces
+    // the old personal-vs-team workspace fork. Personal workspaces still on the
+    // legacy flow (consolidated billing disabled) get the legacy table.
+    if (shouldUseWorkspaceBilling.value) {
       // Existing per-member (legacy) team subscribers keep the old tier-based
       // team table; the unified credit-slider table is for everyone else.
       // Resolved lazily (not at composable setup): these three composables form

src/platform/remoteConfig/refreshRemoteConfig.ts

@@ -1,4 +1,5 @@
 import {
+  cachedConsolidatedBillingEnabled,
   cachedTeamWorkspacesEnabled,
   remoteConfig,
   remoteConfigState
@@ -55,10 +56,14 @@ export async function refreshRemoteConfig(
       window.__CONFIG__ = config
       remoteConfig.value = config
       remoteConfigState.value = useAuth ? 'authenticated' : 'anonymous'
-      if (useAuth)
+      if (useAuth) {
         cachedTeamWorkspacesEnabled.value = Boolean(
           config.team_workspaces_enabled
         )
+        cachedConsolidatedBillingEnabled.value = Boolean(
+          config.consolidated_billing_enabled
+        )
+      }
       return
     }
 

src/platform/remoteConfig/remoteConfig.ts

@@ -59,3 +59,8 @@ export const cachedTeamWorkspacesEnabled = useStorage<boolean | undefined>(
   'team_workspaces_enabled' satisfies `${ServerFeatureFlag.TEAM_WORKSPACES_ENABLED}`,
   undefined
 )
+
+export const cachedConsolidatedBillingEnabled = useStorage<boolean | undefined>(
+  'consolidated_billing_enabled' satisfies `${ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED}`,
+  undefined
+)

src/platform/remoteConfig/types.ts

@@ -111,6 +111,7 @@ export type RemoteConfig = {
   comfyhub_upload_enabled?: boolean
   comfyhub_profile_gate_enabled?: boolean
   unified_cloud_auth?: boolean
+  consolidated_billing_enabled?: boolean
   sentry_dsn?: string
   turnstile_sitekey?: string
   // Raw, unvalidated wire value (a server typo like 'enfroce' is possible).

src/platform/settings/composables/useSettingUI.test.ts

@@ -11,21 +11,49 @@ import type { SettingTreeNode } from '@/platform/settings/settingStore'
 
 import { useSettingUI } from './useSettingUI'
 
+const env = vi.hoisted(() => {
+  const state = {
+    isCloud: false,
+    isDesktop: false,
+    isLoggedIn: false,
+    teamWorkspacesEnabled: false,
+    userSecretsEnabled: false,
+    isActiveSubscription: false,
+    billingType: 'legacy' as 'legacy' | 'workspace'
+  }
+  const fakeRef = <K extends keyof typeof state>(key: K) => ({
+    get value() {
+      return state[key]
+    }
+  })
+  return { state, fakeRef }
+})
+
 vi.mock('vue-i18n', () => ({
   useI18n: () => ({ t: (_: string, fallback: string) => fallback })
 }))
 
 vi.mock('@/composables/auth/useCurrentUser', () => ({
-  useCurrentUser: () => ({ isLoggedIn: ref(false) })
+  useCurrentUser: () => ({ isLoggedIn: env.fakeRef('isLoggedIn') })
 }))
 
 vi.mock('@/composables/billing/useBillingContext', () => ({
-  useBillingContext: () => ({ isActiveSubscription: ref(false) })
+  useBillingContext: () => ({
+    isActiveSubscription: env.fakeRef('isActiveSubscription'),
+    type: env.fakeRef('billingType')
+  })
 }))
 
 vi.mock('@/composables/useFeatureFlags', () => ({
   useFeatureFlags: () => ({
-    flags: { teamWorkspacesEnabled: false, userSecretsEnabled: false }
+    flags: {
+      get teamWorkspacesEnabled() {
+        return env.state.teamWorkspacesEnabled
+      },
+      get userSecretsEnabled() {
+        return env.state.userSecretsEnabled
+      }
+    }
   })
 }))
 
@@ -34,8 +62,12 @@ vi.mock('@/composables/useVueFeatureFlags', () => ({
 }))
 
 vi.mock('@/platform/distribution/types', () => ({
-  isCloud: false,
-  isDesktop: false
+  get isCloud() {
+    return env.state.isCloud
+  },
+  get isDesktop() {
+    return env.state.isDesktop
+  }
 }))
 
 vi.mock('@/platform/settings/settingStore', () => ({
@@ -77,6 +109,16 @@ describe('useSettingUI', () => {
     setActivePinia(createTestingPinia())
     vi.clearAllMocks()
 
+    Object.assign(env.state, {
+      isCloud: false,
+      isDesktop: false,
+      isLoggedIn: false,
+      teamWorkspacesEnabled: false,
+      userSecretsEnabled: false,
+      isActiveSubscription: false,
+      billingType: 'legacy'
+    })
+
     vi.mocked(useSettingStore).mockReturnValue({
       settingsById: mockSettings
     } as ReturnType<typeof useSettingStore>)
@@ -137,4 +179,59 @@ describe('useSettingUI', () => {
     const { defaultCategory } = useSettingUI('about', 'Comfy.Locale')
     expect(defaultCategory.value.key).toBe('about')
   })
+
+  describe('legacy billing in the workspace layout', () => {
+    const navKeys = (groups: { items: { id: string }[] }[]) =>
+      groups.flatMap((group) => group.items.map((item) => item.id))
+
+    beforeEach(() => {
+      Object.assign(env.state, {
+        isCloud: true,
+        isLoggedIn: true,
+        teamWorkspacesEnabled: true,
+        isActiveSubscription: true
+      })
+      window.__CONFIG__ = {
+        subscription_required: true
+      } as typeof window.__CONFIG__
+    })
+
+    it('exposes the legacy plan panel when billing is legacy', () => {
+      env.state.billingType = 'legacy'
+      const { defaultCategory, navGroups } = useSettingUI('subscription')
+
+      expect(defaultCategory.value.key).toBe('subscription')
+      expect(navKeys(navGroups.value)).toContain('subscription')
+      expect(navKeys(navGroups.value)).toContain('workspace')
+    })
+
+    it('hides the legacy plan panel when billing is workspace', () => {
+      env.state.billingType = 'workspace'
+      const { navGroups } = useSettingUI()
+
+      expect(navKeys(navGroups.value)).not.toContain('subscription')
+      expect(navKeys(navGroups.value)).toContain('workspace')
+    })
+
+    it('never renders the plan panel in more than one tab', () => {
+      const countSubscription = () => {
+        const { navGroups } = useSettingUI()
+        return navKeys(navGroups.value).filter((id) => id === 'subscription')
+          .length
+      }
+
+      for (const teamWorkspacesEnabled of [true, false]) {
+        for (const billingType of ['legacy', 'workspace'] as const) {
+          for (const isLoggedIn of [true, false]) {
+            Object.assign(env.state, {
+              teamWorkspacesEnabled,
+              billingType,
+              isLoggedIn
+            })
+            expect(countSubscription()).toBeLessThanOrEqual(1)
+          }
+        }
+      }
+    })
+  })
 })

src/platform/settings/composables/useSettingUI.ts

@@ -53,7 +53,7 @@ export function useSettingUI(
 
   const { flags } = useFeatureFlags()
   const { shouldRenderVueNodes } = useVueFeatureFlags()
-  const { isActiveSubscription } = useBillingContext()
+  const { isActiveSubscription, type: billingType } = useBillingContext()
 
   const teamWorkspacesEnabled = computed(
     () => isCloud && flags.teamWorkspacesEnabled
@@ -157,6 +157,13 @@ export function useSettingUI(
     return isActiveSubscription.value
   })
 
+  const shouldShowLegacyPlanCreditsPanel = computed(
+    () =>
+      isLoggedIn.value &&
+      billingType.value === 'legacy' &&
+      shouldShowPlanCreditsPanel.value
+  )
+
   const userPanel: SettingPanelItem = {
     node: {
       key: 'user',
@@ -301,6 +308,9 @@ export function useSettingUI(
       label: 'General',
       children: [
         translateCategory(userPanel.node),
+        ...(shouldShowLegacyPlanCreditsPanel.value && subscriptionPanel
+          ? [translateCategory(subscriptionPanel.node)]
+          : []),
         ...coreSettingCategories.value.slice(0, 1).map(translateCategory),
         ...(shouldShowSecretsPanel.value
           ? [translateCategory(secretsPanel.node)]
@@ -332,9 +342,7 @@ export function useSettingUI(
       label: 'Account',
       children: [
         userPanel.node,
-        ...(isLoggedIn.value &&
-        shouldShowPlanCreditsPanel.value &&
-        subscriptionPanel
+        ...(shouldShowLegacyPlanCreditsPanel.value && subscriptionPanel
           ? [subscriptionPanel.node]
           : []),
         ...(shouldShowSecretsPanel.value ? [secretsPanel.node] : []),

src/stores/executionInterrupt.test.ts

@@ -1,120 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers, openSet } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-  openSet: new Set<unknown>()
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: (workflow: unknown) => openSet.has(workflow),
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function startJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  wf: ComfyWorkflow,
-  nodes: string[] = []
-) {
-  openSet.add(wf)
-  store.storeJob({ nodes, id, promptOutput: promptOutput(), workflow: wf })
-  handlers['execution_start']?.({ detail: { prompt_id: id } })
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  openSet.clear()
-})
-
-describe('executionStore interrupt and cached', () => {
-  it('drops the workflow badge and goes idle on interruption', () => {
-    const store = setup()
-    const wf = workflow('a.json')
-    startJob(store, 'job-1', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    handlers['execution_interrupted']?.({ detail: { prompt_id: 'job-1' } })
-
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-    expect(store.isIdle).toBe(true)
-  })
-
-  it('ends the active job when executing resolves to null', () => {
-    const store = setup()
-    startJob(store, 'job-2', workflow('b.json'))
-    expect(store.isIdle).toBe(false)
-
-    handlers['executing']?.({ detail: null })
-
-    expect(store.isIdle).toBe(true)
-  })
-
-  it('marks cached nodes as executed', () => {
-    const store = setup()
-    startJob(store, 'job-3', workflow('c.json'), ['a', 'b', 'c'])
-    expect(store.nodesExecuted).toBe(0)
-
-    handlers['execution_cached']?.({
-      detail: { prompt_id: 'job-3', nodes: ['a', 'b'] }
-    })
-
-    expect(store.nodesExecuted).toBe(2)
-  })
-})

src/stores/executionLifecycle.test.ts

@@ -1,119 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => false,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function startJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  nodes: string[]
-) {
-  store.storeJob({
-    nodes,
-    id,
-    promptOutput: promptOutput(),
-    workflow: { path: `${id}.json` } as unknown as ComfyWorkflow
-  })
-  handlers['execution_start']?.({ detail: { prompt_id: id } })
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-})
-
-describe('executionStore execution lifecycle', () => {
-  it('reports zero progress while idle', () => {
-    const store = setup()
-    expect(store.totalNodesToExecute).toBe(0)
-    expect(store.nodesExecuted).toBe(0)
-    expect(store.executionProgress).toBe(0)
-  })
-
-  it('counts the queued nodes once a job starts', () => {
-    const store = setup()
-    startJob(store, 'job-1', ['a', 'b', 'c'])
-
-    expect(store.totalNodesToExecute).toBe(3)
-    expect(store.nodesExecuted).toBe(0)
-    expect(store.executionProgress).toBe(0)
-  })
-
-  it('advances progress as executed events arrive', () => {
-    const store = setup()
-    startJob(store, 'job-1', ['a', 'b', 'c'])
-
-    handlers['executed']?.({ detail: { node: 'a' } })
-    expect(store.nodesExecuted).toBe(1)
-    expect(store.executionProgress).toBeCloseTo(1 / 3)
-
-    handlers['executed']?.({ detail: { node: 'b' } })
-    handlers['executed']?.({ detail: { node: 'c' } })
-    expect(store.nodesExecuted).toBe(3)
-    expect(store.executionProgress).toBe(1)
-  })
-
-  it('ignores executed events when there is no active job', () => {
-    const store = setup()
-    handlers['executed']?.({ detail: { node: 'a' } })
-    expect(store.nodesExecuted).toBe(0)
-  })
-})

src/stores/executionNodeProgress.test.ts

@@ -1,129 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { NodeProgressState } from '@/schemas/apiSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => false,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/stores/nodeOutputStore', () => ({
-  useNodeOutputStore: () => ({ revokePreviewsByExecutionId: () => {} })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-// Derive from the real schema type so the test shape can't drift; keep the
-// non-essential fields optional so cases only spell out what they assert on.
-type NodeState = Partial<NodeProgressState> & Pick<NodeProgressState, 'state'>
-
-function progressState(jobId: string, nodes: Record<string, NodeState>) {
-  handlers['progress_state']?.({ detail: { prompt_id: jobId, nodes } })
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-})
-
-describe('executionStore node progress', () => {
-  it('is idle until an execution starts', () => {
-    const store = setup()
-    expect(store.isIdle).toBe(true)
-
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-1' } })
-    expect(store.isIdle).toBe(false)
-  })
-
-  it('derives the running node ids from a progress_state event', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'running', value: 1, max: 4 },
-      n2: { state: 'finished' },
-      n3: { state: 'pending' }
-    })
-
-    expect(store.executingNodeIds).toEqual(['n1'])
-    expect(store.executingNodeId).toBe('n1')
-  })
-
-  it('exposes fractional progress for the executing node', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'running', value: 1, max: 4 }
-    })
-
-    expect(store.executingNodeProgress).toBe(0.25)
-  })
-
-  it('reports no executing node when none are running', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'finished' },
-      n2: { state: 'pending' }
-    })
-
-    expect(store.executingNodeIds).toEqual([])
-    expect(store.executingNodeId).toBeNull()
-  })
-
-  it('replaces progress state on each progress_state event', () => {
-    const store = setup()
-
-    progressState('job-1', { n1: { state: 'running', value: 1, max: 4 } })
-    expect(store.executingNodeId).toBe('n1')
-
-    progressState('job-1', { n2: { state: 'running', value: 2, max: 2 } })
-    expect(store.executingNodeIds).toEqual(['n2'])
-  })
-})

src/stores/executionRunningState.test.ts

@@ -1,173 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-import type { classifyCloudValidationError } from '@/utils/executionErrorUtil'
-
-type CloudValidationResult = ReturnType<typeof classifyCloudValidationError>
-
-const { handlers, errorStore, activeWorkflow, dist, classifyCloud } =
-  vi.hoisted(() => ({
-    handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-    errorStore: {
-      clearExecutionStartErrors: () => {},
-      clearPromptError: () => {}
-    } as Record<string, unknown>,
-    activeWorkflow: { value: null as { path: string } | null },
-    dist: { isCloud: false },
-    classifyCloud: vi.fn<(_: string) => CloudValidationResult>(() => null)
-  }))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => true,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null,
-    get activeWorkflow() {
-      return activeWorkflow.value
-    }
-  })
-}))
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => errorStore
-}))
-vi.mock('@/stores/nodeOutputStore', () => ({
-  useNodeOutputStore: () => ({ revokePreviewsByExecutionId: () => {} })
-}))
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  }
-}))
-vi.mock('@/platform/errorCatalog/accountPreconditionRouting', () => ({
-  resolveAccountPrecondition: () => null
-}))
-vi.mock('@/utils/executionErrorUtil', () => ({
-  classifyCloudValidationError: classifyCloud
-}))
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  activeWorkflow.value = null
-  dist.isCloud = false
-  classifyCloud.mockReturnValue(null)
-  for (const k of ['lastPromptError', 'lastNodeErrors', 'lastExecutionError'])
-    delete errorStore[k]
-})
-
-describe('executionStore running state and error edges', () => {
-  it('lists jobs with a running node and counts running workflows', () => {
-    const store = setup()
-    handlers['progress_state']?.({
-      detail: {
-        prompt_id: 'job-1',
-        nodes: { n1: { state: 'running', value: 1, max: 2 } }
-      }
-    })
-
-    expect(store.runningJobIds).toEqual(['job-1'])
-    expect(store.runningWorkflowCount).toBe(1)
-  })
-
-  it('does not report the active workflow as running when the path differs', () => {
-    const store = setup()
-    expect(store.isActiveWorkflowRunning).toBe(false)
-
-    const wf = workflow('w.json')
-    activeWorkflow.value = { path: 'other.json' }
-    store.storeJob({
-      nodes: [],
-      id: 'job-2',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-2' } })
-
-    expect(store.isActiveWorkflowRunning).toBe(false)
-  })
-
-  it('reports the active workflow as running when job, path and session agree', () => {
-    const store = setup()
-    const wf = workflow('w.json')
-    activeWorkflow.value = { path: 'w.json' }
-    store.storeJob({
-      nodes: [],
-      id: 'job-2',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-2' } })
-
-    expect(store.isActiveWorkflowRunning).toBe(true)
-  })
-
-  it('formats a service-level error message from the exception message alone', () => {
-    setup()
-    handlers['execution_error']?.({
-      detail: { prompt_id: 'job-3', exception_message: 'Job has stagnated' }
-    })
-
-    expect(errorStore.lastPromptError).toEqual({
-      type: 'error',
-      message: 'Job has stagnated',
-      details: ''
-    })
-  })
-
-  it('stores a classified cloud prompt error on the prompt-error branch', () => {
-    dist.isCloud = true
-    classifyCloud.mockReturnValue({
-      kind: 'promptError',
-      promptError: { type: 'validation', message: 'bad input', details: '' }
-    })
-    setup()
-
-    handlers['execution_error']?.({
-      detail: { prompt_id: 'job-4', exception_message: '{}' }
-    })
-
-    expect(errorStore.lastPromptError).toEqual({
-      type: 'validation',
-      message: 'bad input',
-      details: ''
-    })
-  })
-})

src/stores/executionStore.test.ts

@@ -22,8 +22,7 @@ const {
   mockShowTextPreview,
   mockTrackExecutionError,
   mockTrackExecutionSuccess,
-  mockTrackSharedWorkflowRun,
-  mockRevokePreviewsByExecutionId
+  mockTrackSharedWorkflowRun
 } = await vi.hoisted(async () => {
   const { shallowRef } = await import('vue')
   return {
@@ -35,8 +34,7 @@ const {
     mockShowTextPreview: vi.fn(),
     mockTrackExecutionError: vi.fn(),
     mockTrackExecutionSuccess: vi.fn(),
-    mockTrackSharedWorkflowRun: vi.fn(),
-    mockRevokePreviewsByExecutionId: vi.fn()
+    mockTrackSharedWorkflowRun: vi.fn()
   }
 })
 
@@ -131,7 +129,7 @@ vi.mock('@/scripts/api', () => ({
 
 vi.mock('@/stores/nodeOutputStore', () => ({
   useNodeOutputStore: () => ({
-    revokePreviewsByExecutionId: mockRevokePreviewsByExecutionId
+    revokePreviewsByExecutionId: vi.fn()
   })
 }))
 
@@ -425,124 +423,6 @@ describe('useExecutionStore - nodeLocationProgressStates caching', () => {
       'running'
     )
   })
-
-  it('keeps an existing error state when later progress maps to the same locator', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'error',
-        value: 0,
-        max: 100,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123:456',
-        state: 'running',
-        value: 50,
-        max: 100,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-        .state
-    ).toBe('error')
-  })
-
-  it('ignores finished progress when current state is already running', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'running',
-        value: 5,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'finished',
-        value: 10,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 5 })
-  })
-
-  it('keeps later running progress from moving a locator backwards', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'running',
-        value: 6,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'running',
-        value: 8,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 6, max: 10 })
-  })
-
-  it('merges zero-max running progress without dividing by zero', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'pending',
-        value: 0,
-        max: 0,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'running',
-        value: 0,
-        max: 0,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 0, max: 0 })
-  })
-
-  it('skips nested progress when the execution id cannot be resolved', () => {
-    vi.mocked(app.rootGraph.getNodeById).mockReturnValue(null)
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '404:1',
-        state: 'running',
-        value: 5,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      }
-    }
-
-    expect(store.nodeLocationProgressStates).toHaveProperty('404')
-    expect(store.nodeLocationProgressStates).not.toHaveProperty('404:1')
-  })
 })
 
 describe('useExecutionStore - nodeProgressStatesByJob eviction', () => {
@@ -671,33 +551,6 @@ describe('useExecutionStore - reconcileInitializingJobs', () => {
 
     expect(store.initializingJobIds).toEqual(new Set())
   })
-
-  it('clears initialization ids directly', () => {
-    store.initializingJobIds = new Set(['job-1'])
-
-    store.clearInitializationByJobId(null)
-    store.clearInitializationByJobId('missing')
-    store.clearInitializationByJobId('job-1')
-
-    expect(store.initializingJobIds).toEqual(new Set())
-  })
-
-  it('checks initializing jobs by stringified id', () => {
-    store.initializingJobIds = new Set(['7'])
-
-    expect(store.isJobInitializing(undefined)).toBe(false)
-    expect(store.isJobInitializing(7)).toBe(true)
-  })
-
-  it('does not rewrite initializing state when no requested ids are tracked', () => {
-    store.initializingJobIds = new Set(['job-1'])
-    const before = store.initializingJobIds
-
-    store.clearInitializationByJobIds(['missing'])
-
-    expect(store.initializingJobIds).toBe(before)
-    expect(store.initializingJobIds).toEqual(new Set(['job-1']))
-  })
 })
 
 describe('useExecutionStore - workflowStatus', () => {
@@ -822,16 +675,6 @@ describe('useExecutionStore - workflowStatus', () => {
     expect(store.getWorkflowStatus(workflowA)).toBe('completed')
   })
 
-  it('leaves workflowStatus unchanged when open workflows are unchanged', async () => {
-    callStoreJob('job-a', workflowA)
-    fireExecutionSuccess('job-a')
-
-    mockOpenWorkflows.value = [workflowA, workflowB]
-    await nextTick()
-
-    expect(store.getWorkflowStatus(workflowA)).toBe('completed')
-  })
-
   it('sets failed on execution_error', () => {
     callStoreJob('job-1', workflowA)
     fireExecutionStart('job-1')
@@ -848,14 +691,6 @@ describe('useExecutionStore - workflowStatus', () => {
     expect(store.getWorkflowStatus(workflowA)).toBeUndefined()
   })
 
-  it('handles interrupt for a queued workflow with no active job', () => {
-    callStoreJob('job-1', workflowA)
-
-    fireExecutionInterrupted('job-1')
-
-    expect(store.getWorkflowStatus(workflowA)).toBeUndefined()
-  })
-
   it('evicts the oldest pending status once the buffer cap is exceeded', () => {
     // Each start with no matching storeJob buffers a 'running' status. One
     // past the cap evicts the oldest so the buffer can't grow unbounded.
@@ -1065,35 +900,6 @@ describe('useExecutionStore - progress_text startup guard', () => {
 
     expect(mockShowTextPreview).toHaveBeenCalledWith(mockNode, 'warming up')
   })
-
-  it('should ignore progress_text for another active prompt', async () => {
-    const mockNode = createMockLGraphNode({ id: 1 })
-    const { useCanvasStore } =
-      await import('@/renderer/core/canvas/canvasStore')
-    useCanvasStore().canvas = {
-      graph: { getNodeById: vi.fn(() => mockNode) }
-    } as unknown as LGraphCanvas
-    store.activeJobId = 'job-1'
-
-    fireProgressText({
-      nodeId: toNodeId('1'),
-      text: 'warming up',
-      prompt_id: 'job-2'
-    })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
-
-  it('should ignore progress_text without text or node id', () => {
-    fireProgressText({ nodeId: toNodeId('1'), text: '' })
-    fireProgressText({
-      nodeId: '' as ReturnType<typeof toNodeId>,
-      text: 'warming up'
-    })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
-
   it('should ignore nested progress_text when the execution ID cannot be mapped', async () => {
     const { useCanvasStore } =
       await import('@/renderer/core/canvas/canvasStore')
@@ -1109,19 +915,6 @@ describe('useExecutionStore - progress_text startup guard', () => {
     expect(mockExecutionIdToCurrentId).toHaveBeenCalledWith('1:2')
     expect(mockShowTextPreview).not.toHaveBeenCalled()
   })
-
-  it('should ignore progress_text when the current node id cannot be parsed', async () => {
-    const { useCanvasStore } =
-      await import('@/renderer/core/canvas/canvasStore')
-    useCanvasStore().canvas = {
-      graph: { getNodeById: vi.fn() }
-    } as unknown as LGraphCanvas
-    mockExecutionIdToCurrentId.mockReturnValue({})
-
-    fireProgressText({ nodeId: toNodeId('1:2'), text: 'warming up' })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
 })
 
 describe('useExecutionErrorStore - Node Error Lookups', () => {
@@ -1582,21 +1375,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       expect(store.initializingJobIds.has('job-1')).toBe(false)
       expect(store.initializingJobIds.has('job-2')).toBe(true)
     })
-
-    it('captures a queued workflow path when the start event wins the race', () => {
-      store.queuedJobs = {
-        'job-1': {
-          nodes: {},
-          workflow: createQueuedWorkflow('/workflows/race.json')
-        }
-      }
-
-      fire('execution_start', { prompt_id: 'job-1', timestamp: 0 })
-
-      expect(store.jobIdToSessionWorkflowPath.get('job-1')).toBe(
-        '/workflows/race.json'
-      )
-    })
   })
 
   describe('execution_cached', () => {
@@ -1784,35 +1562,9 @@ describe('useExecutionStore - WebSocket event handlers', () => {
         is_app_mode: true
       })
     })
-
-    it('uses current mode when shared queued job has no queued mode snapshot', () => {
-      mockAppModeState.mode.value = 'app'
-      mockAppModeState.isAppMode.value = true
-      store.queuedJobs = {
-        'job-1': {
-          nodes: {},
-          shareId: 'share-1'
-        }
-      }
-
-      fire('execution_success', { prompt_id: 'job-1', timestamp: 0 })
-
-      expect(mockTrackSharedWorkflowRun).toHaveBeenCalledWith({
-        job_id: 'job-1',
-        share_id: 'share-1',
-        view_mode: 'app',
-        is_app_mode: true
-      })
-    })
   })
 
   describe('executing', () => {
-    it('is a no-op when there is no active job', () => {
-      fire('executing', null)
-
-      expect(store.activeJobId).toBeNull()
-    })
-
     it('clears _executingNodeProgress and activeJobId when detail is null', () => {
       fire('execution_start', { prompt_id: 'job-1', timestamp: 0 })
       store._executingNodeProgress = {
@@ -1838,34 +1590,7 @@ describe('useExecutionStore - WebSocket event handlers', () => {
     })
   })
 
-  describe('progress_state', () => {
-    it('does not revoke previews when the node execution id is invalid', () => {
-      mockRevokePreviewsByExecutionId.mockClear()
-
-      fire('progress_state', {
-        prompt_id: 'job-1',
-        nodes: {
-          '': {
-            value: 1,
-            max: 2,
-            state: 'running',
-            node_id: '',
-            display_node_id: '',
-            prompt_id: 'job-1'
-          }
-        }
-      })
-
-      expect(mockRevokePreviewsByExecutionId).not.toHaveBeenCalled()
-      expect(store.nodeProgressStates).toHaveProperty('')
-    })
-  })
-
   describe('progress', () => {
-    it('reports null executing node progress before progress events arrive', () => {
-      expect(store.executingNodeProgress).toBeNull()
-    })
-
     it('sets _executingNodeProgress from the event payload', () => {
       const payload = { value: 3, max: 10, prompt_id: 'job-1', node: 'n1' }
 
@@ -1885,24 +1610,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       expect(store.clientId).toBe('test-client')
       expect(removeSpy).toHaveBeenCalledWith('status', expect.any(Function))
     })
-
-    it('keeps listening when status arrives before clientId is available', async () => {
-      const apiModule = await import('@/scripts/api')
-      const removeSpy = vi.mocked(apiModule.api.removeEventListener)
-      apiModule.api.clientId = ''
-
-      try {
-        fire('status', { exec_info: { queue_remaining: 0 } })
-
-        expect(store.clientId).toBeNull()
-        expect(removeSpy).not.toHaveBeenCalledWith(
-          'status',
-          expect.any(Function)
-        )
-      } finally {
-        apiModule.api.clientId = 'test-client'
-      }
-    })
   })
 
   describe('execution_error', () => {
@@ -1924,40 +1631,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       })
     })
 
-    it('uses the message directly for service-level errors without a type', () => {
-      const errorStore = useExecutionErrorStore()
-
-      fire('execution_error', {
-        prompt_id: 'job-1',
-        node_id: null,
-        exception_message: 'Job failed before node execution',
-        traceback: []
-      })
-
-      expect(errorStore.lastPromptError).toMatchObject({
-        type: 'error',
-        message: 'Job failed before node execution',
-        details: ''
-      })
-    })
-
-    it('uses an empty prompt message for service-level errors without backend copy', () => {
-      const errorStore = useExecutionErrorStore()
-
-      fire('execution_error', {
-        prompt_id: 'job-1',
-        node_id: null,
-        exception_message: '',
-        traceback: []
-      })
-
-      expect(errorStore.lastPromptError).toMatchObject({
-        type: 'error',
-        message: '',
-        details: ''
-      })
-    })
-
     it('routes a runtime error (with node_id) to lastExecutionError', () => {
       const errorStore = useExecutionErrorStore()
 
@@ -2071,12 +1744,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
 
       expect(store.initializingJobIds.has('job-9')).toBe(false)
     })
-
-    it('ignores notifications without text', () => {
-      fire('notification', { id: 'job-9' })
-
-      expect(store.initializingJobIds.has('job-9')).toBe(false)
-    })
   })
 
   describe('unbindExecutionEvents', () => {
@@ -2146,45 +1813,6 @@ describe('useExecutionStore - storeJob and workflow path tracking', () => {
     )
   })
 
-  it('storeJob works without workflow metadata', () => {
-    const workflow = {} as Parameters<typeof store.storeJob>[0]['workflow']
-    const missingWorkflow = undefined as unknown as Parameters<
-      typeof store.storeJob
-    >[0]['workflow']
-
-    store.storeJob({
-      nodes: ['a'],
-      id: 'job-1',
-      promptOutput: {
-        a: createPromptNode('Node A', 'NodeA')
-      },
-      workflow
-    })
-
-    expect(store.queuedJobs['job-1']?.nodes).toEqual({ a: false })
-    expect(store.jobIdToWorkflowId.has('job-1')).toBe(false)
-    expect(store.jobIdToSessionWorkflowPath.has('job-1')).toBe(false)
-
-    store.storeJob({
-      nodes: ['b'],
-      id: 'job-2',
-      promptOutput: {
-        b: createPromptNode('Node B', 'NodeB')
-      },
-      workflow: missingWorkflow
-    })
-
-    expect(store.queuedJobs['job-2']?.nodes).toEqual({ b: false })
-    expect(store.queuedJobs['job-2']?.workflow).toBeUndefined()
-  })
-
-  it('reports zero execution progress for an active job with no nodes', () => {
-    store.activeJobId = 'job-1'
-    store.queuedJobs = { 'job-1': { nodes: {} } }
-
-    expect(store.executionProgress).toBe(0)
-  })
-
   it('registerJobWorkflowIdMapping ignores empty inputs', () => {
     store.registerJobWorkflowIdMapping('job-1', 'wf-1')
     store.registerJobWorkflowIdMapping('', 'wf-2')
@@ -2201,58 +1829,4 @@ describe('useExecutionStore - storeJob and workflow path tracking', () => {
 
     expect(store.jobIdToSessionWorkflowPath.get('job-1')).toBe('/b.json')
   })
-
-  it('evicts the oldest workflow paths when the session map exceeds capacity', () => {
-    for (let i = 0; i < 4001; i++) {
-      store.ensureSessionWorkflowPath(`job-${i}`, `/workflow-${i}.json`)
-    }
-
-    expect(store.jobIdToSessionWorkflowPath.size).toBe(4000)
-    expect(store.jobIdToSessionWorkflowPath.has('job-0')).toBe(false)
-    expect(store.jobIdToSessionWorkflowPath.get('job-4000')).toBe(
-      '/workflow-4000.json'
-    )
-  })
-
-  it('reports whether the active workflow is running', () => {
-    mockActiveWorkflow.value = { path: '/workflows/foo.json' }
-    store.activeJobId = 'job-1'
-    store.ensureSessionWorkflowPath('job-1', '/workflows/foo.json')
-
-    expect(store.isActiveWorkflowRunning).toBe(true)
-
-    store.ensureSessionWorkflowPath('job-1', '/workflows/bar.json')
-    expect(store.isActiveWorkflowRunning).toBe(false)
-
-    mockActiveWorkflow.value = {}
-    expect(store.isActiveWorkflowRunning).toBe(false)
-  })
-
-  it('counts running jobs from progress state', () => {
-    store.nodeProgressStatesByJob = {
-      'job-1': {
-        a: {
-          value: 1,
-          max: 10,
-          state: 'running',
-          node_id: 'a',
-          display_node_id: 'a',
-          prompt_id: 'job-1'
-        }
-      },
-      'job-2': {
-        b: {
-          value: 10,
-          max: 10,
-          state: 'finished',
-          node_id: 'b',
-          display_node_id: 'b',
-          prompt_id: 'job-2'
-        }
-      }
-    }
-
-    expect(store.runningJobIds).toEqual(['job-1'])
-    expect(store.runningWorkflowCount).toBe(1)
-  })
 })

src/stores/executionWorkflowStatus.test.ts

@@ -1,153 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers, openSet } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-  openSet: new Set<unknown>()
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: (workflow: unknown) => openSet.has(workflow),
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function storeJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  wf: ComfyWorkflow
-) {
-  store.storeJob({ nodes: [], id, promptOutput: promptOutput(), workflow: wf })
-}
-
-function fire(event: string, jobId: string) {
-  handlers[event]?.({ detail: { prompt_id: jobId } })
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  openSet.clear()
-})
-
-describe('executionStore workflow status', () => {
-  it('marks an open workflow running on execution_start and completed on success', () => {
-    const store = setup()
-    const wf = workflow('a.json')
-    openSet.add(wf)
-    storeJob(store, 'job-1', wf)
-
-    fire('execution_start', 'job-1')
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    fire('execution_success', 'job-1')
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-  })
-
-  it('buffers a status that arrives before the job is attached, then flushes on storeJob', () => {
-    const store = setup()
-    const wf = workflow('b.json')
-    openSet.add(wf)
-
-    fire('execution_start', 'job-2')
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-
-    storeJob(store, 'job-2', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-  })
-
-  it('does not apply status to a workflow that is not open', () => {
-    const store = setup()
-    const wf = workflow('c.json')
-    storeJob(store, 'job-3', wf)
-
-    fire('execution_start', 'job-3')
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-  })
-
-  it('clears a workflow status', () => {
-    const store = setup()
-    const wf = workflow('d.json')
-    openSet.add(wf)
-    storeJob(store, 'job-4', wf)
-    fire('execution_start', 'job-4')
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    store.clearWorkflowStatus(wf)
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-  })
-
-  it('does not let a late buffered running overwrite a terminal status', () => {
-    const store = setup()
-    const wf = workflow('e.json')
-    openSet.add(wf)
-
-    storeJob(store, 'job-5', wf)
-    fire('execution_success', 'job-5')
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-
-    fire('execution_start', 'job-6')
-    storeJob(store, 'job-6', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-  })
-
-  it('returns undefined for a null or unknown workflow', () => {
-    const store = setup()
-    expect(store.getWorkflowStatus(null)).toBeUndefined()
-    expect(store.getWorkflowStatus(workflow('unknown.json'))).toBeUndefined()
-  })
-})

src/stores/jobPreviewStore.test.ts

@@ -1,6 +1,6 @@
 import { createPinia, setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick, ref } from 'vue'
+import { ref } from 'vue'
 
 import { useJobPreviewStore } from '@/stores/jobPreviewStore'
 import { releaseSharedObjectUrl } from '@/utils/objectUrlUtil'
@@ -71,20 +71,6 @@ describe('jobPreviewStore', () => {
     expect(store.previewsByPromptId).toEqual({ p2: 'blob:b' })
   })
 
-  it('ignores clearPreview without a prompt id', () => {
-    const store = useJobPreviewStore()
-    store.setPreviewUrl('p1', 'blob:a', 'node-1')
-    vi.mocked(releaseSharedObjectUrl).mockClear()
-
-    store.clearPreview(undefined)
-
-    expect(store.nodePreviewsByPromptId['p1']).toEqual({
-      url: 'blob:a',
-      nodeId: 'node-1'
-    })
-    expect(releaseSharedObjectUrl).not.toHaveBeenCalled()
-  })
-
   it('clears all previews', () => {
     const store = useJobPreviewStore()
     store.setPreviewUrl('p1', 'blob:a', 'node-1')
@@ -105,24 +91,6 @@ describe('jobPreviewStore', () => {
     expect(releaseSharedObjectUrl).not.toHaveBeenCalled()
   })
 
-  it('ignores missing prompt ids', () => {
-    const store = useJobPreviewStore()
-
-    store.setPreviewUrl(undefined, 'blob:a', 'node-1')
-
-    expect(store.nodePreviewsByPromptId).toEqual({})
-  })
-
-  it('releases the old url when replacing a preview', () => {
-    const store = useJobPreviewStore()
-    store.setPreviewUrl('p1', 'blob:a', 'node-1')
-
-    store.setPreviewUrl('p1', 'blob:b', 'node-1')
-
-    expect(releaseSharedObjectUrl).toHaveBeenCalledWith('blob:a')
-    expect(store.nodePreviewsByPromptId['p1']?.url).toBe('blob:b')
-  })
-
   it('ignores setPreviewUrl when previews are disabled', () => {
     previewMethodRef.value = 'none'
     const store = useJobPreviewStore()
@@ -131,15 +99,4 @@ describe('jobPreviewStore', () => {
 
     expect(store.nodePreviewsByPromptId).toEqual({})
   })
-
-  it('clears previews when previews are disabled after storage', async () => {
-    const store = useJobPreviewStore()
-    store.setPreviewUrl('p1', 'blob:a', 'node-1')
-
-    previewMethodRef.value = 'none'
-    await nextTick()
-
-    expect(store.nodePreviewsByPromptId).toEqual({})
-    expect(releaseSharedObjectUrl).toHaveBeenCalledWith('blob:a')
-  })
 })

src/stores/previewExposureStore.test.ts

@@ -124,6 +124,61 @@ describe(usePreviewExposureStore, () => {
     })
   })
 
+  describe('findExposure / hasExposure', () => {
+    beforeEach(() => {
+      store.addExposure(rootGraphA, hostA, {
+        sourceNodeId: '42',
+        sourcePreviewName: 'preview'
+      })
+      store.addExposure(rootGraphA, hostA, {
+        sourceNodeId: '43',
+        sourcePreviewName: 'preview'
+      })
+    })
+
+    it('matches on both sourceNodeId and sourcePreviewName', () => {
+      const source = { sourceNodeId: '43', sourcePreviewName: 'preview' }
+
+      expect(store.hasExposure(rootGraphA, hostA, source)).toBe(true)
+      expect(store.findExposure(rootGraphA, hostA, source)).toEqual({
+        name: 'preview_1',
+        sourceNodeId: '43',
+        sourcePreviewName: 'preview'
+      })
+    })
+
+    it('does not match when only one field matches', () => {
+      expect(
+        store.hasExposure(rootGraphA, hostA, {
+          sourceNodeId: '42',
+          sourcePreviewName: 'other'
+        })
+      ).toBe(false)
+      expect(
+        store.hasExposure(rootGraphA, hostA, {
+          sourceNodeId: '99',
+          sourcePreviewName: 'preview'
+        })
+      ).toBe(false)
+    })
+
+    it('normalizes a numeric sourceNodeId before comparing', () => {
+      const source = { sourceNodeId: 42, sourcePreviewName: 'preview' }
+
+      expect(store.hasExposure(rootGraphA, hostA, source)).toBe(true)
+      expect(store.findExposure(rootGraphA, hostA, source)?.sourceNodeId).toBe(
+        '42'
+      )
+    })
+
+    it('returns undefined/false for an unknown host', () => {
+      const source = { sourceNodeId: '42', sourcePreviewName: 'preview' }
+
+      expect(store.findExposure(rootGraphA, hostB, source)).toBeUndefined()
+      expect(store.hasExposure(rootGraphA, hostB, source)).toBe(false)
+    })
+  })
+
   describe('getExposuresAsPromotionShape', () => {
     it('returns an empty array for unknown host', () => {
       expect(store.getExposuresAsPromotionShape(rootGraphA, hostA)).toEqual([])

src/stores/previewExposureStore.ts

@@ -23,6 +23,11 @@ type PreviewExposureInput = Omit<PreviewExposure, 'sourceNodeId'> & {
   sourceNodeId: SerializedNodeId
 }
 
+type ExposureSource = {
+  sourceNodeId: SerializedNodeId
+  sourcePreviewName: string
+}
+
 function normalizePreviewExposure(
   exposure: PreviewExposureInput
 ): PreviewExposure {
@@ -32,6 +37,16 @@ function normalizePreviewExposure(
   }
 }
 
+function matchesExposureSource(
+  entry: PreviewExposure,
+  source: ExposureSource
+): boolean {
+  return (
+    entry.sourceNodeId === toNodeId(source.sourceNodeId) &&
+    entry.sourcePreviewName === source.sourcePreviewName
+  )
+}
+
 export const usePreviewExposureStore = defineStore('previewExposure', () => {
   const exposures = ref(new Map<UUID, Map<string, PreviewExposure[]>>())
 
@@ -74,10 +89,28 @@ export const usePreviewExposureStore = defineStore('previewExposure', () => {
     hosts.set(hostNodeLocator, next.map(normalizePreviewExposure))
   }
 
+  function findExposure(
+    rootGraphId: UUID,
+    hostNodeLocator: string,
+    source: ExposureSource
+  ): PreviewExposure | undefined {
+    return _getExposuresRef(rootGraphId, hostNodeLocator)?.find((entry) =>
+      matchesExposureSource(entry, source)
+    )
+  }
+
+  function hasExposure(
+    rootGraphId: UUID,
+    hostNodeLocator: string,
+    source: ExposureSource
+  ): boolean {
+    return findExposure(rootGraphId, hostNodeLocator, source) !== undefined
+  }
+
   function addExposure(
     rootGraphId: UUID,
     hostNodeLocator: string,
-    source: { sourceNodeId: SerializedNodeId; sourcePreviewName: string }
+    source: ExposureSource
   ): PreviewExposure {
     const hosts = _getHostsForGraph(rootGraphId)
     const current = hosts.get(hostNodeLocator) ?? []
@@ -138,6 +171,8 @@ export const usePreviewExposureStore = defineStore('previewExposure', () => {
   return {
     getExposures,
     getExposuresAsPromotionShape,
+    findExposure,
+    hasExposure,
     setExposures,
     addExposure,
     removeExposure,

src/stores/queueResultItem.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { SerializedNodeId } from '@/types/nodeId'
-import { ResultItemImpl } from '@/stores/queueStore'
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    apiURL: (path: string) => `http://localhost:8188${path}`,
-    addEventListener: () => {}
-  }
-}))
-
-// Importing ResultItemImpl transitively loads @/scripts/app, whose module-level
-// ComfyApp singleton wires real listeners. Stub it; ResultItemImpl needs none of it.
-vi.mock('@/scripts/app', () => ({ app: {} }))
-
-// Keep preview-url assertions deterministic: don't append cloud params.
-vi.mock('@/platform/distribution/cloudPreviewUtil', () => ({
-  appendCloudResParam: () => {}
-}))
-
-interface ItemOverrides {
-  filename?: string
-  mediaType?: string
-  format?: string
-  frame_rate?: number
-}
-
-function item(over: ItemOverrides = {}) {
-  return new ResultItemImpl({
-    filename: over.filename ?? 'out.png',
-    subfolder: 'sub',
-    type: 'output',
-    nodeId: '1' as SerializedNodeId,
-    mediaType: over.mediaType ?? 'images',
-    format: over.format,
-    frame_rate: over.frame_rate
-  })
-}
-
-describe('ResultItemImpl', () => {
-  it('builds view url params and omits absent vhs fields', () => {
-    const params = item({ filename: 'a.png' }).urlParams
-    expect(params.get('filename')).toBe('a.png')
-    expect(params.get('type')).toBe('output')
-    expect(params.get('subfolder')).toBe('sub')
-    expect(params.has('format')).toBe(false)
-    expect(params.has('frame_rate')).toBe(false)
-  })
-
-  it('includes vhs format and frame_rate params when present', () => {
-    const params = item({ format: 'video/h264-mp4', frame_rate: 24 }).urlParams
-    expect(params.get('format')).toBe('video/h264-mp4')
-    expect(params.get('frame_rate')).toBe('24')
-  })
-
-  it('returns an empty url for a nameless item and a view url otherwise', () => {
-    expect(item({ filename: '' }).url).toBe('')
-    expect(item({ filename: 'a.png' }).url).toContain('/view?')
-  })
-
-  it('routes image preview urls through /view', () => {
-    expect(
-      item({ filename: 'a.png', mediaType: 'images' }).previewUrl
-    ).toContain('/view?')
-  })
-
-  it('falls back to url directly for non-image preview urls', () => {
-    const nonImage = item({ filename: 'a.mp3', mediaType: 'audio' })
-    expect(nonImage.previewUrl).toBe(nonImage.url)
-  })
-
-  it('exposes the vhs advanced preview endpoint', () => {
-    expect(item().vhsAdvancedPreviewUrl).toContain('/viewvideo?')
-  })
-
-  it('maps html video mime types by suffix and vhs format', () => {
-    expect(item({ filename: 'a.webm' }).htmlVideoType).toBe('video/webm')
-    expect(item({ filename: 'a.mp4' }).htmlVideoType).toBe('video/mp4')
-    expect(item({ filename: 'a.mov' }).htmlVideoType).toBe('video/quicktime')
-    expect(
-      item({ filename: 'a.bin', format: 'video/mp4', frame_rate: 24 })
-        .htmlVideoType
-    ).toBe('video/mp4')
-    expect(item({ filename: 'a.txt' }).htmlVideoType).toBeUndefined()
-  })
-
-  it('maps html audio mime types by suffix', () => {
-    expect(item({ filename: 'a.mp3' }).htmlAudioType).toBe('audio/mpeg')
-    expect(item({ filename: 'a.wav' }).htmlAudioType).toBe('audio/wav')
-    expect(item({ filename: 'a.ogg' }).htmlAudioType).toBe('audio/ogg')
-    expect(item({ filename: 'a.flac' }).htmlAudioType).toBe('audio/flac')
-    expect(item({ filename: 'a.png' }).htmlAudioType).toBeUndefined()
-  })
-
-  it('treats vhs format as such only with both format and frame_rate', () => {
-    expect(item({ format: 'video/mp4', frame_rate: 24 }).isVhsFormat).toBe(true)
-    expect(item({ format: 'video/mp4' }).isVhsFormat).toBe(false)
-    expect(item({ frame_rate: 24 }).isVhsFormat).toBe(false)
-    expect(item().isVhsFormat).toBe(false)
-  })
-
-  it('classifies video by suffix and by media type', () => {
-    expect(item({ filename: 'a.webm' }).isVideo).toBe(true)
-    expect(item({ filename: 'a.bin', mediaType: 'video' }).isVideo).toBe(true)
-    expect(item({ filename: 'a.png', mediaType: 'video' }).isVideo).toBe(false)
-  })
-
-  it('classifies image only when not contradicted by a media suffix', () => {
-    expect(item({ filename: 'a.png', mediaType: 'images' }).isImage).toBe(true)
-    expect(item({ filename: 'a.webm', mediaType: 'images' }).isImage).toBe(
-      false
-    )
-  })
-
-  it('classifies audio by suffix and by media type', () => {
-    expect(item({ filename: 'a.mp3' }).isAudio).toBe(true)
-    expect(item({ filename: 'a.bin', mediaType: 'audio' }).isAudio).toBe(true)
-    expect(item({ filename: 'a.png', mediaType: 'audio' }).isAudio).toBe(false)
-  })
-
-  it('reports text and preview support', () => {
-    expect(item({ mediaType: 'text' }).isText).toBe(true)
-    expect(item({ filename: 'a.png' }).supportsPreview).toBe(true)
-    expect(
-      item({ filename: 'a.bin', mediaType: 'binary' }).supportsPreview
-    ).toBe(false)
-  })
-
-  it('filters previewable outputs and finds an item by url', () => {
-    const png = item({ filename: 'a.png' })
-    const bin = item({ filename: 'a.bin', mediaType: 'binary' })
-    expect(ResultItemImpl.filterPreviewable([png, bin])).toEqual([png])
-
-    // A genuine match returns the matched index (1 here, distinguishing it
-    // from the index-0 fallback used for no-match and missing-url cases).
-    expect(ResultItemImpl.findByUrl([bin, png], png.url)).toBe(1)
-    expect(ResultItemImpl.findByUrl([bin, png], 'no-match')).toBe(0)
-    expect(ResultItemImpl.findByUrl([bin, png])).toBe(0)
-  })
-})

src/stores/queueTaskItem.test.ts

@@ -1,216 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { JobListItem } from '@/platform/remote/comfyui/jobs/jobTypes'
-import type { ResultItemType, TaskOutput } from '@/schemas/apiSchema'
-import type { SerializedNodeId } from '@/types/nodeId'
-import { ResultItemImpl, TaskItemImpl } from '@/stores/queueStore'
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    apiURL: (path: string) => `http://localhost:8188${path}`,
-    addEventListener: () => {}
-  }
-}))
-
-vi.mock('@/scripts/app', () => ({ app: {} }))
-
-vi.mock('@/platform/distribution/cloudPreviewUtil', () => ({
-  appendCloudResParam: () => {}
-}))
-
-const { parseTaskOutput } = vi.hoisted(() => ({ parseTaskOutput: vi.fn() }))
-vi.mock('@/stores/resultItemParsing', () => ({ parseTaskOutput }))
-
-type JobStatus =
-  | 'in_progress'
-  | 'pending'
-  | 'completed'
-  | 'failed'
-  | 'cancelled'
-
-function executionError(
-  overrides: Partial<NonNullable<JobListItem['execution_error']>> = {}
-): NonNullable<JobListItem['execution_error']> {
-  return {
-    node_id: '1',
-    node_type: 'KSampler',
-    exception_message: 'boom',
-    exception_type: 'Error',
-    traceback: [],
-    current_inputs: {},
-    current_outputs: {},
-    ...overrides
-  }
-}
-
-function job(over: Partial<JobListItem> = {}): JobListItem {
-  return {
-    id: 'job-1',
-    status: 'completed',
-    create_time: 1000,
-    priority: 0,
-    ...over
-  }
-}
-
-function result(filename: string, type: ResultItemType = 'output') {
-  return new ResultItemImpl({
-    filename,
-    subfolder: '',
-    type,
-    nodeId: '1' as SerializedNodeId,
-    mediaType: 'images'
-  })
-}
-
-describe('TaskItemImpl', () => {
-  it('maps job status to taskType and apiTaskType', () => {
-    expect(new TaskItemImpl(job({ status: 'in_progress' })).taskType).toBe(
-      'Running'
-    )
-    expect(new TaskItemImpl(job({ status: 'pending' })).taskType).toBe(
-      'Pending'
-    )
-    expect(new TaskItemImpl(job({ status: 'completed' })).taskType).toBe(
-      'History'
-    )
-
-    expect(new TaskItemImpl(job({ status: 'pending' })).apiTaskType).toBe(
-      'queue'
-    )
-    expect(new TaskItemImpl(job({ status: 'completed' })).apiTaskType).toBe(
-      'history'
-    )
-  })
-
-  it('exposes displayStatus for every backend status', () => {
-    const statuses: [JobStatus, string][] = [
-      ['in_progress', 'Running'],
-      ['pending', 'Pending'],
-      ['completed', 'Completed'],
-      ['failed', 'Failed'],
-      ['cancelled', 'Cancelled']
-    ]
-    for (const [status, display] of statuses) {
-      expect(new TaskItemImpl(job({ status })).displayStatus).toBe(display)
-    }
-  })
-
-  it('derives history/running flags and a status-qualified key', () => {
-    const running = new TaskItemImpl(job({ id: 'a', status: 'in_progress' }))
-    expect(running.isRunning).toBe(true)
-    expect(running.isHistory).toBe(false)
-    expect(running.key).toBe('aRunning')
-
-    expect(new TaskItemImpl(job({ status: 'completed' })).isHistory).toBe(true)
-  })
-
-  it('uses explicitly provided flat outputs', () => {
-    const outputs = [result('a.png')]
-    const task = new TaskItemImpl(job(), undefined, outputs)
-    expect(task.flatOutputs).toBe(outputs)
-  })
-
-  it('parses outputs lazily when flat outputs are not supplied', () => {
-    const parsed = [result('p.png')]
-    parseTaskOutput.mockReturnValueOnce(parsed)
-    const outputs: TaskOutput = { '1': { images: [] } }
-    const task = new TaskItemImpl(job(), outputs)
-    expect(parseTaskOutput).toHaveBeenCalled()
-    expect(task.flatOutputs).toBe(parsed)
-  })
-
-  it('synthesizes outputs from preview_output when none are provided', () => {
-    parseTaskOutput.mockReturnValueOnce([])
-    const preview = { nodeId: '5', mediaType: 'images', filename: 'prev.png' }
-    new TaskItemImpl(job({ preview_output: preview }))
-    expect(parseTaskOutput).toHaveBeenCalledWith({
-      '5': { images: [preview] }
-    })
-  })
-
-  it('prefers the last saved output over temp previews for previewOutput', () => {
-    const temp = result('temp.png', 'temp')
-    const saved = result('saved.png', 'output')
-    const task = new TaskItemImpl(job(), undefined, [temp, saved])
-    expect(task.previewOutput).toBe(saved)
-
-    const onlyTemp = new TaskItemImpl(job(), undefined, [temp])
-    expect(onlyTemp.previewOutput).toBe(temp)
-  })
-
-  it('reports interrupted only for an interrupt-typed failure', () => {
-    expect(
-      new TaskItemImpl(
-        job({
-          status: 'failed',
-          execution_error: executionError({
-            exception_type: 'InterruptProcessingException'
-          })
-        })
-      ).interrupted
-    ).toBe(true)
-    expect(
-      new TaskItemImpl(
-        job({
-          status: 'failed',
-          execution_error: executionError({ exception_type: 'Other' })
-        })
-      ).interrupted
-    ).toBe(false)
-    expect(
-      new TaskItemImpl(
-        job({
-          status: 'completed',
-          execution_error: executionError({
-            exception_type: 'InterruptProcessingException'
-          })
-        })
-      ).interrupted
-    ).toBe(false)
-  })
-
-  it('surfaces error message and passthrough job fields', () => {
-    const task = new TaskItemImpl(
-      job({
-        status: 'failed',
-        outputs_count: 3,
-        workflow_id: 'wf-9',
-        execution_error: executionError({ exception_message: 'boom' })
-      })
-    )
-    expect(task.errorMessage).toBe('boom')
-    expect(task.outputsCount).toBe(3)
-    expect(task.workflowId).toBe('wf-9')
-  })
-
-  it('computes execution time only when both timestamps exist', () => {
-    expect(
-      new TaskItemImpl(
-        job({ execution_start_time: 1000, execution_end_time: 3000 })
-      ).executionTimeInSeconds
-    ).toBe(2)
-    expect(
-      new TaskItemImpl(job({ execution_start_time: 1000 })).executionTime
-    ).toBeUndefined()
-  })
-
-  it('flatten returns itself when not completed', () => {
-    const running = new TaskItemImpl(job({ status: 'in_progress' }))
-    expect(running.flatten()).toEqual([running])
-  })
-
-  it('flatten expands a completed task into one task per output', () => {
-    const outputs = [result('a.png'), result('b.png')]
-    const task = new TaskItemImpl(
-      job({ id: 'j', status: 'completed' }),
-      undefined,
-      outputs
-    )
-
-    const flattened = task.flatten()
-
-    expect(flattened).toHaveLength(2)
-    expect(flattened.map((t) => t.jobId)).toEqual(['j-0', 'j-1'])
-  })
-})

src/stores/resultItemParsing.test.ts

@@ -1,4 +1,4 @@
-import { fromAny, fromPartial } from '@total-typescript/shoehorn'
+import { fromPartial } from '@total-typescript/shoehorn'
 import { describe, expect, it } from 'vitest'
 
 import type { NodeExecutionOutput } from '@/schemas/apiSchema'
@@ -154,22 +154,6 @@ describe(parseNodeOutput, () => {
     expect(result).toHaveLength(1)
     expect(result[0].filename).toBe('valid.png')
   })
-
-  it('excludes non-object and invalid-type items', () => {
-    const output = fromAny<NodeExecutionOutput, unknown>({
-      images: [
-        null,
-        'not-an-item',
-        { filename: 'bad.png', type: 'invalid' },
-        { filename: 'valid.png', type: 'output' }
-      ]
-    })
-
-    const result = parseNodeOutput('1', output)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].filename).toBe('valid.png')
-  })
 })
 
 describe(parseTaskOutput, () => {

src/storybook/mocks/useFeatureFlags.ts

@@ -25,13 +25,15 @@ export enum ServerFeatureFlag {
   COMFYHUB_UPLOAD_ENABLED = 'comfyhub_upload_enabled',
   COMFYHUB_PROFILE_GATE_ENABLED = 'comfyhub_profile_gate_enabled',
   SHOW_SIGNIN_BUTTON = 'show_signin_button',
-  UNIFIED_CLOUD_AUTH = 'unified_cloud_auth'
+  UNIFIED_CLOUD_AUTH = 'unified_cloud_auth',
+  CONSOLIDATED_BILLING_ENABLED = 'consolidated_billing_enabled'
 }
 
 export function useFeatureFlags() {
   return {
     flags: {
-      teamWorkspacesEnabled: true
+      teamWorkspacesEnabled: true,
+      consolidatedBillingEnabled: true
     }
   }
 }