@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/ui/components/__tests__/StageTimeline.test.tsx

@@ -11,20 +11,19 @@ afterEach(() => {
   document.body.innerHTML = "";
 });
 
-test("StageTimeline sorts by order and puts unordered stages last", () => {
+test("StageTimeline renders each stage name and purpose in order", () => {
   const view = render(
     <StageTimeline
       stages={[
-        { name: "B", order: 2 },
-        { name: "A", order: 1, isAsync: true },
-        { name: "C" },
+        { name: "ingestion", purpose: "Load raw input" },
+        { name: "inference", purpose: "Run the model" },
       ]}
     />,
   );
 
   const items = Array.from(view.container.querySelectorAll("li")).map((node) => node.textContent?.trim());
-  expect(items).toEqual(["Aasync", "B", "C"]);
-  expect(view.getByText("async")).toBeTruthy();
+  expect(items).toEqual(["ingestionLoad raw input", "inferenceRun the model"]);
+  expect(view.getByText("Load raw input")).toBeTruthy();
 });
 
 test("PageSubheader renders breadcrumbs", () => {

package/src/ui/components/__tests__/TaskAnalysisDisplay.test.tsx

@@ -0,0 +1,64 @@
+import "./test-dom";
+
+import { render } from "@testing-library/react";
+import { afterEach, expect, test } from "bun:test";
+
+import { TaskAnalysisDisplay } from "../TaskAnalysisDisplay";
+import type { TaskAnalysis } from "../types";
+
+afterEach(() => {
+  document.body.innerHTML = "";
+});
+
+function makeAnalysis(overrides: Partial<TaskAnalysis> = {}): TaskAnalysis {
+  return {
+    summary: "Summarizes the input document.",
+    stages: [{ name: "ingestion", purpose: "Load raw input" }],
+    artifacts: {
+      reads: [{ fileName: "input.json", role: "source data" }],
+      writes: [{ fileName: "output.json", role: "result data" }],
+    },
+    models: [{ provider: "deepseek", method: "chat", stage: "ingestion" }],
+    analyzedAt: "2026-06-22T00:00:00.000Z",
+    analysisStatus: "ok",
+    ...overrides,
+  };
+}
+
+test("ok renders summary, stage purpose, artifacts, models, and the AI-generated label", () => {
+  const view = render(
+    <TaskAnalysisDisplay analysis={makeAnalysis()} loading={false} error={null} pipelineSlug="demo" />,
+  );
+
+  expect(view.getByText("Summarizes the input document.")).toBeTruthy();
+  expect(view.getByText("Load raw input")).toBeTruthy();
+  expect(view.getByText("input.json")).toBeTruthy();
+  expect(view.getByText("source data")).toBeTruthy();
+  expect(view.getByText("output.json")).toBeTruthy();
+  expect(view.getByText("result data")).toBeTruthy();
+  expect(view.getByText("deepseek · chat · ingestion")).toBeTruthy();
+  expect(view.container.textContent).toContain("AI-generated, approximate");
+});
+
+test("unconfigured renders the configure message and CTA", () => {
+  const analysis = makeAnalysis({ analysisStatus: "unconfigured" });
+  const view = render(
+    <TaskAnalysisDisplay analysis={analysis} loading={false} error={null} pipelineSlug="demo" />,
+  );
+
+  expect(view.container.textContent).toContain("No analysis model is configured");
+  expect(view.getByRole("button", { name: "Configure model" })).toBeTruthy();
+});
+
+test("error renders an error note with the analysis error detail", () => {
+  const analysis = makeAnalysis({
+    analysisStatus: "error",
+    analysisError: "validation failed for field summary",
+  });
+  const view = render(
+    <TaskAnalysisDisplay analysis={analysis} loading={false} error={null} pipelineSlug="demo" />,
+  );
+
+  expect(view.getByText("Analysis failed")).toBeTruthy();
+  expect(view.getByText("validation failed for field summary")).toBeTruthy();
+});

package/src/ui/components/types.ts

@@ -15,6 +15,22 @@ export interface CostsSummary {
   totalCost: number;
   totalInputCost: number;
   totalOutputCost: number;
+  estimatedCost: number;
+  hasEstimated: boolean;
+  unavailableCost: number;
+}
+
+export type UsageSource = "reported" | "estimated" | "unavailable" | "zero";
+
+export interface TaskCostBreakdown {
+  inputTokens: number;
+  outputTokens: number;
+  inputCost: number;
+  outputCost: number;
+  totalCost: number;
+  source?: UsageSource;
+  failed?: boolean;
+  costEstimated?: boolean;
 }
 
 export interface TaskError {
@@ -73,6 +89,8 @@ export interface JobSummary {
   totalTokens?: number;
   displayCategory: DisplayCategory;
   gate?: GateInfo | null;
+  readable?: boolean;
+  error?: { code: string; message: string; path?: string };
 }
 
 export interface GateInfo {
@@ -80,6 +98,7 @@ export interface GateInfo {
   message: string;
   artifacts?: string[];
   requestedAt: string;
+  kind?: "approval" | "control_invalid";
 }
 
 export function normalizeTaskCollection(
@@ -98,10 +117,7 @@ export interface JobDetail {
   status: string;
   tasks: TaskCollection;
   pipeline: { tasks: string[] };
-  costs?: {
-    summary: CostsSummary;
-    taskBreakdown: Record<string, unknown>;
-  };
+  costs?: Record<string, TaskCostBreakdown>;
   totalCost?: number;
   totalTokens?: number;
   current: string | { taskName: string; stage?: string } | null;
@@ -119,6 +135,7 @@ export interface DagItem {
   startedAt: string | number;
   endedAt: string | number | null;
   restartCount?: number;
+  costEstimated?: boolean;
 }
 
 export interface PipelineTask {
@@ -133,16 +150,16 @@ export interface PipelineType {
   tasks: PipelineTask[];
 }
 
-export interface Artifact {
-  fileName: string;
-  stage: string;
-  required?: boolean;
-}
+export type AnalysisStatusKind = "ok" | "unconfigured" | "error";
 
-export interface Stage {
+export interface AnalysisStage {
   name: string;
-  order?: number;
-  isAsync?: boolean;
+  purpose: string;
+}
+
+export interface AnalysisArtifact {
+  fileName: string;
+  role: string;
 }
 
 export interface AnalysisModel {
@@ -152,13 +169,16 @@ export interface AnalysisModel {
 }
 
 export interface TaskAnalysis {
+  summary: string;
+  stages: AnalysisStage[];
   artifacts: {
-    reads: Artifact[];
-    writes: Artifact[];
+    reads: AnalysisArtifact[];
+    writes: AnalysisArtifact[];
   };
-  stages: Stage[];
   models: AnalysisModel[];
   analyzedAt: string;
+  analysisStatus: AnalysisStatusKind;
+  analysisError?: string;
 }
 
 export interface TaskProposal {