feat(channels): ship production thread and feed UX

Generated-By: PostHog Code
Task-Id: 87a79e23-20c4-440b-818b-28154924ffbc

Author: k11kirky

packages/core/src/canvas/threadTimeline.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildThreadTimeline,
+  deriveThreadAgentStatus,
+  shouldSuspendThreadSession,
+} from "./threadTimeline";
+
+describe("buildThreadTimeline", () => {
+  it("interleaves prompts, human replies, and agent turns chronologically", () => {
+    const timeline = buildThreadTimeline({
+      prompts: [{ id: "prompt", text: "Start", timestamp: 100 }],
+      humanMessages: [
+        {
+          id: "human",
+          content: "Reply",
+          createdAt: "1970-01-01T00:00:00.150Z",
+        },
+      ],
+      agentMessages: [{ id: "agent", text: "Done", timestamp: 200 }],
+    });
+
+    expect(timeline.map((row) => row.kind)).toEqual([
+      "prompt",
+      "human",
+      "agent",
+    ]);
+  });
+
+  it("keeps malformed timestamps at the end", () => {
+    const timeline = buildThreadTimeline({
+      prompts: [{ id: "prompt", text: "Start", timestamp: 100 }],
+      humanMessages: [{ id: "human", content: "Reply", createdAt: "invalid" }],
+      agentMessages: [{ id: "agent", text: "Done", timestamp: 200 }],
+    });
+
+    expect(timeline.map((row) => row.kind)).toEqual([
+      "prompt",
+      "agent",
+      "human",
+    ]);
+  });
+});
+
+describe("deriveThreadAgentStatus", () => {
+  it.each([
+    {
+      name: "returns no status before activity",
+      input: {},
+      expected: null,
+    },
+    {
+      name: "prioritizes failures",
+      input: { hasActivity: true, hasError: true, errorTitle: "Run failed" },
+      expected: { phase: "error", label: "Run failed" },
+    },
+    {
+      name: "prioritizes pending permissions over active work",
+      input: {
+        hasActivity: true,
+        pendingPermissionCount: 1,
+        isPromptPending: true,
+      },
+      expected: { phase: "needs_input", label: "Needs input" },
+    },
+    {
+      name: "reports active work",
+      input: { hasActivity: true, isPromptPending: true },
+      expected: { phase: "active", label: "Working…" },
+    },
+    {
+      name: "reports shipped work",
+      input: { hasActivity: true, hasPullRequest: true },
+      expected: { phase: "complete", label: "Shipped" },
+    },
+  ])("$name", ({ input, expected }) => {
+    expect(deriveThreadAgentStatus(input)).toEqual(expected);
+  });
+});
+
+describe("shouldSuspendThreadSession", () => {
+  it("suspends a local runless task so reading cannot start work", () => {
+    expect(
+      shouldSuspendThreadSession({
+        isCloud: false,
+        hasRun: false,
+        hasSession: false,
+      }),
+    ).toBe(true);
+  });
+
+  it.each([
+    { isCloud: true, hasRun: false, hasSession: false },
+    { isCloud: false, hasRun: true, hasSession: false },
+    { isCloud: false, hasRun: false, hasSession: true },
+  ])("keeps an existing or cloud session attached", (input) => {
+    expect(shouldSuspendThreadSession(input)).toBe(false);
+  });
+});

packages/core/src/canvas/threadTimeline.ts

@@ -0,0 +1,116 @@
+export interface ThreadAgentMessage {
+  id: string;
+  text: string;
+  timestamp?: number;
+}
+
+export interface ThreadHumanMessage<T = unknown> {
+  id: string;
+  content: string;
+  createdAt: string;
+  value?: T;
+}
+
+export type ThreadTimelineRow<T = unknown> =
+  | { kind: "prompt"; timestamp: number; message: ThreadAgentMessage }
+  | { kind: "agent"; timestamp: number; message: ThreadAgentMessage }
+  | { kind: "human"; timestamp: number; message: ThreadHumanMessage<T> };
+
+function validTimestamp(timestamp: number | undefined): number {
+  return timestamp !== undefined && Number.isFinite(timestamp)
+    ? timestamp
+    : Number.MAX_SAFE_INTEGER;
+}
+
+function parsedTimestamp(timestamp: string): number {
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : Number.MAX_SAFE_INTEGER;
+}
+
+export function buildThreadTimeline<T>({
+  prompts,
+  agentMessages,
+  humanMessages,
+}: {
+  prompts: ThreadAgentMessage[];
+  agentMessages: ThreadAgentMessage[];
+  humanMessages: ThreadHumanMessage<T>[];
+}): ThreadTimelineRow<T>[] {
+  return [
+    ...prompts.map(
+      (message): ThreadTimelineRow<T> => ({
+        kind: "prompt",
+        timestamp: validTimestamp(message.timestamp),
+        message,
+      }),
+    ),
+    ...humanMessages.map(
+      (message): ThreadTimelineRow<T> => ({
+        kind: "human",
+        timestamp: parsedTimestamp(message.createdAt),
+        message,
+      }),
+    ),
+    ...agentMessages.map(
+      (message): ThreadTimelineRow<T> => ({
+        kind: "agent",
+        timestamp: validTimestamp(message.timestamp),
+        message,
+      }),
+    ),
+  ].sort((left, right) => left.timestamp - right.timestamp);
+}
+
+export type ThreadAgentPhase = "active" | "needs_input" | "complete" | "error";
+
+export interface ThreadAgentStatus {
+  phase: ThreadAgentPhase;
+  label: string;
+}
+
+export function deriveThreadAgentStatus({
+  hasActivity = false,
+  hasError = false,
+  cloudStatus,
+  errorTitle,
+  pendingPermissionCount = 0,
+  isPromptPending = false,
+  isInitializing = false,
+  hasPullRequest = false,
+}: {
+  hasActivity?: boolean;
+  hasError?: boolean;
+  cloudStatus?: string | null;
+  errorTitle?: string | null;
+  pendingPermissionCount?: number;
+  isPromptPending?: boolean;
+  isInitializing?: boolean;
+  hasPullRequest?: boolean;
+}): ThreadAgentStatus | null {
+  if (!hasActivity) return null;
+  if (hasError || cloudStatus === "failed") {
+    return { phase: "error", label: errorTitle ?? "Failed" };
+  }
+  if (pendingPermissionCount > 0) {
+    return { phase: "needs_input", label: "Needs input" };
+  }
+  if (isPromptPending || isInitializing) {
+    return { phase: "active", label: "Working…" };
+  }
+  return {
+    phase: "complete",
+    label: hasPullRequest ? "Shipped" : "Ready to ship",
+  };
+}
+
+export function shouldSuspendThreadSession({
+  isCloud,
+  hasRun,
+  hasSession,
+}: {
+  isCloud: boolean;
+  hasRun: boolean;
+  hasSession: boolean;
+}): boolean {
+  return !isCloud && !hasRun && !hasSession;
+}