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

package/src/app/App.deleted-scroll.test.tsx

@@ -73,9 +73,11 @@ test("deleted file caret scrolls one row and stays at the file boundaries", asyn
     const box = findScrollbox(setup.renderer.root);
 
     if (!box) throw new Error("file diff scrollbox missing");
+
     for (let offset = 0; offset < 1000; offset += 20) {
       box.scrollTo({ x: 0, y: offset });
       await settle(setup);
+
       if (setup.captureCharFrame().includes("row 130")) break;
     }
     const target = locateText(setup, "row 130");
@@ -127,6 +129,7 @@ test("deleted file caret scrolls one row and stays at the file boundaries", asyn
         .findIndex((line) => line.includes("▎"));
 
       if (marker === box.viewport.screenY) anchored = true;
+
       if (anchored && box.scrollTop > 0) expect(marker).toBe(box.viewport.screenY);
     }
     expect(anchored).toBe(true);

package/src/app/App.harness-settings.test.tsx

@@ -0,0 +1,77 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ThreadAgentState } from "@cueloop/schema";
+import { App } from "./App";
+import {
+  clickText,
+  isolateUserConfig,
+  isolatedUserConfigPath,
+  renderReadyApp,
+  waitForText,
+  waitForTextGone,
+} from "../testing/test-support";
+
+test("repeated harness toggle failures show feedback without losing the controller binding", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-harness-settings-"));
+  const restore = isolateUserConfig(home);
+  const server = new DaemonServer({ home, idleExitMs: 0 });
+
+  writeFileSync(isolatedUserConfigPath(home), "[experimental]\nthread_agent = true\n");
+  server.start();
+  const thread = server.core.sessionCreate({
+    workspace: { repoRoot: home, branch: "main" },
+    artifact: { type: "plan", content: "# Switching review", meta: { title: "Switching review" } },
+  });
+  const state: ThreadAgentState = {
+    threadId: thread.id,
+    phase: { kind: "idle" },
+    messages: [],
+    comments: [],
+    tools: [],
+  };
+  let switches = 0;
+  const setup = await renderReadyApp(
+    <App
+      home={home}
+      sessionId={thread.id}
+      agentClient={{
+        agentGet: async () => state,
+        agentPrompt: async () => state,
+        agentCancel: async () => state,
+        agentComment: async () => state,
+        agentPermission: async () => state,
+        agentConfigure: async (params) => {
+          if (!params.configId) return state;
+
+          switches++;
+          throw new Error(`Switch failure ${switches}`);
+        },
+      }}
+    />,
+    { width: 120, height: 32 },
+  );
+
+  try {
+    await setup.mockMouse.click(1, 0);
+    await waitForText(setup, "settings");
+    await clickText(setup, "settings");
+    await waitForText(setup, "General");
+    await clickText(setup, "Thread ");
+    await waitForText(setup, "Harness");
+    await clickText(setup, "Harness");
+    await waitForText(setup, "Switch failure 1");
+    await waitForTextGone(setup, "Switch failure 1");
+    await clickText(setup, "Harness");
+    await waitForText(setup, "Switch failure 2");
+    expect(switches).toBe(2);
+  } finally {
+    setup.renderer.destroy();
+    server.stop();
+    restore();
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/app/App.plan-render.test.tsx

@@ -91,6 +91,7 @@ function foregroundsOf(setup: Setup, needle: string): string[] {
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (span.fg === undefined || !span.text.includes(needle)) continue;
+
       const [red, green, blue] = span.fg.toInts();
 
       foregrounds.push(
@@ -109,6 +110,7 @@ function backgroundsOf(setup: Setup, needle: string): string[] {
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (!span.text.includes(needle)) continue;
+
       const [red, green, blue] = span.bg.toInts();
 
       backgrounds.push(

package/src/app/App.plan-review.test.tsx

@@ -84,6 +84,7 @@ function backgroundsOf(setup: Setup, needle: string): string[] {
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (!span.text.includes(needle)) continue;
+
       const [red, green, blue] = span.bg.toInts();
 
       backgrounds.push(

package/src/app/App.readonly.test.tsx

@@ -5,6 +5,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import React from "react";
+import { DaemonClient } from "@cueloop/daemon/client";
+import { NERD } from "../ui/components/primitives/icons";
 import { DaemonServer } from "@cueloop/daemon";
 import { makeAnchor, parseBlocks, type Thread } from "@cueloop/schema";
 import { App } from "./App";
@@ -208,3 +210,64 @@ describe("observer navigation still works", () => {
     expect(snapshot().annotations).toBe(1);
   });
 });
+
+for (const role of ["collaborator", "observer"] as const) {
+  test(`${role} shared view shows a conversation snapshot and has no Thread actions menu`, async () => {
+    const client = await DaemonClient.connect({ home });
+    const shared = {
+      ...session,
+      artifact: { ...session.artifact, content: "" },
+      agentSnapshot: {
+        threadId: session.id,
+        phase: { kind: "idle" as const },
+        tools: [],
+        comments: [],
+        messages: [
+          {
+            id: "prompt",
+            role: "user" as const,
+            text: "Shared question",
+            complete: true,
+            revision: 1,
+          },
+          {
+            id: "answer",
+            role: "agent" as const,
+            text: "Shared conversation answer",
+            complete: true,
+            revision: 1,
+          },
+        ],
+      },
+    };
+
+    client.sessionGet = async () => shared;
+    client.sessionList = async () => [shared];
+    const setup = await renderReadyApp(
+      <App
+        home={home}
+        sessionId={shared.id}
+        role={role}
+        openClient={() => Promise.resolve(client)}
+      />,
+      { width: 120, height: 32 },
+    );
+
+    try {
+      await waitForText(setup, "Shared conversation answer");
+      expect(setup.captureCharFrame()).toContain("Shared question");
+      const row = setup
+        .captureCharFrame()
+        .split("\n")
+        .findIndex((line) => line.slice(0, 30).includes("Migration Plan"));
+
+      expect(row).toBeGreaterThanOrEqual(0);
+      await setup.mockMouse.moveTo(12, row);
+      expect(setup.captureCharFrame()).not.toContain(NERD.kebab);
+      expect(setup.captureCharFrame()).not.toContain(" edit ");
+    } finally {
+      setup.renderer.destroy();
+      client.close();
+    }
+  });
+}

package/src/app/App.test.tsx

@@ -78,6 +78,7 @@ function foregroundsOf(setup: Setup, needle: string): string[] {
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (!span.text.includes(needle)) continue;
+
       const [red, green, blue] = span.fg.toInts();
 
       foregrounds.push(

package/src/app/App.tsx

@@ -1,3 +1,5 @@
+import { THREAD_MODEL_DEFAULTS } from "@cueloop/schema";
+import { useThreadHarnessSetting } from "../settings/use-thread-harness-setting";
 import React, {
   useCallback,
   useEffect,
@@ -203,6 +205,7 @@ export function quitKeyHandled(
   onExit?: (code: number) => void,
 ): boolean {
   if (!key.ctrl || key.name !== "q") return false;
+
   onExit?.(0);
 
   return true;
@@ -214,6 +217,7 @@ function menuModalHandled(
   key: { name: string },
 ): boolean {
   if (menuControl.openMenuId === null) return false;
+
   if (key.name === "escape") menuControl.closeMenu();
 
   return true;
@@ -300,7 +304,9 @@ function chooseThreadBody(choice: {
   threadView: React.ReactNode;
 }): React.ReactNode {
   if (choice.isPixelPrototype) return choice.prototype;
+
   if (choice.isDiff) return choice.diffPlaceholder;
+
   if (choice.editingBody) return choice.editor;
 
   return choice.threadView;
@@ -453,16 +459,19 @@ export function threadsNavHandled(params: {
   const { focusedPane, quiet, key, count } = params;
 
   if (focusedPane !== "threads" || !quiet || count === 0) return false;
+
   if (key.name === "j" || key.name === "down") {
     params.setInboxCursor((cursor) => Math.min(cursor + 1, count - 1));
 
     return true;
   }
+
   if (key.name === "k" || key.name === "up") {
     params.setInboxCursor((cursor) => Math.max(cursor - 1, 0));
 
     return true;
   }
+
   if (key.name === "return" || key.name === "enter") {
     params.openSession();
 
@@ -490,8 +499,11 @@ export function visiblePanes(
   const panes: FocusPane[] = [];
 
   if (sidebarOpen) panes.push("threads");
+
   if (threadShown) panes.push("thread");
+
   if (changesOpen) panes.push("changes");
+
   if (projectOpen) panes.push("project");
 
   return panes;
@@ -503,6 +515,7 @@ export function nextFocusPane(
   backward: boolean,
 ): FocusPane {
   if (panes.length === 0) return current;
+
   const index = panes.indexOf(current);
   const step = backward ? -1 : 1;
 
@@ -547,7 +560,11 @@ export function App({
   servedArtifact,
   extensionRegistry,
 }: AppProps): React.ReactNode {
-  const { observer, isOwner } = computeRoleCapabilities(readOnly, role);
+  const { observer, isOwner, canManageThreads } = computeRoleCapabilities(
+    readOnly,
+    role,
+    isSharedThreadConnection(openClient, shareTransport),
+  );
   const controller = useMemo(
     () =>
       createReviewController({
@@ -617,6 +634,7 @@ export function App({
 
       if (next.has(id)) next.delete(id);
       else next.add(id);
+
       persistPins([...next]);
 
       return next;
@@ -673,6 +691,7 @@ export function App({
   const [identity, setIdentity] = useState<IdentityConfig>({ provider: "typed" });
   const [quickActions, setQuickActions] = useState<QuickAction[]>(DEFAULT_QUICK_ACTIONS);
   const [skills, setSkills] = useState<SlashItem[]>([]);
+  const [threadModelDefaults, setThreadModelDefaults] = useState(THREAD_MODEL_DEFAULTS);
   const [reviewSkill, setReviewSkill] = useState("code-review");
   const [reviewWorkspace, setReviewWorkspace] = useState<ReviewWorkspaceMode>("worktree");
   const paletteNames = useMemo(
@@ -688,6 +707,8 @@ export function App({
 
     setPrototypePixels(config.experimental.prototypePixels);
     setThreadAgentEnabled(config.experimental.threadAgent);
+    setThreadHarness(config.thread.harness);
+    setThreadModelDefaults({ pi: config.thread.pi, fx: config.thread.fx });
     keysRef.current = config.keys;
     keyBindings.setKeys(config.keys);
     setTheme(composeTheme(config.ui.theme, config.themeOverrides, appearance));
@@ -714,6 +735,7 @@ export function App({
 
   useEffect(() => {
     if (!toast) return;
+
     const timer = setTimeout(() => controller.dismissToast(), TOAST_DISMISS_MS);
 
     return () => clearTimeout(timer);
@@ -725,6 +747,7 @@ export function App({
 
   useEffect(() => {
     if (promptedSelfRef.current || role !== "collaborator" || !selfAuthor || !session) return;
+
     promptedSelfRef.current = true;
     const known = session.participants?.find((participant) => participant.id === selfAuthor)?.name;
 
@@ -747,13 +770,31 @@ export function App({
 
     void resolveGithubIdentity().then((github) => {
       if (identityGenerationRef.current !== generation) return;
+
       if (!github) return controller.setStatus("GitHub not connected - run gh auth login");
+
       const name = github.name?.trim() || github.login;
 
       applyIdentity({ name, provider: "github" });
     });
   };
 
+  const [agentState, setAgentState] = useState<import("@cueloop/schema").ThreadAgentState>();
+  const [threadHarness, setThreadHarness] = useState<"pi" | "fx">("pi");
+
+  const harnessSetting = useThreadHarnessSetting({
+    home,
+    thread: session,
+    enabled: threadAgentEnabled,
+    owner: isOwner,
+    state: agentState,
+    preferred: threadHarness,
+    client: agentClient,
+    onState: setAgentState,
+    onPreferred: setThreadHarness,
+    onError: (message) => controller.setStatus(message),
+  });
+
   // ── settings dialog: config-backed model, navigation, persistence ──
   const {
     settingsNav,
@@ -764,6 +805,8 @@ export function App({
     onCategorySelect,
     openSettings,
   } = useSettingsDialog({
+    threadDefaults: threadModelDefaults,
+    setThreadDefaults: setThreadModelDefaults,
     theme,
     appearance,
     autoClose,
@@ -787,6 +830,9 @@ export function App({
     reviewSkill,
     reviewWorkspace,
     setReviewWorkspace,
+    canSwitchHarness: harnessSetting.enabled,
+    threadHarness: harnessSetting.harness,
+    onSwitchHarness: harnessSetting.switchHarness,
   });
 
   // ── derived view model ──────────────────────
@@ -843,7 +889,6 @@ export function App({
     () => 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);
   // inline body edit: the markdown editor owns the thread pane and all keys while open
@@ -868,9 +913,11 @@ export function App({
 
   const openCardEdit = (annotationId: string): void => {
     if (observer) return controller.setStatus("observer - read-only");
+
     const annotation = session?.annotations.find((candidate) => candidate.id === annotationId);
 
     if (!annotation) return;
+
     // a collaborator's note is theirs to word: activating it (click or e) renames
     // the author rather than editing the body the planner does not own
     if (annotation.author) {
@@ -882,7 +929,9 @@ export function App({
         text: authorNames[annotation.author] ?? "",
       });
     }
+
     if (resolved) return controller.setStatus("review submitted - read-only");
+
     liveInput.current = annotation.body;
     setMode({ type: "railEdit", id: annotation.id, text: annotation.body });
   };
@@ -894,6 +943,7 @@ export function App({
 
       return;
     }
+
     renderer?.suspend();
     try {
       controller.edit();
@@ -949,6 +999,7 @@ export function App({
     },
     openShareDialog: () => {
       if (!isOwner) return controller.setStatus("only the plan owner can share");
+
       shareDialogStore.getState().reset();
       setShareDialogOpen(true);
     },
@@ -974,6 +1025,7 @@ export function App({
   useEffect(() => {
     // the bare shell drives its panes from its own workbench, so only reconcile against this one
     if (!session) return;
+
     const next = reconciledFocus(navigablePanes, focusedPane);
 
     if (next) setFocusedPane(next);
@@ -995,6 +1047,7 @@ export function App({
     });
 
     if (!intent) return false;
+
     if (intent.type === "cut" && selection) {
       controller.cut(
         selection.start.blockIndex,
@@ -1010,9 +1063,11 @@ export function App({
   const openThread = (id: string): void => {
     // save the open editor into the leaving thread's working copy before the switch, so a click away never drops edits
     if (bodyEditing.editing) bodyEditing.requestExit();
+
     const index = grouped.ordered.findIndex((thread) => thread.id === id);
 
     if (index >= 0) setInboxCursor(() => index);
+
     controller.open(id);
   };
 
@@ -1038,7 +1093,9 @@ export function App({
       !key.super
     )
       return true;
+
     if (!threadViewActive || threadViewSuspended) return false;
+
     if (!threadComposing) {
       const chord = resolveSessionChord(key, { isOwner, resolved });
 
@@ -1050,14 +1107,19 @@ export function App({
 
   useKeyboard((key) => {
     if (quitKeyHandled(key, onExit)) return;
+
     // the inline body editor owns the pane and every key while open
     if (bodyEditing.editing) return;
+
     // the share dialog owns its own keys while open; the shell grammar stands down
     if (shareDialogOpen) return;
+
     if (menuModalHandled(menuControl, key)) return;
+
     if (paneCycleRequested(key, overlay, menuOwnsKeyboard, threadComposing)) {
       return cyclePanes(Boolean(key.shift));
     }
+
     if (
       threadsNavHandled({
         focusedPane,
@@ -1069,17 +1131,24 @@ export function App({
       })
     )
       return;
+
     if (threadSurfaceHandledKey(key)) return;
+
     // A compose textarea owns the keyboard while open: let it receive the typed note instead of the
     // global keymap acting on each letter (the prototype, and the bare-shell welcome playground).
     if (prototypeComposing || welcomeComposing) return;
+
     if (menuDialog === "settings") return void handleSettingsKey(key.name);
+
     if (menuDialog) return void (key.name === "escape" && setMenuDialog(null));
+
     // the toast is non-modal: escape only dismisses it when nothing else owns
     // escape, so an open overlay (compose, submit, prompt, walk) still cancels
     if (toastDismissRequested(toast !== null, key, overlay, mode.type === "span"))
       return controller.dismissToast();
+
     if (bareShellDefersKeys(session === null, overlay === "none", focusedPane)) return;
+
     const state = buildKeyState({
       keys: keysRef.current,
       observer,
@@ -1136,6 +1205,7 @@ export function App({
 
   // ── render ──────────────────────────────────
   if (error) return <ErrorScreen error={error} theme={theme} />;
+
   if (!session)
     return inbox ? (
       <SlashSkillsContext.Provider value={skills}>
@@ -1160,8 +1230,10 @@ export function App({
             onFocusPane={setFocusedPane}
             menuControl={menuControl}
             pinnedIds={pinnedIds}
-            onPin={togglePin}
-            onRename={(id, title) => setMode({ type: "renameThread", sessionId: id, text: title })}
+            onPin={enabledThreadAction(canManageThreads, togglePin)}
+            onRename={enabledThreadAction(canManageThreads, (id: string, title: string) =>
+              setMode({ type: "renameThread", sessionId: id, text: title }),
+            )}
             quickActions={quickActions}
             diffView={diffView}
             onWelcomeComposingChange={setWelcomeComposing}
@@ -1229,15 +1301,20 @@ export function App({
     // A share viewer/observer has no Edit affordance (the button is hidden), so
     // this is owner-only; stay silent rather than nag if it is ever reached.
     if (!isOwner) return;
+
     if (resolved) return controller.setStatus("review submitted - read-only");
+
     openBodyEditor();
   };
 
   // clicking the rail Submit button: same read-only answer as the submit key
   const onSubmitRequest = (): void => {
     if (observer) return controller.setStatus("observer - read-only");
+
     if (!isOwner) return controller.setStatus("shared view - your notes save as you go");
+
     if (resolved) return;
+
     dispatch({ type: "openSubmit" });
   };
 
@@ -1285,13 +1362,15 @@ export function App({
                     width={30}
                     onSelect={openThread}
                     onCreateThread={createEmptyThread}
-                    onPin={togglePin}
-                    onRename={(id, title) =>
-                      setMode({ type: "renameThread", sessionId: id, text: title })
-                    }
-                    onRequestDelete={(id, title) =>
-                      setMode({ type: "confirmDelete", sessionId: id, title })
-                    }
+                    onPin={enabledThreadAction(canManageThreads, togglePin)}
+                    onRename={enabledThreadAction(canManageThreads, (id: string, title: string) =>
+                      setMode({ type: "renameThread", sessionId: id, text: title }),
+                    )}
+                    onRequestDelete={enabledThreadAction(
+                      canManageThreads,
+                      (id: string, title: string) =>
+                        setMode({ type: "confirmDelete", sessionId: id, title }),
+                    )}
                     theme={theme}
                   />
                 </scrollbox>
@@ -1618,7 +1697,10 @@ export function App({
   );
 }
 
-function enabledThreadAction(enabled: boolean, action: () => void): (() => void) | undefined {
+function enabledThreadAction<Arguments extends unknown[]>(
+  enabled: boolean,
+  action: (...args: Arguments) => void,
+): ((...args: Arguments) => void) | undefined {
   return enabled ? action : undefined;
 }
 

package/src/app/App.visual.test.tsx

@@ -32,6 +32,7 @@ function hasSpanColor(
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (!span.text.includes(needle) || !span.fg) continue;
+
       const [red, green, blue] = span.fg.toInts();
 
       if (red === color[0] && green === color[1] && blue === color[2]) return true;

package/src/app/App.walk.test.tsx

@@ -88,6 +88,7 @@ function foregroundsOf(setup: Setup, needle: string): string[] {
   for (const line of setup.captureSpans().lines) {
     for (const span of line.spans) {
       if (!span.text.includes(needle)) continue;
+
       const [red, green, blue] = span.fg.toInts();
 
       foregrounds.push(

package/src/app/App.workbench.test.tsx

@@ -244,6 +244,7 @@ describe("the four-pane workbench", () => {
     for (const [index, direction] of Array.from({ length: 500 }, () => "down" as const).entries()) {
       // eslint-disable-next-line no-await-in-loop
       await setup.mockMouse.scroll(75, 10, direction);
+
       if (index % 25 === 0) {
         // eslint-disable-next-line no-await-in-loop
         await setup.waitForVisualIdle();

package/src/app/app-screens.tsx

@@ -175,8 +175,8 @@ export function NoThreadShell(props: {
   /** App owns the one open-menu id, so the bare shell's menus share App's modal keyboard handling. */
   menuControl: MenuControlApi;
   pinnedIds: ReadonlySet<string>;
-  onPin: (id: string) => void;
-  onRename: (id: string, title: string) => void;
+  onPin?: (id: string) => void;
+  onRename?: (id: string, title: string) => void;
   /** Drives the "/" quick actions and skills in the welcome playground's composer. */
   quickActions: QuickAction[];
   diffView: DiffViewMode;
@@ -395,6 +395,7 @@ export function NoThreadShell(props: {
             message={confirming ? `Delete "${confirming.title}"? This removes the thread.` : ""}
             onConfirm={() => {
               if (confirming) controller.deleteSession(confirming.sessionId);
+
               setMode({ type: "normal" });
             }}
             onCancel={() => setMode({ type: "normal" })}

package/src/app/app-view-model.ts

@@ -12,10 +12,13 @@ import type { BreadcrumbItem } from "./components/Breadcrumb";
 export function computeRoleCapabilities(
   readOnly: boolean,
   role: "owner" | "observer" | "collaborator",
+  shared = false,
 ) {
   const observer = readOnly || role === "observer";
 
-  return { observer, isOwner: !observer && role === "owner" };
+  const isOwner = !observer && role === "owner";
+
+  return { observer, isOwner, canManageThreads: isOwner && !shared };
 }
 
 export function deriveReviewFlags(session: Thread | null) {
@@ -49,8 +52,11 @@ export function resolveOverlay(
   walking: boolean,
 ): KeyState["overlay"] {
   if (mode.type === "compose" || mode.type === "railEdit") return "compose";
+
   if (mode.type === "submit") return "submit";
+
   if (mode.type === "confirmDelete") return "confirm";
+
   if (
     mode.type === "rename" ||
     mode.type === "renameThread" ||
@@ -58,9 +64,13 @@ export function resolveOverlay(
     mode.type === "treePrompt"
   )
     return "prompt";
+
   if (mode.type === "spanActions") return "spanActions";
+
   if (completionPhase === "prompt") return "completion-prompt";
+
   if (completionPhase === "counting") return "completion-counting";
+
   if (walking) return "walk";
 
   return "none";

package/src/app/components/WorkspacePanels.tsx

@@ -53,6 +53,7 @@ export function WorkspacePanels(props: {
 
   useKeyboard((key) => {
     if (!props.focused || (key.name !== "[" && key.name !== "]")) return;
+
     const choices = [null, ...views];
     const current = selected ? views.indexOf(selected) + 1 : 0;
     const step = key.name === "]" ? 1 : -1;

package/src/app/intent-dispatch.test.ts

@@ -194,6 +194,7 @@ describe("move", () => {
     const advance = setCursor.mock.calls[0]![0];
 
     if (!isUpdater(advance)) throw new Error("expected setCursor to receive an updater");
+
     expect(advance(2)).toBe(2); // already at the end, stays
     expect(advance(0)).toBe(1);
   });