Merge branch 'main' into posthog-code/per-task-cost-estimate

Author: gantoine

packages/core/src/archive/archiveOrchestration.test.ts

@@ -29,6 +29,7 @@ class Harness {
     stopCloudRun: vi.fn().mockResolvedValue(true),
     disconnectFromTask: vi.fn().mockResolvedValue(undefined),
     archive: vi.fn().mockResolvedValue(undefined),
+    clearViewedState: vi.fn(),
     logError: vi.fn(),
     cache: {
       cancelPathFilter: vi.fn().mockResolvedValue(undefined),
@@ -59,10 +60,19 @@ describe("archiveTask", () => {
 
     expect(harness.deps.archive).toHaveBeenCalledWith(TASK_ID);
     expect(harness.deps.disconnectFromTask).toHaveBeenCalledWith(TASK_ID);
+    expect(harness.deps.clearViewedState).toHaveBeenCalledWith(TASK_ID);
     expect(harness.ids).toContain(TASK_ID);
     expect(harness.list.some((a) => a.taskId === TASK_ID)).toBe(true);
   });
 
+  it("does not clear read state when the archive request fails", async () => {
+    harness.deps.archive = vi.fn().mockRejectedValue(new Error("boom"));
+
+    await expect(archiveTask(TASK_ID, harness.deps)).rejects.toThrow("boom");
+
+    expect(harness.deps.clearViewedState).not.toHaveBeenCalled();
+  });
+
   it("with optimistic:false, defers cache writes until archive resolves", async () => {
     let idsWhenArchiveCalled: string[] = ["sentinel"];
     harness.deps.archive = vi.fn().mockImplementation(async () => {

packages/core/src/archive/archiveOrchestration.ts

@@ -39,6 +39,7 @@ export interface ArchiveOrchestrationDeps {
   stopCloudRun(taskId: string, runId?: string): Promise<boolean>;
   disconnectFromTask(taskId: string): Promise<void>;
   archive(taskId: string): Promise<void>;
+  clearViewedState(taskId: string): void;
   logError(message: string, error: unknown): void;
   cache: ArchiveCacheWriter;
 }
@@ -103,9 +104,8 @@ export async function archiveTask(
   try {
     await deps.disconnectFromTask(taskId);
     await deps.archive(taskId);
-    // Destroying terminals is irreversible, so it waits for the archive to
-    // commit; a failed archive keeps its live terminals.
     deps.clearTerminalStates(taskId);
+    deps.clearViewedState(taskId);
     // Non-optimistic flows keep the row visible during the request, then remove
     // it the moment the archive succeeds.
     if (!optimistic) {

packages/core/src/git/router-schemas.ts

@@ -42,6 +42,7 @@ export const changedFileSchema = z.object({
   linesRemoved: z.number().optional(),
   staged: z.boolean().optional(),
   patch: z.string().optional(),
+  sha: z.string().optional(),
 });
 
 export type ChangedFile = z.infer<typeof changedFileSchema>;

packages/shared/src/domain-types.ts

@@ -107,6 +107,12 @@ export interface ChannelFeedMessage {
 export interface TaskThreadMessage {
   id: string;
   task: string;
+  /** Who authored the row; agent rows are server-emitted announcements. Absent on older backends. */
+  author_kind?: "human" | "system" | "agent";
+  /** Stable event key for non-human rows (e.g. "canvas_created", "turn_complete"). */
+  event?: string;
+  /** Structured event payload; turn_complete carries `{ run_id }` so a client rendering a run's live agent turns can dedupe the durable row. */
+  payload?: Record<string, unknown>;
   content: string;
   created_at: string;
   author?: UserBasic | null;
@@ -364,6 +370,7 @@ export interface ChangedFile {
   linesRemoved?: number;
   staged?: boolean;
   patch?: string; // Unified diff patch from GitHub API
+  sha?: string;
 }
 
 // External apps detection types

packages/ui/src/features/archive/useArchiveTask.ts

@@ -16,6 +16,7 @@ import {
   type HostTrpcClient,
 } from "@posthog/host-router/client";
 import { useHostTRPC } from "@posthog/host-router/react";
+import { useReviewViewedStore } from "@posthog/ui/features/code-review/reviewViewedStore";
 import { useCommandCenterStore } from "@posthog/ui/features/command-center/commandCenterStore";
 import { useFocusStore } from "@posthog/ui/features/focus/focusStore";
 import { pinnedTasksApi } from "@posthog/ui/features/sidebar/taskMetaApi";
@@ -127,6 +128,8 @@ function makeOrchestrationDeps(
       ),
     archive: (taskId) =>
       hostClient.archive.archive.mutate({ taskId }).then(() => undefined),
+    clearViewedState: (taskId) =>
+      useReviewViewedStore.getState().clearTasks([taskId]),
     logError: (message, error) => log.error(message, error),
     cache: makeCacheWriter(queryClient, keys),
   };

packages/ui/src/features/canvas/components/MentionText.test.tsx

@@ -31,6 +31,17 @@ describe("MentionText", () => {
     expect(screen.queryByText("@agent")).not.toBeInTheDocument();
   });
 
+  it("keeps agent text inside a markdown link label", () => {
+    render(
+      <MentionText content="[My @agent report](https://posthog.com/report) has been created" />,
+    );
+
+    expect(
+      screen.getByRole("link", { name: "My @agent report" }),
+    ).toHaveAttribute("href", "https://posthog.com/report");
+    expect(screen.queryByText("@agent")).not.toBeInTheDocument();
+  });
+
   it("inherits the surrounding message text size", () => {
     render(<MentionText content="A thread reply" />);
 

packages/ui/src/features/canvas/components/MentionText.tsx

@@ -36,30 +36,40 @@ export function MentionText({
       entries.push({ segment, key: `${offset}` });
       offset += length;
     };
-    const pushText = (text: string) => {
+    const pushAgentMentions = (text: string) => {
       let cursor = 0;
       for (const match of text.matchAll(/(^|\s)(@agent)\b/gi)) {
         const mentionStart = (match.index ?? 0) + match[1].length;
-        for (const part of splitLinkSegments(
-          text.slice(cursor, mentionStart),
-        )) {
-          push(part, part.text.length);
+        if (mentionStart > cursor) {
+          push(
+            { type: "text", text: text.slice(cursor, mentionStart) },
+            mentionStart - cursor,
+          );
         }
         push({ type: "agent", text: match[2] }, match[2].length);
         cursor = mentionStart + match[2].length;
       }
-      for (const part of splitLinkSegments(text.slice(cursor))) {
-        push(part, part.text.length);
+      if (cursor < text.length) {
+        push({ type: "text", text: text.slice(cursor) }, text.length - cursor);
+      }
+    };
+    const pushMentions = (text: string) => {
+      for (const segment of splitMentionSegments(text)) {
+        if (segment.type === "mention") {
+          push(
+            { type: "mention", name: segment.name, email: segment.email },
+            segment.text.length,
+          );
+        } else {
+          pushAgentMentions(segment.text);
+        }
       }
     };
-    for (const segment of splitMentionSegments(content)) {
-      if (segment.type === "mention") {
-        push(
-          { type: "mention", name: segment.name, email: segment.email },
-          segment.text.length,
-        );
+    for (const segment of splitLinkSegments(content)) {
+      if (segment.type === "link") {
+        push(segment, segment.text.length);
       } else {
-        pushText(segment.text);
+        pushMentions(segment.text);
       }
     }
     return entries;

packages/ui/src/features/canvas/components/ThreadPanel.test.tsx

@@ -1,7 +1,11 @@
 import type { ConversationItem } from "@posthog/ui/features/sessions/components/buildConversationItems";
 import { render, screen } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
-import { AgentStatusLine, UserPromptRow } from "./ThreadPanel";
+import {
+  AgentStatusLine,
+  ThreadMessageRow,
+  UserPromptRow,
+} from "./ThreadPanel";
 import { agentTurns } from "./threadAgentTurns";
 
 describe("agentTurns", () => {
@@ -45,6 +49,84 @@ describe("AgentStatusLine", () => {
   });
 });
 
+describe("ThreadMessageRow", () => {
+  it("renders backend-authored agent announcements as Agent", () => {
+    render(
+      <ThreadMessageRow
+        message={{
+          id: "announcement",
+          task: "task",
+          author_kind: "agent",
+          event: "canvas_created",
+          payload: {},
+          content: "Canvas created",
+          created_at: "2026-07-17T00:00:00Z",
+          author: null,
+        }}
+        isTaskAuthor={false}
+        isOwnMessage={false}
+        canForward={false}
+        onSendToAgent={() => {}}
+        onDelete={() => {}}
+      />,
+    );
+
+    expect(screen.getByText("Agent")).toBeInTheDocument();
+    expect(screen.queryByText("Unknown")).not.toBeInTheDocument();
+  });
+
+  it("renders system announcements as System without human actions", () => {
+    render(
+      <ThreadMessageRow
+        message={{
+          id: "system-announcement",
+          task: "task",
+          author_kind: "system",
+          event: "status_changed",
+          payload: {},
+          content: "Status changed",
+          created_at: "2026-07-17T00:00:00Z",
+          author: null,
+        }}
+        isTaskAuthor
+        isOwnMessage={false}
+        canForward
+        onSendToAgent={() => {}}
+        onDelete={() => {}}
+      />,
+    );
+
+    expect(screen.getByText("System")).toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Message actions" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("keeps legacy authorless rows as human messages", () => {
+    render(
+      <ThreadMessageRow
+        message={{
+          id: "legacy-message",
+          task: "task",
+          content: "Author removed",
+          created_at: "2026-07-17T00:00:00Z",
+          author: null,
+        }}
+        isTaskAuthor
+        isOwnMessage={false}
+        canForward
+        onSendToAgent={() => {}}
+        onDelete={() => {}}
+      />,
+    );
+
+    expect(screen.getByText("Unknown")).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: "Message actions" }),
+    ).toBeInTheDocument();
+  });
+});
+
 describe("UserPromptRow", () => {
   it("prefixes direct task prompts with @agent", () => {
     render(

packages/ui/src/features/canvas/components/ThreadPanel.tsx

@@ -87,7 +87,7 @@ import { track } from "@posthog/ui/shell/analytics";
 import { useQuery } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
-function ThreadMessageRow({
+export function ThreadMessageRow({
   message,
   isTaskAuthor,
   isOwnMessage,
@@ -105,18 +105,36 @@ function ThreadMessageRow({
   onDelete: () => void;
 }) {
   const forwarded = !!message.forwarded_to_agent_at;
-  const showMenu = (isTaskAuthor && !forwarded) || isOwnMessage;
+  const authorKind = message.author_kind ?? "human";
+  const isAgent = authorKind === "agent";
+  const isSystem = authorKind === "system";
+  const showMenu =
+    authorKind === "human" && ((isTaskAuthor && !forwarded) || isOwnMessage);
 
   return (
     <ThreadItem>
       <ThreadItemGutter>
         <Avatar size="lg" className="sticky top-2">
-          <AvatarFallback>{getUserInitials(message.author)}</AvatarFallback>
+          <AvatarFallback>
+            {isAgent ? (
+              <RobotIcon size={14} />
+            ) : isSystem ? (
+              "S"
+            ) : (
+              getUserInitials(message.author)
+            )}
+          </AvatarFallback>
         </Avatar>
       </ThreadItemGutter>
       <ThreadItemContent>
         <ThreadItemHeader>
-          <ThreadItemAuthor>{userDisplayName(message.author)}</ThreadItemAuthor>
+          <ThreadItemAuthor>
+            {isAgent
+              ? "Agent"
+              : isSystem
+                ? "System"
+                : userDisplayName(message.author)}
+          </ThreadItemAuthor>
           <ThreadTimestamp dateTime={message.created_at} />
         </ThreadItemHeader>
         <ThreadItemBody>

packages/ui/src/features/canvas/utils/linkify.test.ts

@@ -54,6 +54,33 @@ describe("splitLinkSegments", () => {
     ],
     ["not a url scheme", "ftp://example.com", [text("ftp://example.com")]],
     ["empty string", "", []],
+    [
+      "markdown link uses its label",
+      "[Signups](https://us.posthog.com/code/canvas/c/d) has been created",
+      [
+        {
+          type: "link",
+          text: "Signups",
+          href: "https://us.posthog.com/code/canvas/c/d",
+        },
+        text(" has been created"),
+      ],
+    ],
+    [
+      "markdown link alongside a bare url",
+      "see [docs](https://a.com) or https://b.com",
+      [
+        text("see "),
+        { type: "link", text: "docs", href: "https://a.com" },
+        text(" or "),
+        link("https://b.com"),
+      ],
+    ],
+    [
+      "markdown label without a url stays prose",
+      "[not a link](just text)",
+      [text("[not a link](just text)")],
+    ],
   ])("%s", (_label, input, expected) => {
     expect(splitLinkSegments(input)).toEqual(expected);
   });