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

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

@@ -110,3 +110,44 @@ test("model and reasoning choices share the existing overlay and close after sel
     setup.renderer.destroy();
   }
 });
+
+for (const harness of ["pi", "fx"]) {
+  test(`${harness} footer identifies its harness, subscription, model and effort`, async () => {
+    const setup = await testRender(
+      <AgentConfigControls
+        theme={DARK}
+        onConfigure={() => {}}
+        state={{
+          ...initial,
+          harness: { id: harness, label: harness },
+          configOptions: [
+            {
+              id: "provider",
+              name: "Provider",
+              currentValue: harness,
+              options: [
+                {
+                  value: harness,
+                  name: harness === "pi" ? "Codex subscription" : "Grok subscription",
+                },
+              ],
+            },
+            ...initial.configOptions!,
+          ],
+        }}
+      />,
+      { width: 100, height: 3 },
+    );
+
+    try {
+      await waitForText(setup, "First model");
+      const frame = setup.captureCharFrame();
+
+      expect(frame).toContain(harness);
+      expect(frame).toContain(harness === "pi" ? "Codex subscription" : "Grok subscription");
+      expect(frame).toContain("Medium");
+    } finally {
+      setup.renderer.destroy();
+    }
+  });
+}

package/src/thread/components/AgentConfigControls.tsx

@@ -18,10 +18,12 @@ export function AgentConfigControls({
 }): React.ReactNode {
   return (
     <box style={{ flexDirection: "row", gap: 2, marginRight: 2 }}>
+      {state.harness ? <text fg={theme.textMuted}>{state.harness.label}</text> : null}
       {state.configOptions
         ?.filter(
           (option) =>
             option.category === "thought_level" ||
+            option.id === "effort" ||
             option.id === "model" ||
             option.id === "provider",
         )
@@ -62,6 +64,7 @@ function AgentConfigMenu({
 
   useEffect(() => {
     if (!open) return;
+
     overlay.setOverlay(
       "agent-config",
       <box
@@ -103,7 +106,11 @@ function AgentConfigMenu({
   return (
     <box
       ref={ref}
-      onMouseUp={disabled ? undefined : () => menu.toggleMenu(`agent-config:${option.id}`)}
+      onMouseUp={
+        disabled || option.options.length < 2
+          ? undefined
+          : () => menu.toggleMenu(`agent-config:${option.id}`)
+      }
     >
       <text fg={disabled ? theme.textDim : theme.textMuted}>
         {option.options.find((choice) => choice.value === option.currentValue)?.name ??

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

@@ -9,11 +9,12 @@ import {
 } from "@cueloop/schema";
 import { AgentThreadPane, AgentThreadPrototype } from "./AgentThreadPane";
 import { ThreadFooter } from "./ThreadFooter";
-import { ThreadView } from "../../markdown/components/ThreadView";
+import { ThreadView, type ThreadViewProps } from "../../markdown/components/ThreadView";
 import { buildDisplay, marksByDisplay } from "../../markdown/view-plan";
 import { DARK } from "../../appearance/theme";
 import {
   locateText,
+  dragText,
   waitForText,
   pressKey,
   typeText,
@@ -43,6 +44,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 +84,7 @@ function createTestAgentClient(initial: ThreadAgentState) {
     agentGet: async () => state,
     agentPrompt: async (params) => {
       prompts.push(params);
+
       if (params.text)
         state = {
           ...state,
@@ -90,6 +119,8 @@ function artifactView(
   value: Thread,
   onReply: (id: string, body: string) => void = noop,
   onUpdateAnnotation: (id: string, body: string) => void = noop,
+  onAnnotate: ThreadViewProps["onAnnotate"] = noop,
+  observer = false,
 ) {
   const display = buildDisplay(value.artifact.content);
 
@@ -99,8 +130,8 @@ function artifactView(
       display={display}
       marks={marksByDisplay(value.annotations, display)}
       quickActions={[]}
-      observer={false}
-      onAnnotate={noop}
+      observer={observer}
+      onAnnotate={onAnnotate}
       onReply={onReply}
       onUpdateAnnotation={onUpdateAnnotation}
       onExit={noop}
@@ -287,6 +318,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;
@@ -868,6 +900,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;
@@ -1038,6 +1071,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;
@@ -1158,3 +1192,57 @@ test("shared viewers see pending activity without owner permission controls", as
     setup.renderer.destroy();
   }
 });
+
+for (const observer of [false, true]) {
+  test(`shared snapshot preserves artifact annotation permissions (observer=${observer})`, async () => {
+    const value = {
+      ...thread,
+      agentSnapshot: {
+        ...empty,
+        messages: [
+          {
+            id: "answer",
+            role: "agent" as const,
+            text: "Frozen conversation",
+            complete: true,
+            revision: 1,
+          },
+        ],
+      },
+    };
+    const annotations: string[] = [];
+    const setup = await testRender(
+      <AgentThreadPrototype
+        enabled={false}
+        observer={observer}
+        pixelPrototype={false}
+        thread={value}
+        focused
+        theme={DARK}
+        onActiveChange={noop}
+        onOpenFile={noop}
+      >
+        {artifactView(
+          value,
+          noop,
+          noop,
+          (_span, body) => {
+            annotations.push(body);
+          },
+          observer,
+        )}
+      </AgentThreadPrototype>,
+      { width: 100, height: 24, kittyKeyboard: true },
+    );
+
+    try {
+      await waitForText(setup, "Frozen conversation");
+      await dragText(setup, "Original artifact", "Original artifact", "Original artifact".length);
+      await typeText(setup, "Artifact feedback");
+      await pressKey(setup, "RETURN", { meta: true });
+      expect(annotations).toEqual(observer ? [] : ["Artifact feedback"]);
+    } finally {
+      setup.renderer.destroy();
+    }
+  });
+}

package/src/thread/components/AgentThreadPane.tsx

@@ -80,6 +80,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
   useEffect(() => {
     if (!busy) return;
+
     const timer = setInterval(() => setPulse((value) => !value), 600);
 
     return () => clearInterval(timer);
@@ -119,7 +120,9 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
   const invoke = async (commentId?: string): Promise<void> => {
     if (thread.status !== "pending") return;
+
     if (!commentId && !draft.current.trim()) return;
+
     invocations.current.push({
       text: draft.current,
       commentId: commentId
@@ -128,7 +131,9 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
       writes: pendingWrites.current.splice(0),
     });
     draft.current = "";
+
     if (invoking.current) return;
+
     invoking.current = true;
 
     const rejected: string[] = [];
@@ -144,6 +149,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
             rejected.push(input.text);
             continue;
           }
+
           await props.flushMutations?.();
           const accepted = await agent.act((client) =>
             client.agentPrompt({
@@ -219,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",
@@ -293,6 +300,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
           return;
         }
+
         if (source?.kind === "mirror") {
           const mirrorId = projection.marks.get(span.start.blockIndex)?.[0]?.annotationId;
 
@@ -300,15 +308,18 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
           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(
@@ -347,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 ? (
               <>
@@ -386,6 +398,55 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 export function AgentThreadPrototype(
   props: AgentThreadPaneProps & { enabled: boolean; observer: boolean; pixelPrototype: boolean },
 ): React.ReactNode {
+  if (
+    (!props.enabled || props.observer) &&
+    props.thread.agentSnapshot &&
+    React.isValidElement<ThreadViewProps>(props.children) &&
+    props.children.type === ThreadView
+  ) {
+    const child = props.children.props;
+    const display =
+      child.display ??
+      buildDisplay(
+        props.thread.artifact.type === "diff"
+          ? (props.thread.artifact.meta.prBrief ?? "")
+          : (props.thread.workingCopy ?? props.thread.artifact.content),
+      );
+    const projection = projectThreadConversation(
+      props.thread,
+      props.thread.agentSnapshot,
+      display,
+      child.marks ?? marksByDisplay(props.thread.annotations, display),
+      false,
+    );
+
+    return (
+      <ThreadView
+        {...child}
+        session={projection.session}
+        display={projection.display}
+        marks={projection.marks}
+        canAnnotateBlock={(index) =>
+          projection.sources[index]?.kind === "artifact" &&
+          (child.canAnnotateBlock?.(index) ?? true)
+        }
+        isAnnotationReadOnly={(id) =>
+          !props.thread.annotations.some((entry) => entry.id === id) ||
+          Boolean(child.isAnnotationReadOnly?.(id))
+        }
+        onAnnotate={(span, body) => {
+          if (
+            projection.sources[span.start.blockIndex]?.kind !== "artifact" ||
+            projection.sources[span.end.blockIndex]?.kind !== "artifact"
+          )
+            return;
+
+          return child.onAnnotate(span, body);
+        }}
+      />
+    );
+  }
+
   if (!props.enabled || props.observer || props.pixelPrototype) return props.children;
 
   return <AgentThreadPane {...props} />;

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;
 

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

@@ -8,9 +8,16 @@ import {
   SHARE_RECONNECT_MIN_MS,
   type ShareTransport,
 } from "./thread-controller";
-import { mergeFromShare, type ShareWatchHandlers } from "../integrations/share";
+import {
+  snapshotThreadConversation,
+  mergeFromShare,
+  type ShareWatchHandlers,
+} from "../integrations/share";
 
-const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
+const publishShare = mock(async (_session: Thread) => ({
+  line: "ssh p_abc123xy@cueloop.dev",
+  copied: true,
+}));
 let remote: Thread;
 const pullShare = mock(async () => remote);
 const pushShare = mock(
@@ -571,3 +578,41 @@ describe("revoke", () => {
     expect(client.sessionDelete).toHaveBeenCalledWith(session.id);
   });
 });
+
+test("share publication captures an empty artifact's separate conversation without execution records", async () => {
+  const thread = sessionFixture({ artifact: { type: "plan", content: "", meta: {} } });
+  const { controller, client } = await connectedController(thread);
+  const state = {
+    threadId: thread.id,
+    phase: { kind: "idle" as const },
+    harness: { id: "pi", label: "pi", sessionId: "private-session" },
+    messages: [
+      {
+        id: "answer",
+        role: "agent" as const,
+        text: "Visible conversation",
+        complete: true,
+        revision: 1,
+      },
+    ],
+    comments: [],
+    tools: [],
+    promptOperations: [
+      { operationId: "private-operation", fingerprint: "private-hash", result: [] },
+    ],
+  };
+
+  client.agentGet = async () => state;
+  publishShare.mockClear();
+  controller.share();
+  await tick();
+  await tick();
+  const shared = publishShare.mock.calls[0]![0];
+
+  expect(shared.agentSnapshot?.messages).toEqual(state.messages);
+  expect(shared.agentSnapshot?.harness).toEqual({ id: "pi", label: "pi" });
+  expect(shared.agentSnapshot?.promptOperations).toBeUndefined();
+  expect(thread.agentSnapshot).toBeUndefined();
+  expect(await snapshotThreadConversation(thread, {})).toBe(thread);
+  controller.close();
+});