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

package/src/thread/agent-transcript.ts

@@ -36,6 +36,7 @@ export function projectAgentTranscript(thread: Thread, state: ThreadAgentState)
 
     display.push(...blocks);
     sources.push(...blocks.map((_, blockIndex) => ({ messageId: message.id, blockIndex })));
+
     if (message.role === "user") {
       const tools = state.tools.filter((tool) => tool.turnId === message.id);
 
@@ -176,6 +177,7 @@ export function projectThreadConversation(
         kind: "p",
         work: { kind: "p", text: "", lineStart: 0, lineEnd: 0 },
       });
+
     const offset = display.length;
     const annotation = {
       id: `mirror:${id}`,
@@ -195,6 +197,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 +214,23 @@ 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 } },
+            })),
           ],
         ]);
 
@@ -245,6 +249,7 @@ export function projectThreadConversation(
       );
     }
     mirrors.set(annotation.id, { commentId, submissionId });
+
     if (submissionId) destinations.set(submissionId, offset);
   };
   const message = (entry: ThreadAgentState["messages"][number]): void => {
@@ -298,12 +303,14 @@ export function projectThreadConversation(
           revision: 1,
         });
       }
+
       for (const entry of state.messages.filter(
         (entry) => entry.role === "agent" && entry.submissionId === submission.id,
       ))
         message(entry);
     }
   } else for (const entry of state.messages) message(entry);
+
   const activityIndex = showActivity ? display.length : -1;
 
   if (showActivity) {
@@ -314,6 +321,7 @@ export function projectThreadConversation(
     });
     sources.push({ kind: "activity" });
   }
+
   const tailIndex = display.length;
 
   display.push({

package/src/thread/components/AgentConfigControls.tsx

@@ -62,6 +62,7 @@ function AgentConfigMenu({
 
   useEffect(() => {
     if (!open) return;
+
     overlay.setOverlay(
       "agent-config",
       <box

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

@@ -43,6 +43,33 @@ const empty: ThreadAgentState = {
   comments: [],
 };
 
+test("a failed harness turn displays its error below the conversation", async () => {
+  const failure = "OAuth auth derivation failed: missing provider module";
+  const { client } = createTestAgentClient({ ...empty, phase: { kind: "failed", error: failure } });
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={thread}
+      client={client}
+      focused
+      theme={DARK}
+      onActiveChange={noop}
+      onOpenFile={noop}
+    >
+      {artifactView(thread)}
+    </AgentThreadPane>,
+    { width: 100, height: 24 },
+  );
+
+  try {
+    await waitForText(setup, "Original artifact");
+    await settle(setup);
+    expect(setup.captureCharFrame()).toContain(failure);
+    expect(setup.captureCharFrame()).not.toContain("Thinking");
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
 function createTestAgentClient(initial: ThreadAgentState) {
   let state = initial;
   const prompts: AgentPromptRequest[] = [];
@@ -56,6 +83,7 @@ function createTestAgentClient(initial: ThreadAgentState) {
     agentGet: async () => state,
     agentPrompt: async (params) => {
       prompts.push(params);
+
       if (params.text)
         state = {
           ...state,
@@ -287,6 +315,7 @@ test("three bottom prompts survive delayed acceptance and remain separate submis
 
   client.agentPrompt = async (params) => {
     prompts.push(params.text);
+
     if (prompts.length === 1)
       return new Promise((resolve) => {
         release = resolve;
@@ -374,6 +403,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 +635,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}
@@ -643,6 +897,7 @@ test("an arriving reply preserves a bottom draft and submits it as the next prom
 
   client.agentPrompt = async (params) => {
     prompts.push(params);
+
     if (prompts.length === 1)
       return new Promise<ThreadAgentState>((resolve) => {
         finish = resolve;
@@ -813,6 +1068,7 @@ test("a failed mutation flush restores the prompt alongside a newer visible draf
       onOpenFile={noop}
       flushMutations={() => {
         if (flushStarted) return Promise.resolve();
+
         flushStarted = true;
 
         return failedFlush;

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);
@@ -78,6 +80,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
   useEffect(() => {
     if (!busy) return;
+
     const timer = setInterval(() => setPulse((value) => !value), 600);
 
     return () => clearInterval(timer);
@@ -115,11 +118,22 @@ 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;
 
     const rejected: string[] = [];
@@ -135,11 +149,13 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
             rejected.push(input.text);
             continue;
           }
+
           await props.flushMutations?.();
           const accepted = await agent.act((client) =>
             client.agentPrompt({
               id: thread.id,
               text: input.text,
+              commentId: input.commentId,
               inputOnly: Boolean(input.text.trim()),
               operationId: newAnnotationId(),
             }),
@@ -158,32 +174,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 +212,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);
@@ -201,6 +225,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     );
 
     if (!submission) return undefined;
+
     if (submission.status === "failed" && props.client?.canControlAgent !== false)
       return {
         label: "Retry",
@@ -245,7 +270,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={
@@ -275,22 +300,26 @@ 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;
+        if (source?.kind === "artifact" && end?.kind === "artifact") {
+          return child?.onAnnotate(span, body);
         }
+
         if (
           source?.kind !== "message" ||
           end?.kind !== "message" ||
           source.messageId !== end.messageId
         )
           return;
+
         const message = state.messages.find((entry) => entry.id === source.messageId)!;
         const localState = { ...state, messages: [message] };
         const comment = commentOnAgentSpan(
@@ -307,6 +336,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) => {
@@ -327,6 +358,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
             {state.phase.kind === "offline" ? (
               <text fg={theme.textMuted}>Owner offline</text>
             ) : null}
+            {state.phase.kind === "failed" ? <text fg={theme.red}>{state.phase.error}</text> : null}
             {busy ? <text fg={pulse ? theme.textDim : theme.textMuted}>Thinking…</text> : null}
             {state.phase.kind === "permission" && props.client?.canControlAgent !== false ? (
               <>

package/src/thread/components/ThreadTree.tsx

@@ -116,6 +116,7 @@ function ThreadRow(props: ThreadRowProps): React.ReactNode {
 
   useEffect(() => {
     if (!menuOpen) return;
+
     // the full-screen box closes the menu on an outside click; the menu drops from under the kebab
     setOverlay(
       "thread-menu",

package/src/thread/components/thread-tree.test.ts

@@ -6,6 +6,7 @@ function session(id: string, title: string, rootCommit?: string, remote?: string
   const workspace: WorkspaceKey = { repoRoot: `/home/dev/${id}-checkout`, branch: "main" };
 
   if (rootCommit !== undefined) workspace.rootCommit = rootCommit;
+
   if (remote !== undefined) workspace.remote = remote;
 
   return {

package/src/thread/thread-controller.curate.test.ts

@@ -99,6 +99,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): ThreadClient {
 
       sink.workingCopy = content;
       session = { ...session, workingCopy: content };
+
       if (content === undefined) delete session.workingCopy;
 
       return session;
@@ -111,6 +112,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): ThreadClient {
 
       sink.workingCopy = content;
       session = { ...session, workingCopy: content };
+
       if (rejections.length) session.curation = rejections;
       else delete session.curation;