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

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,14 @@ 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 +465,25 @@ 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/markdown/mark-runs.ts

@@ -38,6 +38,7 @@ export function runsFor(text: string, ranges: MarkRange[]): Run[] {
 
     if (end <= start) continue;
     const covering = ranges.filter((range) => range.start <= start && end <= range.end);
+
     // the caret cell shows through a mark, so the head of a selection is visible
     runs.push({
       text: text.slice(start, end),

package/src/markdown/markdown-highlight.ts

@@ -25,6 +25,7 @@ export interface MarkdownHighlightRange {
 /** The absolute source offset where each 0-based line begins. */
 function lineStartOffsets(source: string): number[] {
   const offsets = [0];
+
   for (let index = 0; index < source.length; index++) {
     if (source[index] === "\n") offsets.push(index + 1);
   }
@@ -39,6 +40,7 @@ const INLINE_TOKEN = /(`+)(?:.+?)\1|\[[^\]]+\]\([^)]+\)/g;
 function scanInlineTokens(text: string, base: number, into: MarkdownHighlightRange[]): void {
   INLINE_TOKEN.lastIndex = 0;
   let match: RegExpExecArray | null;
+
   while ((match = INLINE_TOKEN.exec(text)) !== null) {
     const token = match[0];
     const start = base + match.index;

package/src/performance/otlp-trace.test.ts

@@ -64,6 +64,7 @@ test("phaseMarksToSpans builds a scope root with one child span per phase under
 
   expect(spans).toHaveLength(3);
   const [root, first, second] = spans;
+
   expect(root!.name).toBe("cueloop.startup");
   expect(root!.parentSpanId).toBeUndefined();
   expect(first!.name).toBe("cueloop.startup.renderer");
@@ -82,6 +83,7 @@ test("postOtlpTrace sends no request when the endpoint is unset", async () => {
       return new Response("{}");
     },
   });
+
   try {
     await postOtlpTrace("cueloop-client", [span]);
   } finally {
@@ -101,6 +103,7 @@ test("postOtlpTrace POSTs OTLP JSON to /v1/traces when the endpoint is set", asy
       return new Response("{}");
     },
   });
+
   // a trailing slash must not double up into "//v1/traces"
   process.env.OTEL_EXPORTER_OTLP_ENDPOINT = `http://127.0.0.1:${server.port}/`;
   try {

package/src/performance/otlp-trace.ts

@@ -28,6 +28,7 @@ export interface TraceSpan {
 
 function randomHex(bytes: number): string {
   const buffer = new Uint8Array(bytes);
+
   crypto.getRandomValues(buffer);
 
   return Array.from(buffer, (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -97,6 +98,7 @@ export function phaseMarksToSpans(scope: string, marks: readonly PhaseMark[]): T
   let cursorMs = startMs;
   const children = marks.map((mark) => {
     const phaseStartMs = cursorMs;
+
     cursorMs += mark.elapsedMs;
 
     return {
@@ -118,10 +120,12 @@ export async function postOtlpTrace(
   spans: readonly TraceSpan[],
 ): Promise<void> {
   const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+
   if (endpoint === undefined || spans.length === 0) return;
 
   // strip a trailing slash so an endpoint like "http://host:4318/" does not become "//v1/traces"
   const base = endpoint.replace(/\/+$/, "");
+
   await fetch(`${base}/v1/traces`, {
     method: "POST",
     headers: { "content-type": "application/json" },

package/src/performance/perf-report.ts

@@ -10,6 +10,7 @@ const PERF_SERVICE_NAME = "cueloop-client";
 
 export function reportPerfMarks(scope: string): void {
   const marks = takePerfMarks();
+
   if (marks.length === 0) return;
 
   if (process.env.CUELOOP_PERF === "1") process.stderr.write(formatPerfBlock(scope, marks));

package/src/performance/perf-timings.ts

@@ -18,6 +18,7 @@ function perfInstrumentationEnabled(): boolean {
 export function perfMark(label: string): void {
   if (!perfInstrumentationEnabled()) return;
   const now = performance.now();
+
   phaseMarks.push({ label, elapsedMs: now - (lastMarkAt ?? 0) });
   lastMarkAt = now;
 }

package/src/settings/components/quick-actions-editor.test.tsx

@@ -99,12 +99,15 @@ describe("editing an expanded action", () => {
       />,
       { width: 60, height: 8 },
     );
+
     await settle(setup);
 
     // clicking the title opens the title field; clicking the description opens the metadata field
     const title = locateText(setup, "Ship it");
+
     await setup.mockMouse.click(title.column, title.row);
     const description = locateText(setup, "be terse");
+
     await setup.mockMouse.click(description.column, description.row);
 
     expect(toggles).toEqual([

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 });
+  }
+});

package/src/settings/config.ts

@@ -144,6 +144,8 @@ export interface CueloopConfig {
 export interface ExperimentalConfig {
   /** Render a prototype as a pixel mockup (kitty graphics) instead of the default markdown design doc. */
   prototypePixels: boolean;
+  /** Allow the local session owner to invoke a harness inside the Thread. */
+  threadAgent: boolean;
 }
 
 /** Where a display name came from: typed by the user, or verified from a GitHub login. */
@@ -251,6 +253,7 @@ const ObsidianSchema = v.object({
 const IntegrationsSchema = v.object({ obsidian: v.optional(ObsidianSchema) });
 const ExperimentalSchema = v.object({
   prototype_pixels: v.fallback(v.optional(v.boolean()), undefined),
+  thread_agent: v.fallback(v.optional(v.boolean()), undefined),
 });
 const ReviewSchema = v.object({
   skill: v.fallback(v.optional(v.string()), undefined),
@@ -369,9 +372,7 @@ function layer(
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
   }
-  if (experimental.success && experimental.output.prototype_pixels !== undefined) {
-    out.experimental.prototypePixels = experimental.output.prototype_pixels;
-  }
+  if (experimental.success) applyExperimental(out.experimental, experimental.output);
   if (review.success) applyReview(out.review, review.output);
 
   return out;
@@ -397,7 +398,7 @@ export function loadConfig(
     skillsPath: join(homedir(), ".agents", "skills"),
     review: { skill: "code-review", workspace: "worktree" },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
-    experimental: { prototypePixels: false },
+    experimental: { prototypePixels: false, threadAgent: false },
   };
   // Theme name and per-token overrides are separate concerns, composed once
   // after all layers: the last file to set [ui] theme wins, and every [theme]
@@ -629,3 +630,12 @@ export function persistAuthorName(id: string, name: string, userConfigPath?: str
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
+
+/** Only explicitly configured experimental switches override the preceding layer. */
+function applyExperimental(
+  config: ExperimentalConfig,
+  raw: v.InferOutput<typeof ExperimentalSchema>,
+): void {
+  if (raw.prototype_pixels !== undefined) config.prototypePixels = raw.prototype_pixels;
+  if (raw.thread_agent !== undefined) config.threadAgent = raw.thread_agent;
+}

package/src/stories/__snapshots__/stories.test.tsx.snap

@@ -2282,3 +2282,77 @@ exports[`stories catalog Collaborator Join/JoinSplash renders, snapshots, and ca
                                                                                 
 "
 `;
+
+exports["stories catalog Surfaces/AgentThreadPane/CompletedAnswer renders, snapshots, and carries its colors: Surfaces/AgentThreadPane/CompletedAnswer 1"] = "\n\" Artifact  Agent  fx ready  Tools (1)                                           \nWorkspace: /project                                                             \n                                                                                \n  You                                                                           \n  ──────────────────────────────────────────────────────────────────────        \n                                                                                \n  Why does the retry survive cancellation?                                      \n                                                                                \n  1 tool call · 1 reads · 0 commands                                            \n                                                                                \n  fx                                                                            \n  ──────────────────────────────────────────────────────────────────────        \n                                                                                \n  The timer survives cancellation. Clear it when the request ends.              \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n────────────────────────────────────────────────────────────────────────────────\n Ask fx…  Ctrl+Enter sends · Esc reads · i composes                             \n                                                                                \n Send message (0)                                                               \n\"\n";
+
+exports["stories catalog Surfaces/AgentThreadPane/WaitingPermission renders, snapshots, and carries its colors: Surfaces/AgentThreadPane/WaitingPermission 1"] = "\n\" Artifact  Agent  fx working  Tools (1)  Stop                                   \nWorkspace: /project                                                             \n                                                                                \n  You                                                                           \n  ──────────────────────────────────────────────────────────────────────        \n                                                                                \n  Why does the retry survive cancellation?                                      \n                                                                                \n  1 tool call · 1 reads · 0 commands                                            \n                                                                                \n  fx                                                                            \n  ──────────────────────────────────────────────────────────────────────        \n                                                                                \n  The timer survives cancellation. Clear it when the request ends.              \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n                                                                                \n┌──────────────────────────────────────────────────────────────────────────────┐\n│ Update retry.ts                                                              │\n│ Allow once  Reject once                                                      │\n└──────────────────────────────────────────────────────────────────────────────┘\n────────────────────────────────────────────────────────────────────────────────\n Wait for fx, or stop the tur                                                   \n                                                                                \n Send message (0)                                                               \n\"\n";
+
+exports[`stories catalog Chrome/AgentConfigControls/Choices renders, snapshots, and carries its colors: Chrome/AgentConfigControls/Choices 1`] = `
+"Test model  Medium                      
+                                        
+"
+`;
+
+exports[`stories catalog Surfaces/AgentThreadPane/CompletedAnswer renders, snapshots, and carries its colors: Surfaces/AgentThreadPane/CompletedAnswer 1`] = `
+"                                                                                
+  Keep the retry bounded.                                                       
+                                                                                
+  Why does the retry survive cancellation?                                      
+                                                                                
+  The timer survives cancellation. Clear it when the request ends.              
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+  type to comment · esc for nav mode                                            
+"
+`;
+
+exports[`stories catalog Surfaces/AgentThreadPane/WaitingPermission renders, snapshots, and carries its colors: Surfaces/AgentThreadPane/WaitingPermission 1`] = `
+"                                                                                
+  Keep the retry bounded.                                                       
+                                                                                
+  Why does the retry survive cancellation?                                      
+                                                                                
+  The timer survives cancellation. Clear it when the request ends.              
+  Thinking…                                                                     
+  Update retry.ts                                                               
+  Allow once  Reject once                                                       
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+  type to comment · esc for nav mode                                            
+"
+`;

package/src/stories/stories-app.tsx

@@ -59,6 +59,7 @@ function StoriesApp({ stories, onExit }: StoriesAppProps): React.ReactNode {
   const toggleFolder = (id: string): void => {
     setExpandedIds((current) => {
       const next = new Set(current);
+
       if (next.has(id)) next.delete(id);
       else next.add(id);
 
@@ -73,6 +74,7 @@ function StoriesApp({ stories, onExit }: StoriesAppProps): React.ReactNode {
   const collapseFolder = (id: string): void => {
     setExpandedIds((current) => {
       const next = new Set(current);
+
       next.delete(id);
 
       return next;
@@ -83,6 +85,7 @@ function StoriesApp({ stories, onExit }: StoriesAppProps): React.ReactNode {
     const index = rows.findIndex((row) => row.id === selectedId);
     const nextIndex = Math.max(0, Math.min(rows.length - 1, index + delta));
     const nextRow = rows[nextIndex];
+
     if (nextRow !== undefined) setSelectedId(nextRow.id);
   };
 

package/src/stories/story.ts

@@ -97,6 +97,7 @@ function hoistSingleStoryFolders(nodes: TreeNode[]): TreeNode[] {
     if (node.children === undefined) return node;
     const children = hoistSingleStoryFolders(node.children);
     const onlyChild = children.length === 1 ? children[0] : undefined;
+
     if (
       onlyChild !== undefined &&
       onlyChild.children === undefined &&
@@ -126,6 +127,7 @@ export function buildStoryTree(stories: LoadedStory[]): TreeNode[] {
     for (const segment of [section, ...moduleTitle.split("/")]) {
       path = path === "" ? segment : `${path}/${segment}`;
       let folder = foldersByPath.get(path);
+
       if (folder === undefined) {
         folder = { id: path, label: segment, children: [] };
         foldersByPath.set(path, folder);

package/src/terminal/pty.ts

@@ -228,6 +228,7 @@ class Pty implements IPty {
         this.exitEvent.fire({ exitCode });
       } else {
         const delay = Math.min(READ_IDLE_MAX_MS, READ_IDLE_MS * 2 ** Math.min(idlePolls, 5));
+
         idlePolls += 1;
         await new Promise((resolve) => setTimeout(resolve, delay));
       }

package/src/thread/agent-continuation.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "bun:test";
+import { agentContinuation, type AgentContinuation } from "./agent-continuation";
+import type { ThreadAgentState } from "@cueloop/schema";
+
+const state: ThreadAgentState = {
+  threadId: "thread",
+  phase: { kind: "idle" },
+  messages: [],
+  comments: [],
+  tools: [],
+};
+
+test("only a completed reply in an idle conversation offers continuation", () => {
+  expect(agentContinuation(state)).toEqual({ kind: "waiting" });
+  const message = {
+    id: "answer",
+    role: "agent" as const,
+    text: "Done",
+    complete: true,
+    revision: 1,
+  };
+  const completed: AgentContinuation = agentContinuation({ ...state, messages: [message] });
+
+  expect(completed.kind).toBe("ready");
+  if (completed.kind === "ready") expect(completed.replyId).toBe("answer");
+  expect(agentContinuation({ ...state, phase: { kind: "running" }, messages: [message] })).toEqual({
+    kind: "waiting",
+  });
+  expect(agentContinuation({ ...state, messages: [{ ...message, complete: false }] })).toEqual({
+    kind: "waiting",
+  });
+});

package/src/thread/agent-continuation.ts

@@ -0,0 +1,13 @@
+import type { ThreadAgentState } from "@cueloop/schema";
+
+/** Chat continuation names a completed reply only when the harness has returned to idle. */
+export type AgentContinuation = { kind: "waiting" } | { kind: "ready"; replyId: string };
+
+/** Streaming replies cannot request the next prompt's focus. */
+export function agentContinuation(state: ThreadAgentState): AgentContinuation {
+  const reply = state.messages.findLast((message) => message.role === "agent");
+
+  if (state.phase.kind !== "idle" || !reply?.complete) return { kind: "waiting" };
+
+  return { kind: "ready", replyId: reply.id };
+}