@cueloop/client 0.1.0-alpha.101 → 0.1.0-alpha.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.101",
+  "version": "0.1.0-alpha.102",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -27,10 +27,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.101",
-    "@cueloop/extension-api": "0.1.0-alpha.101",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.101",
-    "@cueloop/schema": "0.1.0-alpha.101",
+    "@cueloop/daemon": "0.1.0-alpha.102",
+    "@cueloop/extension-api": "0.1.0-alpha.102",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.102",
+    "@cueloop/schema": "0.1.0-alpha.102",
     "@opentui/core": "^0.5.14",
     "@opentui/keymap": "0.5.14",
     "@opentui/react": "^0.5.14",

package/src/annotations/components/AnnotationCards.tsx

@@ -317,12 +317,14 @@ export function CommentRow({
   tokens,
   authorLabel,
   action,
+  onFocus,
 }: {
   annotation: Annotation;
   tokens: Theme;
   /** The author's resolved display name, shown as a tooltip when the dot is hovered. */
   authorLabel?: string;
   action?: { label: string; run: () => void };
+  onFocus?: () => void;
 }): React.ReactNode {
   // own comments (no author) wear the filled dot, collaborators the outline
   const own = annotation.author === undefined;
@@ -337,7 +339,14 @@ export function CommentRow({
     : {};
 
   return (
-    <box style={{ flexDirection: "column" }}>
+    <box
+      style={{ flexDirection: "column" }}
+      onMouseDown={(event) => {
+        if (!onFocus) return;
+        event.stopPropagation();
+        onFocus();
+      }}
+    >
       {annotation.body.split("\n").map((line, lineIndex) => (
         <box key={lineIndex} style={{ flexDirection: "row" }}>
           <box style={{ flexShrink: 0 }} {...(lineIndex === 0 ? dotHover : {})}>

package/src/annotations/use-annotation-surface.tsx

@@ -47,7 +47,7 @@ import {
   slashItemsFrom,
 } from "../keyboard/slash-palette";
 import { SlashSkillsContext } from "../keyboard/skills";
-import { discussionsFrom, type Discussion } from "./discussions";
+import { discussionsFrom, spanKey, type Discussion } from "./discussions";
 import {
   CommentRow,
   Composer,
@@ -107,13 +107,13 @@ export interface AnnotationSurfaceOptions {
   ) => boolean;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
   isAnnotationReadOnly?: (id: string) => boolean;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   requestedBlock?: { blockIndex: number };
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   isPromptBlock?: (blockIndex: number) => boolean;
   promptFocusRequest?: PromptFocusRequest;
   promptRestoreRequest?: PromptRestoreRequest;
@@ -277,17 +277,25 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   // app owns it (onFocusAnnotation), the focused discussion is the one holding
   // the focused card and focusing here names the root comment; standalone, it
   // is local state
-  const [localFocus, setLocalFocus] = useState<string | null>(null);
-  const focusedDiscussion =
-    onFocusAnnotation === undefined
-      ? localFocus
-      : (discussions.find((discussion) =>
-          discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
-        )?.key ?? null);
+  const [localFocus, setLocalFocus] = useState<{ key: string; annotationId?: string } | null>(null);
+  const getFocusedDiscussion = (): string | null => {
+    if (onFocusAnnotation === undefined) return localFocus?.key ?? null;
+
+    return (
+      discussions.find((discussion) =>
+        discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
+      )?.key ?? null
+    );
+  };
+  const focusedDiscussion = getFocusedDiscussion();
   const setFocusedDiscussion = (key: string | null): void => {
-    if (onFocusAnnotation === undefined) return setLocalFocus(key);
+    if (onFocusAnnotation === undefined) return setLocalFocus(key === null ? null : { key });
     onFocusAnnotation(discussions.find((discussion) => discussion.key === key)?.rootId);
   };
+  const focusSavedComment = (annotationId: string, key: string): void => {
+    if (onFocusAnnotation) onFocusAnnotation(annotationId);
+    else setLocalFocus({ key, annotationId });
+  };
   const [folded, setFolded] = useState<Set<string>>(new Set());
   const [composeText, setComposeText] = useState("");
   const [composerFocusRequest, setComposerFocusRequest] = useState(0);
@@ -473,7 +481,8 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     if (!target || body.trim().length === 0) return;
     if (target.editAnnotationId !== null) {
       onUpdateAnnotation(target.editAnnotationId, body);
-      if (invoke) onInvoke?.();
+      if (target.discussionKey) focusSavedComment(target.editAnnotationId, target.discussionKey);
+      if (invoke) onInvoke?.(target.editAnnotationId);
 
       return;
     }
@@ -481,8 +490,10 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       const discussion = discussions.find((candidate) => candidate.key === target.discussionKey);
 
       if (discussion) {
-        onReply(discussion.rootId, body);
-        if (invoke) onInvoke?.();
+        const commentId = onReply(discussion.rootId, body);
+
+        if (commentId) focusSavedComment(commentId, discussion.key);
+        if (invoke && commentId) onInvoke?.(commentId);
 
         return;
       }
@@ -490,10 +501,22 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const span = target.span ?? caretSpan();
 
     if (span) {
-      onAnnotate(span, body);
-      if (invoke) onInvoke?.();
+      const commentId = onAnnotate(span, body);
+
+      completeSavedComment(span, commentId, prompt, invoke);
     }
   };
+  const completeSavedComment = (
+    span: TextSpan,
+    commentId: string | void,
+    prompt: boolean,
+    invoke: boolean,
+  ): void => {
+    if (!prompt && commentId) {
+      focusSavedComment(commentId, spanKey(span));
+    }
+    if (invoke && (prompt || commentId)) onInvoke?.(commentId || undefined);
+  };
   /** A new discussion on the typing anchor; the card renders under the span's last block. */
   const openNewCompose = (seed: string): void => {
     const span = caretSpan();
@@ -854,6 +877,16 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     openNewCompose(sequence);
   };
 
+  const invokeFocusedComment = (): void => {
+    const discussion = discussions.find((candidate) => candidate.key === focusedDiscussion);
+    const focusedCommentId = focusedAnnotationId ?? localFocus?.annotationId;
+    const commentId =
+      discussion?.annotations.find((annotation) => annotation.id === focusedCommentId)?.id ??
+      discussion?.annotations.at(-1)?.id;
+
+    onInvoke?.(commentId);
+  };
+
   useSharedKeyboard((key) => {
     if (suspended) return;
     if (key.ctrl && key.name === "q") return onExit();
@@ -863,7 +896,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     if (isAgentInvokeKey(key, onInvoke)) {
       key.preventDefault();
 
-      return onInvoke?.();
+      return invokeFocusedComment();
     }
     if (key.name === "escape") {
       // from type mode esc only enters nav, so a held mark survives for `c`
@@ -951,6 +984,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
             tokens={tokens}
             authorLabel={resolveAuthorLabel?.(annotation)}
             action={annotationAction?.(annotation.id)}
+            onFocus={() => {
+              blurSaveCompose();
+              focusSavedComment(annotation.id, discussion.key);
+              setCursor(discussion.blockIndex);
+            }}
           />
         ),
       };
@@ -1231,7 +1269,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
 function isAgentInvokeKey(
   key: { name: string; ctrl?: boolean; meta?: boolean; super?: boolean },
-  onInvoke?: () => void,
+  onInvoke?: (commentId?: string) => void,
 ): boolean {
   return Boolean(
     onInvoke &&

package/src/app/App.tsx

@@ -842,7 +842,7 @@ export function App({
   const agentActions = useRef<(id: string) => { label: string; run: () => void } | undefined>(
     () => undefined,
   );
-  const agentInvoke = useRef<(() => void) | undefined>(undefined);
+  const agentInvoke = useRef<((commentId?: string) => void) | undefined>(undefined);
   const [agentState, setAgentState] = useState<import("@cueloop/schema").ThreadAgentState>();
   const [prototypeComposing, setPrototypeComposing] = useState(false);
   const [welcomeComposing, setWelcomeComposing] = useState(false);
@@ -1484,7 +1484,7 @@ export function App({
                         // a diff thread's Changes view is the artifact itself; any other thread's is the
                         // live working-tree diff, so its notes carry a file target and anchor there
                         onAnnotate: (span, body) =>
-                          void controller.annotate(
+                          controller.annotate(
                             "comment",
                             span.start.blockIndex,
                             span.start.char,
@@ -1496,11 +1496,11 @@ export function App({
                               : { kind: "file", path: "", rev: "worktree" },
                           ),
                         onReply: (rootAnnotationId, body) =>
-                          void controller.reply(rootAnnotationId, body),
+                          controller.reply(rootAnnotationId, body),
                         onUpdateAnnotation: (id, body) => controller.updateAnnotation(id, body),
                         onInvoke: agentActive
-                          ? () => {
-                              agentInvoke.current?.();
+                          ? (commentId) => {
+                              agentInvoke.current?.(commentId);
                               setFocusedPane("thread");
                             }
                           : undefined,

package/src/diff/components/AnnotatableFileView.tsx

@@ -31,9 +31,9 @@ export interface AnnotatableFileViewProps {
   onCursorChange?: (rowIndex: number) => void;
   onObserverBlocked?: (reason: "observer" | "resolved") => void;
   onAddComment: (anchor: Anchor, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   isAnnotationReadOnly?: (id: string) => boolean;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;

package/src/diff/components/DiffContentView.tsx

@@ -86,10 +86,10 @@ export interface DiffContentViewProps {
   onCursorChange?: (rowIndex: number) => void;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   isAnnotationReadOnly?: (id: string) => boolean;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;

package/src/markdown/components/ThreadView.tsx

@@ -159,7 +159,7 @@ export interface ThreadViewProps {
   isAnnotationReadOnly?: (id: string) => boolean;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   requestedBlock?: { blockIndex: number };
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   isPromptBlock?: (blockIndex: number) => boolean;
   promptFocusRequest?: PromptFocusRequest;
   promptRestoreRequest?: PromptRestoreRequest;
@@ -177,8 +177,8 @@ export interface ThreadViewProps {
   onCursorChange?: (blockIndex: number) => void;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   onNavCommand?: (key: KeyEvent, selection: TextSpan | null) => boolean;

package/src/thread/agent-transcript.ts

@@ -195,6 +195,8 @@ export function projectThreadConversation(
     display.push(...blocks);
     sources.push(...blocks.map(() => ({ kind: "mirror" as const, commentId })));
     annotations.push(annotation);
+    const mirrorAnnotations = [annotation];
+
     if (commentId) {
       const replies = [...thread.annotations, ...state.comments].filter(
         (entry) => entry.replyTo === commentId,
@@ -210,23 +212,22 @@ export function projectThreadConversation(
         };
 
         annotations.push(replica);
+        mirrorAnnotations.push(replica);
         mirrors.set(replica.id, { commentId: reply.id });
       }
     }
     const localMarks = quote.trim()
-      ? marksByDisplay([annotation], blocks)
+      ? marksByDisplay(mirrorAnnotations, blocks)
       : new Map<number, Mark[]>([
           [
             0,
-            [
-              {
-                start: 0,
-                end: 0,
-                role: "mark-comment",
-                annotationId: annotation.id,
-                span: { start: { blockIndex: 0, char: 0 }, end: { blockIndex: 0, char: 0 } },
-              },
-            ],
+            mirrorAnnotations.map((entry) => ({
+              start: 0,
+              end: 0,
+              role: "mark-comment",
+              annotationId: entry.id,
+              span: { start: { blockIndex: 0, char: 0 }, end: { blockIndex: 0, char: 0 } },
+            })),
           ],
         ]);
 

package/src/thread/components/AgentThreadPane.test.tsx

@@ -374,6 +374,227 @@ test("typing on an accepted plain prompt cannot edit it or create an unmarked co
   }
 });
 
+for (const editingReply of [false, true]) {
+  test(`Option+Enter preserves the exact ${editingReply ? "edited" : "new"} reply for Ctrl+Enter`, async () => {
+    const submitted: string[] = [];
+    const root = {
+      id: "root",
+      kind: "comment" as const,
+      body: "Submitted question",
+      createdAt: "2026-10-04",
+      anchor: { quote: "Original", prefix: "", suffix: " artifact" },
+    };
+    const display = buildDisplay(thread.artifact.content);
+
+    function ControlledDiscussion(): React.ReactNode {
+      const [value, setValue] = React.useState<Thread>({
+        ...thread,
+        annotations: editingReply
+          ? [root, { ...root, id: "reply", replyTo: "root", body: "Editable followup" }]
+          : [root],
+      });
+      const [focused, setFocused] = React.useState<string>();
+
+      return (
+        <ThreadView
+          session={value}
+          display={display}
+          marks={marksByDisplay(value.annotations, display)}
+          quickActions={[]}
+          observer={false}
+          focusedAnnotationId={focused}
+          onFocusAnnotation={setFocused}
+          isAnnotationReadOnly={(id) => id === "root"}
+          onAnnotate={noop}
+          onReply={(id, body) => {
+            setValue((current) => ({
+              ...current,
+              annotations: [...current.annotations, { ...root, id: "reply", replyTo: id, body }],
+            }));
+
+            return "reply";
+          }}
+          onUpdateAnnotation={(id, body) =>
+            setValue((current) => ({
+              ...current,
+              annotations: current.annotations.map((note) =>
+                note.id === id ? { ...note, body } : note,
+              ),
+            }))
+          }
+          onInvoke={(id) => {
+            if (id) submitted.push(id);
+          }}
+          onExit={noop}
+        />
+      );
+    }
+    const setup = await testRender(<ControlledDiscussion />, {
+      width: 100,
+      height: 24,
+      kittyKeyboard: true,
+    });
+
+    try {
+      await waitForText(setup, editingReply ? "Editable followup" : "Submitted question");
+      const comment = locateText(setup, editingReply ? "Editable followup" : "Submitted question");
+
+      await setup.mockMouse.click(comment.column, comment.row);
+      await typeText(setup, " Why?");
+      await pressKey(setup, "RETURN", { meta: true });
+      expect(submitted).toEqual([]);
+      const saved = locateText(setup, editingReply ? "Editable followup Why?" : "Why?");
+
+      await setup.mockMouse.click(saved.column, saved.row);
+      await pressKey(setup, "RETURN", { ctrl: true });
+      expect(submitted).toEqual(["reply"]);
+    } finally {
+      setup.renderer.destroy();
+    }
+  });
+}
+
+test("Option-saved Changes mirror replies send their stored ID with Ctrl+Enter", async () => {
+  const root = {
+    id: "changes-note",
+    kind: "comment" as const,
+    body: "Question on Changes",
+    createdAt: thread.createdAt,
+    anchor: { quote: "Changed code", prefix: "", suffix: "" },
+  };
+  const { client, prompts } = createTestAgentClient({
+    ...empty,
+    submissions: [
+      {
+        id: "accepted",
+        commentId: root.id,
+        prompt: root.body,
+        quote: root.anchor.quote,
+        status: "completed",
+      },
+    ],
+  });
+
+  function ChangesDiscussion(): React.ReactNode {
+    const [value, setValue] = React.useState<Thread>({ ...thread, annotations: [root] });
+    const [focused, setFocused] = React.useState<string>();
+    const display = buildDisplay(value.artifact.content);
+    const saveReply = (id: string, body: string): string => {
+      setValue((current) => ({
+        ...current,
+        annotations: [...current.annotations, { ...root, id: "followup", replyTo: id, body }],
+      }));
+
+      return "followup";
+    };
+
+    return (
+      <AgentThreadPane
+        thread={value}
+        client={client}
+        focused
+        theme={DARK}
+        onActiveChange={noop}
+        onOpenFile={noop}
+      >
+        <ThreadView
+          session={value}
+          display={display}
+          marks={marksByDisplay(value.annotations, display)}
+          quickActions={[]}
+          observer={false}
+          focusedAnnotationId={focused}
+          onFocusAnnotation={setFocused}
+          onAnnotate={noop}
+          onReply={saveReply}
+          onUpdateAnnotation={noop}
+          onExit={noop}
+        />
+      </AgentThreadPane>
+    );
+  }
+  const setup = await testRender(<ChangesDiscussion />, {
+    width: 100,
+    height: 24,
+    kittyKeyboard: true,
+  });
+
+  try {
+    await waitForText(setup, root.body);
+    const mirror = locateText(setup, root.body);
+
+    await setup.mockMouse.click(mirror.column, mirror.row);
+    await typeText(setup, "Follow up on this change");
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "Follow up on this change");
+    expect(prompts).toHaveLength(0);
+    await pressKey(setup, "RETURN", { ctrl: true });
+    expect(prompts.map((prompt) => prompt.commentId)).toEqual(["followup"]);
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
+test("Ctrl+Enter submits only the comment just saved, leaving older notes editable", async () => {
+  const value: Thread = {
+    ...thread,
+    annotations: [
+      {
+        id: "older",
+        kind: "comment",
+        body: "Older unsent note",
+        createdAt: "2026-10-04",
+        anchor: { quote: "Original", prefix: "", suffix: " artifact" },
+      },
+    ],
+  };
+  const { client, prompts } = createTestAgentClient(empty);
+  const display = buildDisplay(value.artifact.content);
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={value}
+      theme={DARK}
+      focused
+      onActiveChange={noop}
+      onOpenFile={noop}
+      client={client}
+    >
+      <ThreadView
+        session={value}
+        display={display}
+        marks={marksByDisplay(value.annotations, display)}
+        quickActions={[]}
+        observer={false}
+        onAnnotate={() => "selected"}
+        onReply={noop}
+        onUpdateAnnotation={noop}
+        onExit={noop}
+      />
+    </AgentThreadPane>,
+    { width: 100, height: 24, kittyKeyboard: true },
+  );
+
+  try {
+    await waitForText(setup, "Original artifact");
+    const artifact = locateText(setup, "Original artifact");
+
+    await setup.mockMouse.drag(
+      artifact.column + 9,
+      artifact.row,
+      artifact.column + 17,
+      artifact.row,
+    );
+    await typeText(setup, "Only this question");
+    await pressKey(setup, "RETURN", { ctrl: true });
+    await waitForState(setup, () => prompts.length === 1, "selected comment invocation");
+    expect(prompts[0]?.commentId).toBe("selected");
+    expect(prompts[0]?.id).toBe(value.id);
+    expect(value.annotations[0]?.body).toBe("Older unsent note");
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
 test("Option+Enter saves a comment, Command+Enter leaves its draft, and Ctrl+Enter invokes", async () => {
   const saved: string[] = [];
   let invocations = 0;
@@ -385,7 +606,11 @@ test("Option+Enter saves a comment, Command+Enter leaves its draft, and Ctrl+Ent
       marks={marksByDisplay([], display)}
       quickActions={[]}
       observer={false}
-      onAnnotate={(_span, body) => saved.push(body)}
+      onAnnotate={(_span, body) => {
+        saved.push(body);
+
+        return `saved-${saved.length}`;
+      }}
       onReply={noop}
       onUpdateAnnotation={noop}
       onExit={noop}

package/src/thread/components/AgentThreadPane.tsx

@@ -29,7 +29,7 @@ export interface AgentThreadPaneProps {
     action: (id: string) => { label: string; run: () => void } | undefined,
   ) => void;
   onRevealReply?: () => void;
-  onInvokeChange?: (invoke: (() => void) | undefined) => void;
+  onInvokeChange?: (invoke: ((commentId?: string) => void) | undefined) => void;
   onStateChange?: (state: ThreadAgentState) => void;
   flushMutations?: () => Promise<void>;
   client?: ThreadAgentClient;
@@ -68,7 +68,9 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     useState<ThreadViewProps["promptRestoreRequest"]>();
   const restoreSequence = useRef(0);
   const invoking = useRef(false);
-  const invocations = useRef<{ text: string; writes: Promise<boolean>[] }[]>([]);
+  const invocations = useRef<{ text: string; commentId?: string; writes: Promise<boolean>[] }[]>(
+    [],
+  );
   const pendingWrites = useRef<Promise<boolean>[]>([]);
   const state = agent.state;
   const continuation = agentContinuation(state);
@@ -115,9 +117,16 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     notifyControls();
   }, [state, theme]);
 
-  const invoke = async (): Promise<void> => {
+  const invoke = async (commentId?: string): Promise<void> => {
     if (thread.status !== "pending") return;
-    invocations.current.push({ text: draft.current, writes: pendingWrites.current.splice(0) });
+    if (!commentId && !draft.current.trim()) return;
+    invocations.current.push({
+      text: draft.current,
+      commentId: commentId
+        ? (projection.mirrors.get(commentId)?.commentId ?? commentId)
+        : undefined,
+      writes: pendingWrites.current.splice(0),
+    });
     draft.current = "";
     if (invoking.current) return;
     invoking.current = true;
@@ -140,6 +149,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
             client.agentPrompt({
               id: thread.id,
               text: input.text,
+              commentId: input.commentId,
               inputOnly: Boolean(input.text.trim()),
               operationId: newAnnotationId(),
             }),
@@ -158,32 +168,36 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
       if (text) setPromptRestoreRequest({ id: ++restoreSequence.current, text });
     }
   };
-  const invokeRef = useRef<() => Promise<void>>(async () => {});
+  const invokeRef = useRef<(commentId?: string) => Promise<void>>(async () => {});
 
   useEffect(() => {
     invokeRef.current = invoke;
   });
-  const notifyInvoke = useEffectEvent((invoke: (() => void) | undefined) =>
+  const notifyInvoke = useEffectEvent((invoke: ((commentId?: string) => void) | undefined) =>
     props.onInvokeChange?.(invoke),
   );
 
   useEffect(() => {
-    notifyInvoke(() => void invokeRef.current());
+    notifyInvoke((commentId) => void invokeRef.current(commentId));
 
     return () => notifyInvoke(undefined);
   }, []);
-  const reply = (id: string, body: string): void => {
+  const reply = (id: string, body: string): string | void => {
     const origin = projection.mirrors.get(id)?.commentId ?? id;
     const root = agentCommentRoot(state, origin);
+    const replyFocusId = (commentId: string | void): string | void =>
+      commentId && projection.mirrors.has(id) ? `${id}:${commentId}` : commentId;
+
+    if (root) {
+      const commentId = newAnnotationId();
 
-    if (root)
       pendingWrites.current.push(
         agent.act((client) =>
           client.agentComment({
             id: thread.id,
             comment: {
               ...root,
-              id: newAnnotationId(),
+              id: commentId,
               body,
               sent: false,
               author: undefined,
@@ -192,7 +206,11 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
           }),
         ),
       );
-    else child?.onReply(origin, body);
+
+      return replyFocusId(commentId);
+    }
+
+    return replyFocusId(child?.onReply(origin, body));
   };
   const actionFor = (id: string) => {
     const mirror = projection.mirrors.get(id);
@@ -245,7 +263,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
         Boolean(state.comments.find((entry) => entry.id === id)?.sent)
       }
       annotationAction={actionFor}
-      onInvoke={() => void invoke()}
+      onInvoke={(commentId) => void invoke(commentId)}
       isPromptBlock={(index) => index === projection.tailIndex}
       promptRestoreRequest={promptRestoreRequest}
       promptFocusRequest={
@@ -276,14 +294,14 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
           return;
         }
         if (source?.kind === "mirror") {
-          if (source.commentId) reply(source.commentId, body);
+          const mirrorId = projection.marks.get(span.start.blockIndex)?.[0]?.annotationId;
+
+          if (mirrorId) return reply(mirrorId, body);
 
           return;
         }
         if (source?.kind === "artifact" && end?.kind === "artifact") {
-          child?.onAnnotate(span, body);
-
-          return;
+          return child?.onAnnotate(span, body);
         }
         if (
           source?.kind !== "message" ||
@@ -307,6 +325,8 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
         pendingWrites.current.push(
           agent.act((client) => client.agentComment({ id: thread.id, comment })),
         );
+
+        return comment.id;
       }}
       onReply={reply}
       onUpdateAnnotation={(id, body) => {