@cueloop/client 0.1.0-alpha.69 → 0.1.0-alpha.70

package/src/{session-controller.share.test.ts → thread-controller.share.test.ts}

@@ -1,17 +1,17 @@
 import { beforeEach, describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
-import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
 import {
   createReviewController,
   SHARE_RECONNECT_MAX_MS,
   SHARE_RECONNECT_MIN_MS,
   type ShareTransport,
-} from "./session-controller";
+} from "./thread-controller";
 import { mergeFromShare, type ShareWatchHandlers } from "./share";
 
 const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
-let remote: ReviewSession;
+let remote: Thread;
 const pullShare = mock(async () => remote);
 const pushShare = mock(
   async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
@@ -27,7 +27,7 @@ const shareTransport: ShareTransport = {
   mergeFromShare,
 };
 
-function sessionFixture(overrides: Partial<ReviewSession> = {}): ReviewSession {
+function sessionFixture(overrides: Partial<Thread> = {}): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
@@ -54,19 +54,20 @@ function annotation(id: string, author: string): Annotation {
 }
 
 interface FakeSessionClient extends SessionClient {
-  sessionAnnotate: Mock<SessionClient["sessionAnnotate"]>;
+  sessionComment: Mock<SessionClient["sessionComment"]>;
 }
 
 const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
-function fakeClient(session: ReviewSession): FakeSessionClient {
+function fakeClient(session: Thread): FakeSessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
-    sessionAnnotate: mock<SessionClient["sessionAnnotate"]>(async () => session),
+    sessionComment: mock<SessionClient["sessionComment"]>(async () => session),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
     sessionCutBlock: unimplemented("sessionCutBlock"),
@@ -100,7 +101,7 @@ function fakeClient(session: ReviewSession): FakeSessionClient {
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 
 async function connectedController(
-  session: ReviewSession,
+  session: Thread,
   clock?: ManualClock,
   transport: ShareTransport = shareTransport,
 ): Promise<{ controller: ReturnType<typeof createReviewController>; client: FakeSessionClient }> {
@@ -233,7 +234,7 @@ describe("mirror on annotate", () => {
       sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
     );
 
-    client.sessionAnnotate.mockImplementationOnce(async () => {
+    client.sessionComment.mockImplementationOnce(async () => {
       throw new Error("session is resolved");
     });
 
@@ -259,7 +260,7 @@ describe("reply", () => {
     await tick();
 
     // Assert
-    const wire = client.sessionAnnotate.mock.calls.at(-1)![1];
+    const wire = client.sessionComment.mock.calls.at(-1)![1];
 
     expect(wire).toEqual({
       id: id!,
@@ -287,7 +288,7 @@ describe("reply", () => {
     await tick();
 
     // Assert
-    expect(client.sessionAnnotate.mock.calls.at(-1)?.[1]).toMatchObject({
+    expect(client.sessionComment.mock.calls.at(-1)?.[1]).toMatchObject({
       id: "a2",
       body: "revised reply",
       replyTo: "a1",
@@ -310,7 +311,7 @@ describe("reply", () => {
     await tick();
 
     // Assert
-    expect(client.sessionAnnotate.mock.calls.at(-1)?.[1]).toMatchObject({ replyTo: "a1" });
+    expect(client.sessionComment.mock.calls.at(-1)?.[1]).toMatchObject({ replyTo: "a1" });
   });
 
   test("replying to an unknown annotation does nothing", async () => {
@@ -319,7 +320,7 @@ describe("reply", () => {
 
     // Act + Assert
     expect(controller.reply("missing", "x")).toBeUndefined();
-    expect(client.sessionAnnotate).not.toHaveBeenCalled();
+    expect(client.sessionComment).not.toHaveBeenCalled();
   });
 });
 

package/src/{session-controller.tree.test.ts → thread-controller.tree.test.ts}

@@ -12,10 +12,10 @@ import {
   SCHEMA_VERSION,
   switchBranch,
   type Annotation,
-  type ReviewSession,
+  type Thread,
 } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
-import { createReviewController, type ShareTransport } from "./session-controller";
+import { createReviewController, type ShareTransport } from "./thread-controller";
 import { mergeFromShare } from "./share";
 
 const AT = "2026-01-01T00:00:00.000Z";
@@ -31,8 +31,8 @@ function annotation(id: string, body: string): Annotation {
 }
 
 /** A plan with one comment on main and its history. */
-function sessionFixture(): ReviewSession {
-  const session: ReviewSession = {
+function sessionFixture(): Thread {
+  const session: Thread = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
     workspace: { repoRoot: "/repo", branch: "main" },
@@ -49,7 +49,7 @@ function sessionFixture(): ReviewSession {
   return session;
 }
 
-const publish = mock(async (session: ReviewSession) => ({
+const publish = mock(async (session: Thread) => ({
   line: `ssh p_${session.id}@cueloop.dev`,
   copied: true,
 }));
@@ -67,14 +67,15 @@ const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
 /** Tree requests never resolve here: what the controller shows is its own guess. */
-const pending = () => new Promise<ReviewSession>(() => {});
+const pending = () => new Promise<Thread>(() => {});
 
-function fakeClient(session: ReviewSession) {
+function fakeClient(session: Thread) {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
+    sessionComment: unimplemented("sessionComment"),
     sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),

package/src/{session-controller.ts → thread-controller.ts}

@@ -30,7 +30,7 @@ import {
   type Annotation,
   type AnnotationTarget,
   type DiffFileContents,
-  type ReviewSession,
+  type Thread,
   type SessionHistory,
   type VerdictKind,
 } from "@cueloop/schema";
@@ -124,8 +124,8 @@ function planCutId(base: { lineStart: number; lineEnd: number }): string {
 }
 
 export interface ControllerSnapshot {
-  session: ReviewSession | null;
-  inbox: ReviewSession[] | null;
+  session: Thread | null;
+  inbox: Thread[] | null;
   status: string;
   toast: ToastState | null;
   error: string | null;
@@ -360,7 +360,7 @@ class Controller implements ReviewController {
   private shareStop: (() => void) | null = null;
   private shareRun: object | null = null;
   /** Projections keyed by session identity (and the live diff for non-diff threads) so renders reuse one computation. */
-  private derivedFor: ReviewSession | null = null;
+  private derivedFor: Thread | null = null;
   /** The launch/workspace repo's live working-tree diff, feeding the Changes view for non-diff threads. */
   private liveDiff: LiveWorkingDiff | null = null;
   private derivedForLiveDiff: LiveWorkingDiff | null = null;
@@ -661,7 +661,7 @@ class Controller implements ReviewController {
   }
 
   /** Optimistic apply: the daemon response is the next session snapshot. */
-  private apply(mutation: Promise<ReviewSession>): void {
+  private apply(mutation: Promise<Thread>): void {
     mutation
       .then((session) => this.update({ session }))
       .catch((cause: unknown) =>
@@ -674,7 +674,7 @@ class Controller implements ReviewController {
    * builds on the first instead of on the stale snapshot. Answers arrive in
    * request order over the socket and replace the guess with the daemon's copy.
    */
-  private applyOptimistic(expected: ReviewSession, mutation: Promise<ReviewSession>): void {
+  private applyOptimistic(expected: Thread, mutation: Promise<Thread>): void {
     this.update({ session: expected });
     mutation
       .then((session) => this.update({ session }))
@@ -762,7 +762,7 @@ class Controller implements ReviewController {
     );
 
     if (baseIndex === -1) return;
-    const expected: ReviewSession = {
+    const expected: Thread = {
       ...session,
       workingCopy: restoreBlock(base, working, block.base, line),
     };
@@ -847,7 +847,7 @@ class Controller implements ReviewController {
     const session = this.snapshot.session;
 
     if (!session) return;
-    const expected: ReviewSession = { ...session, curation: rejections };
+    const expected: Thread = { ...session, curation: rejections };
 
     if (!rejections.length) delete expected.curation;
     this.applyOptimistic(expected, this.client!.sessionCurate(session.id, rejections));
@@ -980,7 +980,7 @@ class Controller implements ReviewController {
    * resolving stay stored (the feedback serializer flags orphaned anchors);
    * the count feeds the one-line banner above the sheet.
    */
-  private reconcileAnnotations(session: ReviewSession, editedContent: string): void {
+  private reconcileAnnotations(session: Thread, editedContent: string): void {
     const editedBlocks = parseBlocks(editedContent);
     const orphanCount = session.annotations.filter(
       (annotation) => resolveAnchor(annotation.anchor, editedBlocks) === null,
@@ -1049,7 +1049,7 @@ class Controller implements ReviewController {
       resolvedTarget.kind === "artifact"
         ? { id: newAnnotationId(), kind, anchor, body }
         : { id: newAnnotationId(), kind, anchor, body, target: resolvedTarget };
-    const persisted = this.client!.sessionAnnotate(session.id, wire);
+    const persisted = this.client!.sessionComment(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
@@ -1065,7 +1065,7 @@ class Controller implements ReviewController {
       target.kind === "artifact"
         ? { id: newAnnotationId(), kind: "comment", anchor, body }
         : { id: newAnnotationId(), kind: "comment", anchor, body, target };
-    const persisted = this.client!.sessionAnnotate(session.id, wire);
+    const persisted = this.client!.sessionComment(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
@@ -1108,7 +1108,7 @@ class Controller implements ReviewController {
       replyTo: root.replyTo ?? root.id,
     };
     const wire = root.target ? { ...base, target: root.target } : base;
-    const persisted = this.client!.sessionAnnotate(session.id, wire);
+    const persisted = this.client!.sessionComment(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
@@ -1122,7 +1122,7 @@ class Controller implements ReviewController {
     if (!session) return undefined;
     const anchor = { quote, prefix: "", suffix: "", selector };
     const wire = { id: newAnnotationId(), kind: "comment", anchor, body };
-    const persisted = this.client!.sessionAnnotate(session.id, wire);
+    const persisted = this.client!.sessionComment(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
@@ -1147,7 +1147,7 @@ class Controller implements ReviewController {
     };
 
     if (existing.replyTo !== undefined) wire.replyTo = existing.replyTo;
-    const persisted = this.client!.sessionAnnotate(session.id, wire);
+    const persisted = this.client!.sessionComment(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
@@ -1156,7 +1156,7 @@ class Controller implements ReviewController {
 
   // push only after the local write lands, so a rejected write never leaks to the share
   private mirrorAnnotation(
-    persisted: Promise<ReviewSession>,
+    persisted: Promise<Thread>,
     annotation: Omit<Annotation, "createdAt">,
   ): void {
     const session = this.snapshot.session;
@@ -1391,12 +1391,8 @@ class Controller implements ReviewController {
    * Show a moved tree at once - the record re-derived from its new path - and
    * let the daemon's answer replace it. A refused move surfaces as status.
    */
-  private moveTree(
-    session: ReviewSession,
-    history: SessionHistory,
-    request: () => Promise<ReviewSession>,
-  ): void {
-    const expected: ReviewSession = { ...session, history };
+  private moveTree(session: Thread, history: SessionHistory, request: () => Promise<Thread>): void {
+    const expected: Thread = { ...session, history };
 
     applyPathView(
       expected,
@@ -1421,7 +1417,7 @@ class Controller implements ReviewController {
       .catch(() => {});
   }
 
-  private mergeShared(remote: ReviewSession): Promise<void> {
+  private mergeShared(remote: Thread): Promise<void> {
     const session = this.snapshot.session;
 
     if (!session || !this.client) return Promise.resolve();

package/src/use-annotation-surface.tsx

@@ -12,10 +12,10 @@
  * cards this hook builds under the visual line a span ends on.
  */
 
-import React, { useEffect, useRef, useState } from "react";
+import React, { useContext, useEffect, useRef, useState } from "react";
 import type { KeyEvent, MouseEvent as TerminalMouseEvent, TextRenderable } from "@opentui/core";
 import { useKeyboard } from "@opentui/react";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import type { Mark } from "./view-plan";
 import type { QuickAction } from "./config";
 import type { Theme } from "./theme";
@@ -37,7 +37,13 @@ import {
 } from "./thread-selection";
 import { annotationPaletteFor, type AnnotationPalette } from "./annotation-palette";
 import { printableSequence, type MarkRange, type VisualLine } from "./mark-runs";
-import { resolveInlineSuggestion, slashFilter, slashItemsFrom } from "./slash-palette";
+import {
+  mergeSlashItems,
+  resolveInlineSuggestion,
+  slashFilter,
+  slashItemsFrom,
+} from "./slash-palette";
+import { SlashSkillsContext } from "./skills";
 import { discussionsFrom, type Discussion } from "./discussions";
 import {
   CommentRow,
@@ -68,7 +74,7 @@ export interface ComposeState {
 
 export interface AnnotationSurfaceOptions {
   source: LineSource;
-  session: ReviewSession;
+  session: Thread;
   marks: Map<number, Mark[]>;
   quickActions: QuickAction[];
   tokens: Theme;
@@ -305,14 +311,12 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     setCompose(null);
     setComposeText("");
   };
+  const skills = useContext(SlashSkillsContext);
+  const paletteItems = mergeSlashItems(slashItemsFrom(quickActions), skills);
   // open only while typing the token: a leading "/" with no space yet
   const slashActive = compose !== null && /^\/\S*$/.test(composeText);
-  const slashItems = slashActive
-    ? slashFilter(slashItemsFrom(quickActions), composeText.slice(1).trim())
-    : [];
-  // inline skill completion: the trailing "/word" token and its closest match,
-  // offered as a hint below the composer that tab completes to the full name
-  const inlineSlash = resolveInlineSuggestion(slashActive, composeText, quickActions);
+  const slashItems = slashActive ? slashFilter(paletteItems, composeText.slice(1).trim()) : [];
+  const inlineSlash = resolveInlineSuggestion(slashActive, composeText, paletteItems);
 
   const saveComment = (body: string): void => {
     // the body saves verbatim - typed newlines are the author's choice;

package/src/view-diff.ts

@@ -12,7 +12,7 @@ import {
   resolveAnchor,
   type Annotation,
   type Block,
-  type ReviewSession,
+  type Thread,
 } from "@cueloop/schema";
 import { spanRangeInBlock, type TextSpan } from "./thread-selection";
 import type { Mark } from "./view-plan";
@@ -253,7 +253,7 @@ export function fileTargetMarks(
  * replies) toward the file its span ends in. Feeds the changed-files tree and tab badges, so a
  * file whose tab is closed still shows it carries feedback.
  */
-export function commentCountsByFile(session: ReviewSession, rows: DiffRow[]): Map<string, number> {
+export function commentCountsByFile(session: Thread, rows: DiffRow[]): Map<string, number> {
   const discussions = discussionsFrom(session, marksByRows(session.annotations, rows));
   const counts = new Map<string, number>();