@cueloop/client 0.1.0-alpha.97 → 0.1.0-alpha.98

package/src/app/App.tsx

@@ -35,7 +35,11 @@ import {
   type ThemeName,
 } from "../appearance/theme-presets";
 import type { Theme } from "../appearance/theme";
-import { createReviewController, type ShareTransport } from "../thread/thread-controller";
+import {
+  createReviewController,
+  type ShareTransport,
+  type ReviewController,
+} from "../thread/thread-controller";
 import type { ThreadClient } from "@cueloop/daemon/client";
 import { createIntentDispatch, type Mode, type RailTab } from "./intent-dispatch";
 import { reduceKey, type KeyState } from "../keyboard/keymap";
@@ -62,6 +66,7 @@ import { useThreadBodyEditing } from "../markdown/use-thread-body-editing";
 import { useRememberLayout } from "../workbench/use-remember-layout";
 import type { LaunchLayout } from "./launch-layout";
 import { ThreadFooter, THREAD_FOOTER_HEIGHT } from "../thread/components/ThreadFooter";
+import { AgentThreadPrototype, agentOwnsKeyboard } from "../thread/components/AgentThreadPane";
 import { ConfirmCard } from "../ui/components/ConfirmCard";
 import { THREAD_VIEW_CHEATSHEET, ThreadView } from "../markdown/components/ThreadView";
 import {
@@ -697,11 +702,13 @@ export function App({
   );
   // opt-in: render a prototype as a kitty pixel mockup instead of the markdown doc
   const [prototypePixels, setPrototypePixels] = useState(false);
+  const [threadAgentEnabled, setThreadAgentEnabled] = useState(false);
 
   useEffect(() => {
     const config = loadConfig({ repoRoot: session?.workspace.repoRoot });
 
     setPrototypePixels(config.experimental.prototypePixels);
+    setThreadAgentEnabled(config.experimental.threadAgent);
     keysRef.current = config.keys;
     keyBindings.setKeys(config.keys);
     setTheme(composeTheme(config.ui.theme, config.themeOverrides, appearance));
@@ -849,6 +856,13 @@ export function App({
   // diff sheet: both drive the shared annotation surface; only the pixel prototype keeps the keymap
   const threadViewActive = session !== null && !isPixelPrototype;
   const [threadComposing, setThreadComposing] = useState(false);
+  const [agentActive, setAgentActive] = useState(false);
+  const [agentControls, setAgentControls] = useState<React.ReactNode>(null);
+  const agentActions = useRef<(id: string) => { label: string; run: () => void } | undefined>(
+    () => undefined,
+  );
+  const agentInvoke = useRef<(() => 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
@@ -1020,7 +1034,28 @@ export function App({
     controller.open(id);
   };
 
+  const createEmptyThread = enabledThreadAction(
+    canRunThreadAgent({
+      enabled: threadAgentEnabled,
+      owner: isOwner,
+      editing: false,
+      shared: isSharedThreadConnection(openClient, shareTransport),
+    }),
+    () => {
+      void controller.createEmptyThread();
+      setFocusedPane("thread");
+    },
+  );
+
   const threadSurfaceHandledKey = (key: KeyEvent): boolean => {
+    if (
+      agentOwnsKeyboard(agentActive, focusedPane) &&
+      (key.name === "return" || key.name === "enter") &&
+      key.ctrl &&
+      !key.meta &&
+      !key.super
+    )
+      return true;
     if (!threadViewActive || threadViewSuspended) return false;
     if (!threadComposing) {
       const chord = resolveSessionChord(key, { isOwner, resolved });
@@ -1130,6 +1165,7 @@ export function App({
             rows={grouped.rows}
             inboxCursor={inboxCursor}
             onOpenThread={openThread}
+            onCreateThread={createEmptyThread}
             mode={mode}
             theme={theme}
             controller={controller}
@@ -1225,6 +1261,7 @@ export function App({
 
   const threadFooter = (
     <ThreadFooter
+      controls={threadAgentControls(agentActive, agentControls)}
       repo={projectName(activeSession.workspace)}
       branch={activeSession.workspace.branch}
       onSubmit={onSubmitRequest}
@@ -1265,6 +1302,7 @@ export function App({
                     pinnedIds={pinnedIds}
                     width={30}
                     onSelect={openThread}
+                    onCreateThread={createEmptyThread}
                     onPin={togglePin}
                     onRename={(id, title) =>
                       setMode({ type: "renameThread", sessionId: id, text: title })
@@ -1278,106 +1316,138 @@ export function App({
               }
               threadTitle={reviewThreadTitle(activeSession)}
               threadActions={
-                showOwnerActions
-                  ? ownerThreadActions({
-                      editing: bodyEditing.editing,
-                      onEdit: onEditRequest,
-                      onExitEdit: bodyEditing.requestExit,
-                      onShare: () => dispatch({ type: "share" }),
-                      theme,
-                    })
-                  : showDiffRefresh
-                    ? refreshDiffAction(() => void controller.refreshDiff(), theme)
-                    : undefined
+                <>
+                  {showOwnerActions
+                    ? ownerThreadActions({
+                        editing: bodyEditing.editing,
+                        onEdit: onEditRequest,
+                        onExitEdit: bodyEditing.requestExit,
+                        onShare: () => dispatch({ type: "share" }),
+                        theme,
+                      })
+                    : showDiffRefresh
+                      ? refreshDiffAction(() => void controller.refreshDiff(), theme)
+                      : undefined}
+                </>
               }
               threadPanel={
                 <box style={{ flexGrow: 1, flexDirection: "column" }}>
                   <box style={{ flexGrow: 1, flexDirection: "row" }}>
-                    {chooseThreadBody({
-                      isPixelPrototype,
-                      isDiff,
-                      editingBody: bodyEditing.editing,
-                      prototype: (
-                        <PrototypePixels
-                          prototypePath={prototypePath}
-                          canComment={prototypeCanComment}
-                          onCommentElement={onCommentPrototype}
-                          onComposingChange={setPrototypeComposing}
-                          hidden={chromeHidden}
-                        />
-                      ),
-                      diffPlaceholder: activeSession.artifact.meta.prBrief ? (
-                        <ThreadView
-                          session={pullRequestBriefThread(activeSession)}
-                          display={buildDisplay(activeSession.artifact.meta.prBrief)}
-                          marks={new Map()}
-                          quickActions={quickActions}
-                          suspended={threadViewSuspended}
-                          resolved
-                          observer
-                          onComposingChange={() => {}}
-                          onObserverBlocked={() => {}}
-                          onCursorChange={() => {}}
-                          onAnnotate={() => {}}
-                          onReply={() => {}}
-                          onUpdateAnnotation={() => {}}
-                          resolveAuthorLabel={() => undefined}
-                          onExit={() => onExit?.(0)}
-                        />
-                      ) : (
-                        <box
-                          style={{
-                            flexGrow: 1,
-                            flexDirection: "column",
-                            alignItems: "center",
-                            justifyContent: "center",
-                          }}
-                        >
-                          <text fg={theme.textDim}>Select a thread</text>
-                        </box>
-                      ),
-                      editor: bodyEditing.renderEditor(theme),
-                      threadView: (
-                        <ThreadView
-                          session={activeSession}
-                          suspended={surfaceSuspended(threadViewSuspended, focusedPane, "thread")}
-                          editOrphanCount={editOrphanCount}
-                          onComposingChange={setThreadComposing}
-                          onNavCommand={runNavCommand}
-                          resolved={resolved}
-                          onObserverBlocked={(reason) =>
-                            controller.setStatus(
-                              reason === "observer"
-                                ? "observer - read-only"
-                                : "review submitted - read-only",
-                            )
-                          }
-                          onCursorChange={setCursor}
-                          focusedAnnotationId={focusedAnnotationId}
-                          onFocusAnnotation={setFocusedAnnotationId}
-                          display={display}
-                          marks={marks}
-                          quickActions={quickActions}
-                          observer={observer}
-                          onAnnotate={(span, body) =>
-                            void controller.annotate(
-                              "comment",
-                              span.start.blockIndex,
-                              span.start.char,
-                              span.end.char,
-                              body,
-                              span.end.blockIndex,
-                            )
-                          }
-                          onReply={(rootAnnotationId, body) =>
-                            void controller.reply(rootAnnotationId, body)
-                          }
-                          onUpdateAnnotation={(id, body) => controller.updateAnnotation(id, body)}
-                          resolveAuthorLabel={resolveAuthorLabel}
-                          onExit={() => onExit?.(0)}
-                        />
-                      ),
-                    })}
+                    <AgentThreadPrototype
+                      key={activeSession.id}
+                      enabled={canRunThreadAgent({
+                        enabled: threadAgentEnabled,
+                        owner: isOwner,
+                        editing: bodyEditing.editing,
+                        shared: isSharedThreadConnection(openClient, shareTransport),
+                      })}
+                      observer={observer}
+                      pixelPrototype={isPixelPrototype}
+                      thread={activeSession}
+                      home={home}
+                      theme={theme}
+                      focused={focusedPane === "thread"}
+                      suspended={threadViewSuspended}
+                      onActiveChange={setAgentActive}
+                      onControlsChange={setAgentControls}
+                      onStateChange={setAgentState}
+                      onActionsChange={(actions) => {
+                        agentActions.current = actions;
+                      }}
+                      onInvokeChange={(invoke) => {
+                        agentInvoke.current = invoke;
+                      }}
+                      onRevealReply={() => setFocusedPane("thread")}
+                      flushMutations={() => flushReviewMutations(controller)}
+                      onOpenFile={(path) => workbench.openFile(path, "contents", true)}
+                      onNextPane={cyclePanes}
+                    >
+                      {chooseThreadBody({
+                        isPixelPrototype,
+                        isDiff,
+                        editingBody: bodyEditing.editing,
+                        prototype: (
+                          <PrototypePixels
+                            prototypePath={prototypePath}
+                            canComment={prototypeCanComment}
+                            onCommentElement={onCommentPrototype}
+                            onComposingChange={setPrototypeComposing}
+                            hidden={chromeHidden}
+                          />
+                        ),
+                        diffPlaceholder: activeSession.artifact.meta.prBrief ? (
+                          <ThreadView
+                            session={pullRequestBriefThread(activeSession)}
+                            display={buildDisplay(activeSession.artifact.meta.prBrief)}
+                            marks={new Map()}
+                            quickActions={quickActions}
+                            suspended={threadViewSuspended}
+                            resolved
+                            observer
+                            onComposingChange={() => {}}
+                            onObserverBlocked={() => {}}
+                            onCursorChange={() => {}}
+                            onAnnotate={() => {}}
+                            onReply={() => {}}
+                            onUpdateAnnotation={() => {}}
+                            resolveAuthorLabel={() => undefined}
+                            onExit={() => onExit?.(0)}
+                          />
+                        ) : (
+                          <box
+                            style={{
+                              flexGrow: 1,
+                              flexDirection: "column",
+                              alignItems: "center",
+                              justifyContent: "center",
+                            }}
+                          >
+                            <text fg={theme.textDim}>Select a thread</text>
+                          </box>
+                        ),
+                        editor: bodyEditing.renderEditor(theme),
+                        threadView: (
+                          <ThreadView
+                            session={activeSession}
+                            suspended={surfaceSuspended(threadViewSuspended, focusedPane, "thread")}
+                            editOrphanCount={editOrphanCount}
+                            onComposingChange={setThreadComposing}
+                            onNavCommand={runNavCommand}
+                            resolved={resolved}
+                            onObserverBlocked={(reason) =>
+                              controller.setStatus(
+                                reason === "observer"
+                                  ? "observer - read-only"
+                                  : "review submitted - read-only",
+                              )
+                            }
+                            onCursorChange={setCursor}
+                            focusedAnnotationId={focusedAnnotationId}
+                            onFocusAnnotation={setFocusedAnnotationId}
+                            display={display}
+                            marks={marks}
+                            quickActions={quickActions}
+                            observer={observer}
+                            onAnnotate={(span, body) =>
+                              controller.annotate(
+                                "comment",
+                                span.start.blockIndex,
+                                span.start.char,
+                                span.end.char,
+                                body,
+                                span.end.blockIndex,
+                              )
+                            }
+                            onReply={(rootAnnotationId, body) =>
+                              controller.reply(rootAnnotationId, body)
+                            }
+                            onUpdateAnnotation={(id, body) => controller.updateAnnotation(id, body)}
+                            resolveAuthorLabel={resolveAuthorLabel}
+                            onExit={() => onExit?.(0)}
+                          />
+                        ),
+                      })}
+                    </AgentThreadPrototype>
                   </box>
                   {threadFooter}
                 </box>
@@ -1444,6 +1514,15 @@ export function App({
                         onReply: (rootAnnotationId, body) =>
                           void controller.reply(rootAnnotationId, body),
                         onUpdateAnnotation: (id, body) => controller.updateAnnotation(id, body),
+                        onInvoke: agentActive
+                          ? () => {
+                              agentInvoke.current?.();
+                              setFocusedPane("thread");
+                            }
+                          : undefined,
+                        annotationAction: (id) => agentActions.current(id),
+                        isAnnotationReadOnly: (id) =>
+                          isSubmittedComment(agentState, activeSession.id, id),
                         resolveAuthorLabel,
                         onNavCommand: runNavCommand,
                         onExit: () => onExit?.(0),
@@ -1548,3 +1627,44 @@ export function App({
     </SlashSkillsContext.Provider>
   );
 }
+
+function enabledThreadAction(enabled: boolean, action: () => void): (() => void) | undefined {
+  return enabled ? action : undefined;
+}
+
+/** Experimental agent UI is available only in a local owner's review. */
+export function canRunThreadAgent(options: {
+  enabled: boolean;
+  owner: boolean;
+  editing: boolean;
+  shared: boolean;
+}): boolean {
+  return options.enabled && options.owner && !options.editing && !options.shared;
+}
+
+function isSubmittedComment(
+  state: import("@cueloop/schema").ThreadAgentState | undefined,
+  threadId: string,
+  commentId: string,
+): boolean {
+  return (
+    state?.threadId === threadId &&
+    Boolean(state.submissions?.some((entry) => entry.commentId === commentId))
+  );
+}
+
+function flushReviewMutations(controller: ReviewController): Promise<void> {
+  return controller.flushMutations?.() ?? Promise.resolve();
+}
+
+function threadAgentControls(active: boolean, controls: React.ReactNode): React.ReactNode {
+  return active ? controls : undefined;
+}
+
+/** Injected shared transports never own a local harness connection. */
+function isSharedThreadConnection(
+  openClient: AppProps["openClient"],
+  shareTransport: ShareTransport | undefined,
+): boolean {
+  return Boolean(openClient || shareTransport);
+}

package/src/app/app-screens.tsx

@@ -160,6 +160,7 @@ export function NoThreadShell(props: {
   inboxCursor: number;
   /** Open a sidebar thread and move the cursor onto it, so the row shows its selected backdrop at once. */
   onOpenThread: (id: string) => void;
+  onCreateThread?: () => void;
   mode: Mode;
   theme: Theme;
   controller: ReviewController;
@@ -291,6 +292,7 @@ export function NoThreadShell(props: {
                 pinnedIds={pinnedIds}
                 width={30}
                 onSelect={onOpenThread}
+                onCreateThread={props.onCreateThread}
                 onRequestDelete={(id, title) =>
                   setMode({ type: "confirmDelete", sessionId: id, title })
                 }

package/src/app/components/AppShell.zoom.test.tsx

@@ -13,7 +13,7 @@ import { AppShell } from "./AppShell";
 import { EditorGrid } from "../../workbench/components/EditorGrid";
 import { changesTab, makeGroup, splitGroup } from "../../workbench/components/editor-grid";
 import { NERD } from "../../ui/components/primitives/icons";
-import { allowEventLoopUpdates } from "../../testing/test-support";
+import { allowEventLoopUpdates, settle } from "../../testing/test-support";
 
 const grid = makeGroup([changesTab()]);
 
@@ -59,8 +59,9 @@ async function zoomIconColumn(
     { width, height: 8 },
   );
 
-  allowEventLoopUpdates();
-  await setup.waitForVisualIdle();
+  // Split widths commit through React after the frame measurement. Renderer idle alone
+  // can still expose the initial fractional split, before its whole-cell widths land.
+  await settle(setup);
   const column = setup.captureCharFrame().split("\n")[0]!.indexOf(NERD.zoom);
 
   setup.renderer.destroy();

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

@@ -62,6 +62,7 @@ const EMPTY_SNAPSHOT: ControllerSnapshot = {
 function baseController(): ReviewController {
   return {
     readOnly: false,
+    createEmptyThread: mock(async () => {}),
     subscribe: mock(() => () => {}),
     getSnapshot: mock(() => EMPTY_SNAPSHOT),
     connect: mock(),

package/src/diff/components/AnnotatableFileView.tsx

@@ -34,6 +34,9 @@ export interface AnnotatableFileViewProps {
   onAddComment: (anchor: Anchor, body: string) => void;
   onReply: (rootAnnotationId: string, body: string) => void;
   onUpdateAnnotation: (id: string, body: string) => void;
+  onInvoke?: () => void;
+  annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
+  isAnnotationReadOnly?: (id: string) => boolean;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   onExit: () => void;
   theme?: Theme;
@@ -126,6 +129,9 @@ export function AnnotatableFileView(props: AnnotatableFileViewProps): React.Reac
       }
       onReply={props.onReply}
       onUpdateAnnotation={props.onUpdateAnnotation}
+      onInvoke={props.onInvoke}
+      isAnnotationReadOnly={props.isAnnotationReadOnly}
+      annotationAction={props.annotationAction}
       resolveAuthorLabel={props.resolveAuthorLabel}
       onExit={props.onExit}
       theme={props.theme}

package/src/diff/components/DiffContentView.tsx

@@ -98,6 +98,9 @@ export interface DiffContentViewProps {
   onAnnotate: (span: TextSpan, body: string) => void;
   onReply: (rootAnnotationId: string, body: string) => void;
   onUpdateAnnotation: (id: string, body: string) => void;
+  onInvoke?: () => void;
+  annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
+  isAnnotationReadOnly?: (id: string) => boolean;
   /** The author's display name for a comment's hover tooltip. */
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   onNavCommand?: (key: KeyEvent, selection: TextSpan | null) => boolean;
@@ -542,6 +545,9 @@ export function DiffContentView({
   onAnnotate,
   onReply,
   onUpdateAnnotation,
+  onInvoke,
+  isAnnotationReadOnly,
+  annotationAction,
   resolveAuthorLabel,
   onNavCommand,
   onExit,
@@ -610,6 +616,9 @@ export function DiffContentView({
     onAnnotate,
     onReply,
     onUpdateAnnotation,
+    onInvoke,
+    isAnnotationReadOnly,
+    annotationAction,
     dragViewport: () => scrollBoxDragViewport(scrollRef.current),
     resolveAuthorLabel: (annotation) => {
       const label = resolveAuthorLabel?.(annotation);

package/src/markdown/components/ThreadView.tsx

@@ -36,7 +36,12 @@ import { wrapLines, type MarkRange, type VisualLine } from "../mark-runs";
 import { MarkdownGridBlock } from "./MarkdownGridBlock";
 import { useFrameMeasure } from "../../ui/use-frame-measure";
 import { scrollBoxDragViewport, useTerminalVirtualizer } from "../../ui/use-terminal-virtualizer";
-import { useAnnotationSurface, type LineSource } from "../../annotations/use-annotation-surface";
+import {
+  useAnnotationSurface,
+  type LineSource,
+  type PromptFocusRequest,
+  type PromptRestoreRequest,
+} from "../../annotations/use-annotation-surface";
 import { NavModeHint } from "../../keyboard/components/NavModeHint";
 import { DiscussionMarkerRail } from "../../annotations/components/DiscussionMarkerRail";
 import { useComponentTheme } from "../../appearance/components/theme-context";
@@ -150,6 +155,17 @@ export const THREAD_VIEW_CHEATSHEET: CheatsheetSection[] = [
 ];
 
 export interface ThreadViewProps {
+  /** Agent transcripts permit feedback only on finalized answer blocks. */
+  canAnnotateBlock?: (blockIndex: number) => boolean;
+  isAnnotationReadOnly?: (id: string) => boolean;
+  annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
+  requestedBlock?: { blockIndex: number };
+  onInvoke?: () => void;
+  /** The final prompt line uses a plain composer instead of a comment card. */
+  isPromptBlock?: (blockIndex: number) => boolean;
+  promptFocusRequest?: PromptFocusRequest;
+  promptRestoreRequest?: PromptRestoreRequest;
+  renderBlock?: (index: number) => React.ReactNode | undefined;
   session: Thread;
   display: DisplayBlock[];
   marks: Map<number, Mark[]>;
@@ -202,13 +218,22 @@ export function ThreadView({
   onNavCommand,
   onExit,
   theme,
+  canAnnotateBlock,
+  isAnnotationReadOnly,
+  annotationAction,
+  requestedBlock,
+  onInvoke,
+  isPromptBlock,
+  promptFocusRequest,
+  promptRestoreRequest,
+  renderBlock,
 }: ThreadViewProps): React.ReactNode {
   const tokens = useComponentTheme(theme);
   const source: LineSource = {
     count: display.length,
     // the surface hit-tests and paints in rendered text (inline markers concealed); a grid anchors on its raw source
     textAt: (blockIndex) => renderedText(display[blockIndex]!),
-    annotatable: () => true,
+    annotatable: canAnnotateBlock ?? (() => true),
   };
   const scrollRef = useRef<ScrollBoxRenderable | null>(null);
   const surface = useAnnotationSurface({
@@ -228,6 +253,13 @@ export function ThreadView({
     onAnnotate,
     onReply,
     onUpdateAnnotation,
+    isAnnotationReadOnly,
+    annotationAction,
+    requestedBlock,
+    onInvoke,
+    isPromptBlock,
+    promptFocusRequest,
+    promptRestoreRequest,
     dragViewport: () => scrollBoxDragViewport(scrollRef.current),
     resolveAuthorLabel,
     onNavCommand,
@@ -316,7 +348,7 @@ export function ThreadView({
     </span>
   );
 
-  const lineRowFor = (context: LineContext): React.ReactNode => {
+  const lineRowFor = (context: LineContext, hasComposer = false): React.ReactNode => {
     const {
       blockIndex,
       roleRuns,
@@ -329,6 +361,9 @@ export function ThreadView({
       syntaxSpans,
     } = context;
 
+    // The prompt composer occupies its blank line instead of adding a row below it.
+    if (isPromptBlock?.(blockIndex) && hasComposer) return null;
+
     return (
       <box key={`line-${lineIndex}`} style={{ flexDirection: "row" }}>
         <text selectable={false}>
@@ -366,6 +401,13 @@ export function ThreadView({
   };
 
   const blockNodeFor = (blockIndex: number): React.ReactNode => {
+    const custom = renderBlock?.(blockIndex);
+    if (custom !== undefined)
+      return (
+        <box key={`custom-${blockIndex}`} ref={virtual.measureRef(blockIndex)}>
+          {custom}
+        </box>
+      );
     const block = display[blockIndex]!;
     const { baseFg, baseAttributes, marker } = blockStyle(block, tokens);
     // list items of one list stay tight; every other block sits a blank row below its neighbour
@@ -422,22 +464,24 @@ export function ThreadView({
       const line = lines[lineIndex]!;
       const isLastLine = lineIndex === lines.length - 1;
 
+      const cards = surface.cardsAfterLine(blockIndex, line, isLastLine);
       lineRows.push(
-        lineRowFor({
-          blockIndex,
-          roleRuns,
-          line,
-          lineIndex,
-          ranges,
-          marker,
-          baseFg,
-          baseAttributes,
-          syntaxSpans,
-        }),
+        lineRowFor(
+          {
+            blockIndex,
+            roleRuns,
+            line,
+            lineIndex,
+            ranges,
+            marker,
+            baseFg,
+            baseAttributes,
+            syntaxSpans,
+          },
+          cards.length > 0,
+        ),
       );
       if (isLastLine) lineRows.push(headingRule(block));
-      const cards = surface.cardsAfterLine(blockIndex, line, isLastLine);
-
       lineRows.push(...cards);
       if (cards.length > 0 && !isLastLine) {
         lineRows.push(<box key={`gap-${lineIndex}`} style={{ height: 1 }} />);

package/src/settings/config.test.ts

@@ -659,3 +659,18 @@ describe("the /lgtm default quick action", () => {
     expect(quickActionBody(lgtm!)).toBe("LGTM\n\nThis looks good to me.");
   });
 });
+
+test("Thread agents default off and require a boolean experimental TOML flag", () => {
+  const dir = mkdtempSync(join(tmpdir(), "cueloop-agent-config-"));
+  const path = join(dir, "config.toml");
+
+  try {
+    expect(loadConfig({ userConfigPath: path }).experimental.threadAgent).toBe(false);
+    writeFileSync(path, "[experimental]\nthread_agent = true\n");
+    expect(loadConfig({ userConfigPath: path }).experimental.threadAgent).toBe(true);
+    writeFileSync(path, '[experimental]\nthread_agent = "true"\n');
+    expect(loadConfig({ userConfigPath: path }).experimental.threadAgent).toBe(false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});