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

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

@@ -1,7 +1,12 @@
 import { expect, test } from "bun:test";
 import React from "react";
 import { testRender } from "@opentui/react/test-utils";
-import { SCHEMA_VERSION, type Thread, type ThreadAgentState } from "@cueloop/schema";
+import {
+  SCHEMA_VERSION,
+  type Thread,
+  type ThreadAgentState,
+  type AgentPromptRequest,
+} from "@cueloop/schema";
 import { AgentThreadPane, AgentThreadPrototype } from "./AgentThreadPane";
 import { ThreadFooter } from "./ThreadFooter";
 import { ThreadView } from "../../markdown/components/ThreadView";
@@ -16,6 +21,7 @@ import {
   waitForState,
 } from "../../testing/test-support";
 import type { ThreadAgentClient } from "../use-thread-agent";
+import type { EventFrame } from "@cueloop/daemon/client";
 
 const thread: Thread = {
   schemaVersion: SCHEMA_VERSION,
@@ -39,8 +45,14 @@ const empty: ThreadAgentState = {
 
 function createTestAgentClient(initial: ThreadAgentState) {
   let state = initial;
-  const prompts: { id: string; text: string; retry?: string }[] = [];
+  const prompts: AgentPromptRequest[] = [];
+  const listeners = new Set<(event: EventFrame) => void>();
   const client: ThreadAgentClient = {
+    onEvent: (listener) => {
+      listeners.add(listener);
+
+      return () => listeners.delete(listener);
+    },
     agentGet: async () => state,
     agentPrompt: async (params) => {
       prompts.push(params);
@@ -66,7 +78,12 @@ function createTestAgentClient(initial: ThreadAgentState) {
     agentPermission: async () => ({ ...state, phase: { kind: "idle" } }),
   };
 
-  return { client, prompts };
+  const publishTestAgentState = (next: ThreadAgentState): void => {
+    state = next;
+    for (const listener of listeners) listener({ event: "agent.updated", sessionId: thread.id });
+  };
+
+  return { client, prompts, publishTestAgentState };
 }
 
 function artifactView(
@@ -132,6 +149,7 @@ test("typing on the final blank line invokes the agent while the existing footer
     setup.mockInput.pressKey("RETURN", { ctrl: true });
     await waitForText(setup, "The timer survives cancellation.");
     expect(prompts[0]?.text).toBe("Explain retries");
+    expect(prompts[0]?.inputOnly).toBe(true);
     const send = locateText(setup, "Send message (0)");
 
     await setup.mockMouse.click(send.column, send.row);
@@ -356,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;
@@ -367,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}
@@ -827,3 +1070,91 @@ test("a failed mutation flush restores the prompt alongside a newer visible draf
     setup.renderer.destroy();
   }
 });
+
+test("an offline shared agent accepts continuation below its status without model controls", async () => {
+  const state: ThreadAgentState = {
+    ...empty,
+    messages: [
+      { id: "online-answer", role: "agent", text: "An online answer", complete: true, revision: 1 },
+    ],
+  };
+  const { client, prompts, publishTestAgentState } = createTestAgentClient(state);
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={thread}
+      client={client}
+      focused
+      theme={DARK}
+      onActiveChange={noop}
+      onOpenFile={noop}
+    >
+      {artifactView(thread)}
+    </AgentThreadPane>,
+    { width: 80, height: 15, kittyKeyboard: true },
+  );
+
+  try {
+    await waitForText(setup, "An online answer");
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor !== null,
+      "online continuation editor",
+    );
+    publishTestAgentState({ ...state, phase: { kind: "offline" } });
+    await waitForText(setup, "Owner offline");
+    expect(setup.captureCharFrame()).toContain("Original artifact");
+    expect(setup.captureCharFrame()).not.toContain("Thinking");
+    const status = locateText(setup, "Owner offline");
+
+    await setup.mockMouse.click(status.column + 5, status.row + 3);
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor !== null,
+      "offline continuation editor",
+    );
+    await typeText(setup, "Queue until the owner reconnects");
+    await waitForText(setup, "Queue until the owner reconnects");
+    await pressKey(setup, "RETURN", { ctrl: true });
+    expect(prompts[0]?.text).toBe("Queue until the owner reconnects");
+    expect(prompts[0]?.inputOnly).toBe(true);
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
+test("shared viewers see pending activity without owner permission controls", async () => {
+  const { client } = createTestAgentClient({
+    ...empty,
+    phase: {
+      kind: "permission",
+      permission: {
+        id: "owner-permission",
+        title: "Owner approval required",
+        options: [{ optionId: "allow", name: "Allow once", kind: "allow_once" }],
+      },
+    },
+  });
+
+  client.canControlAgent = false;
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={thread}
+      client={client}
+      focused
+      theme={DARK}
+      onActiveChange={noop}
+      onOpenFile={noop}
+    >
+      {artifactView(thread)}
+    </AgentThreadPane>,
+    { width: 80, height: 15 },
+  );
+
+  try {
+    await waitForText(setup, "Thinking");
+    expect(setup.captureCharFrame()).not.toContain("Allow once");
+    expect(setup.captureCharFrame()).not.toContain("Owner approval required");
+  } finally {
+    setup.renderer.destroy();
+  }
+});

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);
@@ -86,18 +88,20 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
   const notifyState = useEffectEvent(() => props.onStateChange?.(state));
   const notifyControls = useEffectEvent(() =>
     props.onControlsChange?.(
-      <AgentConfigControls
-        state={state}
-        theme={theme}
-        onConfigure={(configId, value) =>
-          void agent.act((client) => {
-            if (!client.agentConfigure)
-              return Promise.reject(new Error("Agent configuration is unavailable"));
-
-            return client.agentConfigure({ id: thread.id, configId, value });
-          })
-        }
-      />,
+      props.client && !props.client.agentConfigure ? null : (
+        <AgentConfigControls
+          state={state}
+          theme={theme}
+          onConfigure={(configId, value) =>
+            void agent.act((client) => {
+              if (!client.agentConfigure)
+                return Promise.reject(new Error("Agent configuration is unavailable"));
+
+              return client.agentConfigure({ id: thread.id, configId, value });
+            })
+          }
+        />
+      ),
     ),
   );
 
@@ -113,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;
@@ -135,7 +146,13 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
           }
           await props.flushMutations?.();
           const accepted = await agent.act((client) =>
-            client.agentPrompt({ id: thread.id, text: input.text }),
+            client.agentPrompt({
+              id: thread.id,
+              text: input.text,
+              commentId: input.commentId,
+              inputOnly: Boolean(input.text.trim()),
+              operationId: newAnnotationId(),
+            }),
           );
 
           if (!accepted) rejected.push(input.text);
@@ -151,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,
@@ -185,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);
@@ -194,7 +219,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     );
 
     if (!submission) return undefined;
-    if (submission.status === "failed")
+    if (submission.status === "failed" && props.client?.canControlAgent !== false)
       return {
         label: "Retry",
         run: () =>
@@ -238,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={
@@ -269,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" ||
@@ -300,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) => {
@@ -317,8 +344,11 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
       renderBlock={(index) =>
         index === projection.activityIndex ? (
           <box style={{ flexDirection: "column", paddingLeft: 2 }}>
+            {state.phase.kind === "offline" ? (
+              <text fg={theme.textMuted}>Owner offline</text>
+            ) : null}
             {busy ? <text fg={pulse ? theme.textDim : theme.textMuted}>Thinking…</text> : null}
-            {state.phase.kind === "permission" ? (
+            {state.phase.kind === "permission" && props.client?.canControlAgent !== false ? (
               <>
                 <text fg={theme.text}>{state.phase.permission.title}</text>
                 <box style={{ flexDirection: "row", gap: 2 }}>

package/src/thread/thread-controller.ts

@@ -39,6 +39,7 @@ import {
   type Artifact,
   type DiffFileContents,
   type ShareLink,
+  type SharePolicy,
   type Thread,
   type SessionHistory,
   type MessageOutcome,
@@ -241,6 +242,7 @@ export interface NewShareLink {
   name?: string;
   requireAuth: boolean;
   allowlist: string[];
+  agentEnabled?: boolean;
 }
 
 export interface ReviewControllerOptions {
@@ -1697,15 +1699,16 @@ class Controller implements ReviewController {
     this.setStatus("sharing…");
     this.freezeForShare(session)
       .then((shared) => {
-        return this.shareTransport.publish(
-          shared,
-          {},
-          {
-            requireAuth: input.requireAuth,
-            allowlist: input.allowlist,
-            shareBranch,
-          },
-        );
+        const policy: ShareLink = {
+          id: session.id,
+          requireAuth: input.requireAuth,
+          allowlist: input.allowlist,
+          shareBranch,
+        };
+
+        if (input.agentEnabled !== undefined) policy.agentEnabled = input.agentEnabled;
+
+        return this.shareTransport.publish(shared, {}, policy);
       })
       .then(async ({ line, copied }) => {
         const id = this.shareTransport.parseShareId(line);
@@ -1719,6 +1722,7 @@ class Controller implements ReviewController {
           shareBranch,
         };
 
+        if (input.agentEnabled !== undefined) link.agentEnabled = input.agentEnabled;
         await client.sessionSetShares(session.id, [...this.linksFor(this.snapshot.session), link]);
         this.setStatus("");
         this.showToast(line, copied ? "link copied" : "link created");
@@ -1738,20 +1742,24 @@ class Controller implements ReviewController {
     if (!links.some((link) => link.id === id)) return;
     const allowlist = input.requireAuth ? input.allowlist : [];
 
+    const policy: SharePolicy = { requireAuth: input.requireAuth, allowlist };
+
+    if (input.agentEnabled !== undefined) policy.agentEnabled = input.agentEnabled;
     // Publish the same policy stored on the local link.
-    void this.shareTransport
-      .push(id, [], { requireAuth: input.requireAuth, allowlist })
-      .catch(() => {});
-    const next = links.map((link) =>
-      link.id === id
-        ? {
-            ...link,
-            name: input.name?.trim() || undefined,
-            requireAuth: input.requireAuth,
-            allowlist,
-          }
-        : link,
-    );
+    void this.shareTransport.push(id, [], policy).catch(() => {});
+    const next = links.map((link) => {
+      if (link.id !== id) return link;
+      const updated = {
+        ...link,
+        name: input.name?.trim() || undefined,
+        requireAuth: input.requireAuth,
+        allowlist,
+      };
+
+      if (input.agentEnabled !== undefined) updated.agentEnabled = input.agentEnabled;
+
+      return updated;
+    });
 
     this.applyOptimistic(
       { ...session, shares: next },