Flash workflow status from the product host

The runner now emits workflow. The product host subscribes and flashes the active step or complete via existing notices.

Author: TheGreatAxios

src/tui/product-host.ts

@@ -34,6 +34,8 @@ import {
   mcpServerState,
   RUNTIME_FLASH_MS,
   type RuntimeNotice,
+  workflowNotice,
+  workflowPayloadInfo,
 } from "./runtime-notices.js";
 import type { PaletteCommand } from "./command-catalog.js";
 import {
@@ -388,6 +390,7 @@ export async function mountProductHost(config: ProductHostConfig): Promise<Produ
     config.eventEmitter.off("mcp.status", onMcpStatus);
     config.eventEmitter.off("permission.grant", onPermissionGrant);
     config.eventEmitter.off("compaction", onCompaction);
+    config.eventEmitter.off("workflow", onWorkflow);
     bridge.dispose();
     // Cancels any flash still counting down: its expiry repaints, and after
     // teardown that repaint reaches a destroyed text buffer.
@@ -460,6 +463,16 @@ export async function mountProductHost(config: ProductHostConfig): Promise<Produ
     if (info !== null) show(compactionNotice(info));
   }
 
+  let workflowWasActive = false;
+
+  function onWorkflow(payload: unknown): void {
+    if (disposed) return;
+    const info = workflowPayloadInfo(payload);
+    if (info === null) return;
+    show(workflowNotice(info, { wasActive: workflowWasActive }));
+    workflowWasActive = info.current.active;
+  }
+
   // The renderer already owns the alternate screen and raw mode by this point,
   // but `dispose` has not been handed to any caller yet — a throw here would
   // leave the terminal wedged with nobody able to restore it.
@@ -627,6 +640,7 @@ export async function mountProductHost(config: ProductHostConfig): Promise<Produ
   config.eventEmitter.on("mcp.status", onMcpStatus);
   config.eventEmitter.on("permission.grant", onPermissionGrant);
   config.eventEmitter.on("compaction", onCompaction);
+  config.eventEmitter.on("workflow", onWorkflow);
 
   return {
     shell,

src/tui/runtime-channels.test.ts

@@ -271,6 +271,74 @@ describe("agents chrome (live strip above the prompt)", () => {
   });
 });
 
+describe("workflow channel", () => {
+  const liveIdle = {
+    current: {
+      active: false,
+      name: undefined as string | undefined,
+      stepIndex: 0,
+      total: 0,
+      label: "",
+      steps: [] as unknown[],
+      capabilities: [] as unknown[],
+    },
+    history: [{ name: "ship" }],
+  };
+
+  test("an active live emit paints the step and holds no transcript row", async () => {
+    const { host, emitter, frame, cleanup } = await mountHeadless();
+    try {
+      emitter.emit("workflow", {
+        current: { active: true, name: "ship", stepIndex: 0, total: 2, label: "build" },
+        history: [],
+      });
+      expect(await frame()).toContain("workflow ship · step 1/2: build");
+      expect(host.shell.streamLog).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("active then idle paints complete once and streamLog stays empty", async () => {
+    const { host, emitter, frame, cleanup } = await mountHeadless();
+    try {
+      emitter.emit("workflow", {
+        current: { active: true, name: "ship", stepIndex: 0, total: 2, label: "build" },
+        history: [],
+      });
+      expect(await frame()).toContain("workflow ship · step 1/2: build");
+      emitter.emit("workflow", liveIdle);
+      expect(await frame()).toContain("workflow ship complete");
+      expect(host.shell.streamLog).toEqual([]);
+      emitter.emit("workflow", liveIdle);
+      expect(host.shell.streamLog).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("first-emit idle with history does not complete-flash", async () => {
+    const { emitter, frame, cleanup } = await mountHeadless();
+    try {
+      emitter.emit("workflow", liveIdle);
+      expect(await frame()).not.toContain("workflow ship complete");
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("a bad payload paints nothing", async () => {
+    const { host, emitter, frame, cleanup } = await mountHeadless();
+    try {
+      emitter.emit("workflow", { current: { active: true } });
+      expect(await frame()).not.toContain("workflow ship");
+      expect(host.shell.streamLog).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+});
+
 /**
  * Static guard for the whole bug class: an emitted channel with no `.on`
  * anywhere is a feature nobody can see, and it fails silently. Static because
@@ -300,7 +368,7 @@ describe("every emitted runtime channel has a subscriber", () => {
   emitted.delete("subagent.progress");
 
   test("the runner still emits the channels this suite knows about", () => {
-    for (const channel of ["hook", "mcp.status", "permission.grant", "compaction"]) {
+    for (const channel of ["hook", "mcp.status", "permission.grant", "compaction", "workflow"]) {
       expect([...emitted]).toContain(channel);
     }
   });

src/tui/runtime-notices.test.ts

@@ -13,6 +13,8 @@ import {
   mcpNotice,
   mcpServerState,
   subAgentProgress,
+  workflowNotice,
+  workflowPayloadInfo,
 } from "./runtime-notices.js";
 
 const hook = {
@@ -166,4 +168,106 @@ describe("payload validation", () => {
     expect(compactionFoldInfo(null)).toBeNull();
     expect(compactionFoldInfo("nope")).toBeNull();
   });
+
+  test("workflow payloads require current + history and reject junk", () => {
+    expect(
+      workflowPayloadInfo({
+        current: { active: true, name: "ship", stepIndex: 0, total: 2, label: "build" },
+        history: [],
+      }),
+    ).toEqual({
+      current: { active: true, name: "ship", stepIndex: 0, total: 2, label: "build" },
+      history: [],
+    });
+    expect(workflowPayloadInfo({ current: { active: true } })).toBeNull();
+    expect(workflowPayloadInfo(null)).toBeNull();
+    expect(workflowPayloadInfo("nope")).toBeNull();
+  });
+
+  test("live inactive payload with name: undefined and extra status keys parses", () => {
+    const parsed = workflowPayloadInfo({
+      current: {
+        active: false,
+        name: undefined,
+        stepIndex: 0,
+        total: 0,
+        label: "",
+        steps: [{ id: "a" }],
+        capabilities: ["x"],
+      },
+      history: [{ name: "ship", extra: true }],
+    });
+    expect(parsed).not.toBeNull();
+    expect(parsed?.current.active).toBe(false);
+    expect(parsed?.current.name).toBeUndefined();
+    expect(parsed?.history.at(-1)?.name).toBe("ship");
+  });
+});
+
+describe("workflowNotice", () => {
+  test("active named step flashes index+1 and label", () => {
+    expect(
+      workflowNotice({
+        current: { active: true, name: "ship", stepIndex: 0, total: 2, label: "build" },
+        history: [],
+      }),
+    ).toEqual({
+      kind: "flash",
+      text: "workflow ship · step 1/2: build",
+    });
+  });
+
+  test("inactive with last history name flashes complete only when wasActive", () => {
+    const payload = {
+      current: {
+        active: false,
+        name: undefined as string | undefined,
+        stepIndex: 1,
+        total: 2,
+        label: "done",
+      },
+      history: [{ name: "ship" }],
+    };
+    expect(workflowNotice(payload, { wasActive: true })).toEqual({
+      kind: "flash",
+      text: "workflow ship complete",
+    });
+    expect(workflowNotice(payload, { wasActive: false })).toBeNull();
+    expect(workflowNotice(payload)).toBeNull();
+  });
+
+  test("idle snapshots say nothing", () => {
+    expect(
+      workflowNotice({
+        current: { active: false, stepIndex: 0, total: 0, label: "" },
+        history: [],
+      }),
+    ).toBeNull();
+    expect(
+      workflowNotice({
+        current: { active: true, stepIndex: 0, total: 1, label: "x" },
+        history: [],
+      }),
+    ).toBeNull();
+  });
+
+  test("active live payload with extra keys still flashes the step", () => {
+    const parsed = workflowPayloadInfo({
+      current: {
+        active: true,
+        name: "ship",
+        stepIndex: 0,
+        total: 2,
+        label: "build",
+        steps: [],
+        capabilities: [],
+      },
+      history: [],
+    });
+    expect(parsed).not.toBeNull();
+    expect(workflowNotice(parsed!)).toEqual({
+      kind: "flash",
+      text: "workflow ship · step 1/2: build",
+    });
+  });
 });

src/tui/runtime-notices.ts

@@ -208,3 +208,57 @@ export function subAgentProgress(raw: unknown): SubAgentProgress | null {
   if (parsed instanceof type.errors) return null;
   return parsed;
 }
+
+export interface WorkflowNoticePayload {
+  readonly current: {
+    readonly active: boolean;
+    readonly name?: string | undefined;
+    readonly stepIndex: number;
+    readonly total: number;
+    readonly label: string;
+  };
+  readonly history: readonly { readonly name?: string | undefined }[];
+}
+
+const workflowHistoryEntry = type({ "name?": "string | undefined" });
+
+const workflowPayload = type({
+  current: {
+    active: "boolean",
+    "name?": "string | undefined",
+    stepIndex: "number",
+    total: "number",
+    label: "string",
+  },
+  history: workflowHistoryEntry.array(),
+});
+
+export function workflowPayloadInfo(raw: unknown): WorkflowNoticePayload | null {
+  const parsed = workflowPayload(raw);
+  if (parsed instanceof type.errors) return null;
+  return parsed;
+}
+
+/**
+ * Live workflow projection. Active named steps flash the current step;
+ * complete flashes only on the active→idle transition when last history has a name.
+ */
+export function workflowNotice(
+  payload: WorkflowNoticePayload,
+  opts?: { wasActive?: boolean },
+): RuntimeNotice | null {
+  const { current, history } = payload;
+  if (current.active && current.name !== undefined && current.name.length > 0) {
+    return {
+      kind: "flash",
+      text: `workflow ${current.name} · step ${current.stepIndex + 1}/${current.total}: ${current.label}`,
+    };
+  }
+  if (!current.active && opts?.wasActive === true) {
+    const last = history.at(-1);
+    if (last?.name !== undefined && last.name.length > 0) {
+      return { kind: "flash", text: `workflow ${last.name} complete` };
+    }
+  }
+  return null;
+}