@cueloop/client 0.1.0-alpha.79 → 0.1.0-alpha.80

package/src/intent-dispatch.ts

@@ -8,14 +8,14 @@
  */
 
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
-import { isAddressed, type Thread, type VerdictKind } from "@cueloop/schema";
+import { isAddressed, type Thread, type MessageOutcome } from "@cueloop/schema";
 import { displayText, spanKey, startSpan, type DisplayBlock, type SpanState } from "./view-plan";
 import type { DiffRow } from "./view-diff";
 import type { ReviewController } from "./thread-controller";
 import type { Intent } from "./keymap";
 import type { TreeRow } from "./tree-view";
 import { quickActionBody, type QuickAction } from "./config";
-import { VERDICTS } from "./components/ConfirmCard";
+import { MESSAGE_OUTCOMES } from "./components/ConfirmCard";
 
 /** Which pane of the session tree / review the keyboard grammar is aimed at. */
 export type RailTab = "review" | "tree";
@@ -34,7 +34,7 @@ export type Mode =
       text: string;
     }
   | { type: "railEdit"; id: string; text: string }
-  | { type: "submit"; verdict: VerdictKind; summary: string }
+  | { type: "submit"; message: MessageOutcome; summary: string }
   | { type: "confirmDelete"; sessionId: string; title: string }
   | { type: "rename"; authorId: string; text: string }
   | { type: "renameThread"; sessionId: string; text: string }
@@ -68,7 +68,7 @@ export interface IntentDispatchDeps {
   inboxCursor: number;
   mode: Mode;
   session: Thread | null;
-  defaultVerdict: VerdictKind;
+  defaultMessage: MessageOutcome;
   focusedAnnotationId: string | undefined;
   /** The curation item selected for undo, if any. */
   selectedCurationId: string | undefined;
@@ -368,7 +368,7 @@ function handleOpenSubmit(_intent: IntentOfType<"openSubmit">, deps: IntentDispa
 
   if (!session) return;
   deps.liveInput.current = "";
-  deps.setMode({ type: "submit", verdict: deps.defaultVerdict, summary: "" });
+  deps.setMode({ type: "submit", message: deps.defaultMessage, summary: "" });
 }
 
 // share opens the share dialog; it owns its own keys, links list, and publish wizard
@@ -524,24 +524,25 @@ function handleSaveCompose(_intent: IntentOfType<"saveCompose">, deps: IntentDis
   deps.setMode({ type: "normal" });
 }
 
-function handleSubmitVerdict(
-  _intent: IntentOfType<"submitVerdict">,
+function handleSubmitMessage(
+  _intent: IntentOfType<"submitMessage">,
   deps: IntentDispatchDeps,
 ): void {
   const { mode } = deps;
 
-  if (mode.type === "submit") deps.controller.submit(mode.verdict, deps.liveInput.current);
+  if (mode.type === "submit") deps.controller.submit(mode.message, deps.liveInput.current);
   deps.setMode({ type: "normal" });
 }
 
-function handleCycleVerdict(intent: IntentOfType<"cycleVerdict">, deps: IntentDispatchDeps): void {
+function handleCycleMessage(intent: IntentOfType<"cycleMessage">, deps: IntentDispatchDeps): void {
   const { mode } = deps;
 
   if (mode.type !== "submit") return;
-  const verdictIndex =
-    (VERDICTS.indexOf(mode.verdict) + intent.direction + VERDICTS.length) % VERDICTS.length;
+  const messageIndex =
+    (MESSAGE_OUTCOMES.indexOf(mode.message) + intent.direction + MESSAGE_OUTCOMES.length) %
+    MESSAGE_OUTCOMES.length;
 
-  deps.setMode({ ...mode, verdict: VERDICTS[verdictIndex]! });
+  deps.setMode({ ...mode, message: MESSAGE_OUTCOMES[messageIndex]! });
 }
 
 function handleFinishReview(_intent: IntentOfType<"finishReview">, deps: IntentDispatchDeps): void {
@@ -664,8 +665,8 @@ const intentHandlers: IntentHandlers = {
   deselect: handleDeselect,
   closeOverlay: handleCloseOverlay,
   saveCompose: handleSaveCompose,
-  submitVerdict: handleSubmitVerdict,
-  cycleVerdict: handleCycleVerdict,
+  submitMessage: handleSubmitMessage,
+  cycleMessage: handleCycleMessage,
   finishReview: handleFinishReview,
   optInAutoClose: handleOptInAutoClose,
   dismissCompletion: handleDismissCompletion,

package/src/key-bindings.test.ts

@@ -63,14 +63,14 @@ describe("mode layers own their keys", () => {
     expect(resolver.resolveAction({ name: "j", shift: false })).toBeUndefined();
   });
 
-  test("the submit overlay adds the verdict arrows", () => {
+  test("the submit overlay adds the message arrows", () => {
     // Arrange
     const resolver = bindings({ overlay: "submit" });
 
     // Assert
-    expect(resolver.resolveAction({ name: "left", shift: false })).toBe("cycle_verdict_left");
-    expect(resolver.resolveAction({ name: "right", shift: false })).toBe("cycle_verdict_right");
-    expect(resolver.resolveAction({ name: "return", shift: false })).toBe("submit_verdict");
+    expect(resolver.resolveAction({ name: "left", shift: false })).toBe("cycle_outcome_left");
+    expect(resolver.resolveAction({ name: "right", shift: false })).toBe("cycle_outcome_right");
+    expect(resolver.resolveAction({ name: "return", shift: false })).toBe("send_message");
   });
 
   test("the walk overlay owns the bracket stepping and leaves the grammar keys dead", () => {

package/src/key-bindings.ts

@@ -58,7 +58,7 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
     { commands: ["submit"], label: "submit" },
     { commands: ["quit"], label: "quit" },
   ],
-  // A share viewer: annotate and navigate, no plan edit / verdict submit.
+  // A share viewer: annotate and navigate, no plan edit / message submit.
   collaborator: [
     { commands: ["down", "up"], label: "move" },
     { commands: ["span"], label: "span" },
@@ -90,11 +90,11 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
   ],
   submit: [
     {
-      commands: ["cycle_verdict_left", "cycle_verdict_right"],
+      commands: ["cycle_outcome_left", "cycle_outcome_right"],
       label: "decision",
       labelFirst: true,
     },
-    { commands: ["submit_verdict"], label: "submit" },
+    { commands: ["send_message"], label: "submit" },
     { commands: ["cancel_submit"], label: "cancel" },
   ],
   walk: [
@@ -329,16 +329,16 @@ export class KeyBindings {
       priority: 20,
       when: () => this.context.overlay === "submit",
       bindings: [
-        { key: "return", cmd: "submit_verdict" },
-        { key: "enter", cmd: "submit_verdict" },
-        { key: "left", cmd: "cycle_verdict_left" },
-        { key: "right", cmd: "cycle_verdict_right" },
+        { key: "return", cmd: "send_message" },
+        { key: "enter", cmd: "send_message" },
+        { key: "left", cmd: "cycle_outcome_left" },
+        { key: "right", cmd: "cycle_outcome_right" },
         { key: "escape", cmd: "cancel_submit" },
       ],
       commands: [
-        record("submit_verdict"),
-        record("cycle_verdict_left"),
-        record("cycle_verdict_right"),
+        record("send_message"),
+        record("cycle_outcome_left"),
+        record("cycle_outcome_right"),
         record("cancel_submit"),
       ],
     });

package/src/keymap.test.ts

@@ -61,8 +61,8 @@ describe("submit overlay", () => {
     ["escape", [{ type: "closeOverlay" }]],
     ["return", []],
     ["enter", []],
-    ["left", [{ type: "cycleVerdict", direction: -1 }]],
-    ["right", [{ type: "cycleVerdict", direction: 1 }]],
+    ["left", [{ type: "cycleMessage", direction: -1 }]],
+    ["right", [{ type: "cycleMessage", direction: 1 }]],
     ["j", []],
     ["q", []],
   ];
@@ -134,7 +134,7 @@ describe("inbox mode", () => {
 describe("collaborator (share) capabilities", () => {
   test("can annotate: comment opens the composer", () => {
     // Arrange
-    const collab = state({ canEditPlan: false, canSubmitVerdict: false });
+    const collab = state({ canEditPlan: false, canSubmitMessage: false });
 
     // Act / Assert
     expect(reduceKey(collab, key("c"), "comment")).toEqual([
@@ -159,9 +159,9 @@ describe("collaborator (share) capabilities", () => {
     expect(reduceKey(collab, key("c"), "cut")).toEqual([]);
   });
 
-  test("cannot submit a verdict: there is no agent on a share", () => {
+  test("cannot submit a message: there is no agent on a share", () => {
     // Arrange
-    const collab = state({ canSubmitVerdict: false });
+    const collab = state({ canSubmitMessage: false });
 
     // Act / Assert
     expect(reduceKey(collab, key("x"), "submit")).toEqual([

package/src/keymap.ts

@@ -46,8 +46,8 @@ export type Intent =
   | { type: "deselect" }
   | { type: "closeOverlay" }
   | { type: "saveCompose" }
-  | { type: "submitVerdict" }
-  | { type: "cycleVerdict"; direction: -1 | 1 }
+  | { type: "submitMessage" }
+  | { type: "cycleMessage"; direction: -1 | 1 }
   | { type: "finishReview" }
   | { type: "optInAutoClose" }
   | { type: "dismissCompletion" }
@@ -73,10 +73,10 @@ export interface KeyState {
   /**
    * Owner-only primitives a share collaborator lacks (undefined = owner, allowed).
    * A collaborator annotates but cannot edit the plan (cut / $EDITOR runs on
-   * the gateway) or submit an agent verdict (there is no agent on a share).
+   * the gateway) or submit an agent message (there is no agent on a share).
    */
   canEditPlan?: boolean;
-  canSubmitVerdict?: boolean;
+  canSubmitMessage?: boolean;
   /** Owner-only: publish the plan as a share. A collaborator never re-shares. */
   canShare?: boolean;
   /** Layer that owns keys before the grammar runs. */
@@ -193,7 +193,7 @@ function submitOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
 
   if (name === "escape") return [{ type: "closeOverlay" }];
   if (name === "left" || name === "right") {
-    return [{ type: "cycleVerdict", direction: name === "left" ? -1 : 1 }];
+    return [{ type: "cycleMessage", direction: name === "left" ? -1 : 1 }];
   }
 
   return [];
@@ -398,8 +398,8 @@ function annotationCluster(state: KeyState, action: string | undefined): Intent[
     return [{ type: "openRename" }];
   }
   if (action === "submit") {
-    // a collaborator's notes union back as they go; there is no verdict to submit
-    if (state.canSubmitVerdict === false)
+    // a collaborator's notes union back as they go; there is no message to submit
+    if (state.canSubmitMessage === false)
       return status("shared view - your notes save as you go; q to leave");
 
     return state.resolved ? [] : [{ type: "openSubmit" }];

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

@@ -9,7 +9,7 @@ import {
   type Thread,
 } from "@cueloop/schema";
 import { curateDiff } from "@cueloop/daemon/curate";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import { createReviewController } from "./thread-controller";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
@@ -40,7 +40,7 @@ function diffSession(files?: DiffFileContents[]): Thread {
     artifact: { type: "diff", content: PATCH, meta: {}, files },
     revisions: [{ revision: 1, content: PATCH, submittedAt: "2026-01-01T00:00:00.000Z" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
   };
@@ -54,7 +54,7 @@ const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
 /** A fake client that records the working copy the controller writes. */
-function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
+function fakeClient(initial: Thread, sink: WorkingCopySink): ThreadClient {
   let session = initial;
 
   return {
@@ -122,7 +122,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     close: () => {},
   };
 }
@@ -299,6 +299,16 @@ describe("diff hunk curation", () => {
     expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
     expect(sink.workingCopy).toBeUndefined();
   });
+
+  test("curation is disabled when a revision cleared its file snapshots", async () => {
+    const { controller, client } = await connected(diffSession([]));
+
+    controller.toggleRejectChange(4);
+    await tick();
+
+    expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
+    expect(client.sessionCurate).not.toHaveBeenCalled();
+  });
 });
 
 const PLAN_CONTENT = "# Title\n\nFirst paragraph.\n\nSecond paragraph.\n";
@@ -313,7 +323,7 @@ function planSession(workingCopy?: string): Thread {
     artifact: { type: "plan", content: PLAN_CONTENT, meta: {} },
     revisions: [{ revision: 1, content: PLAN_CONTENT, submittedAt: "2026-01-01T00:00:00.000Z" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
     workingCopy,

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

@@ -12,7 +12,7 @@ function threadFixture(overrides: Partial<Thread> = {}): Thread {
       { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
     ],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
     ...overrides,

package/src/thread-controller.live-diff.test.ts

@@ -7,7 +7,7 @@
 
 import { describe, expect, mock, test } from "bun:test";
 import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import { createReviewController, type ShareTransport } from "./thread-controller";
 import { mergeFromShare } from "./share";
 
@@ -53,7 +53,7 @@ function planSession(id = "ses_plan", repoRoot = "/repo"): Thread {
     artifact: { type: "plan", content: "# Plan\n", meta: {} },
     revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: AT,
   };
@@ -62,7 +62,7 @@ function planSession(id = "ses_plan", repoRoot = "/repo"): Thread {
 const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
-function fakeClient(session: Thread): SessionClient {
+function fakeClient(session: Thread): ThreadClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
@@ -88,10 +88,10 @@ function fakeClient(session: Thread): SessionClient {
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     repoDiff: async () => ({ patch: PATCH, files: FILES }),
     close: () => {},
-  } satisfies SessionClient;
+  } satisfies ThreadClient;
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
@@ -133,7 +133,7 @@ describe("live working-tree diff for a non-diff thread", () => {
 
         return { ...session, annotations: [{ ...annotation, createdAt: AT }] };
       },
-    } satisfies SessionClient;
+    } satisfies ThreadClient;
     const controller = createReviewController({
       sessionId: session.id,
       openClient: async () => client,
@@ -176,7 +176,7 @@ describe("live working-tree diff for a non-diff thread", () => {
       ...fakeClient(sessionA),
       sessionList: async () => [sessionA, sessionB],
       repoDiff: async (cwd: string) => (cwd === "/repoA" ? pendingA : diffB),
-    } satisfies SessionClient;
+    } satisfies ThreadClient;
 
     const controller = createReviewController({
       sessionId: sessionA.id,
@@ -228,7 +228,7 @@ function diffSession(meta: Thread["artifact"]["meta"], id = "ses_diff"): Thread
     artifact: { type: "diff", content: STALE_PATCH, files: STALE_FILES, meta },
     revisions: [{ revision: 1, content: STALE_PATCH, submittedAt: AT }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: AT,
   };
@@ -258,7 +258,7 @@ describe("frozen vs live diff by thread kind", () => {
   test("a plain diff review pins its captured snapshot and never queries the live tree", async () => {
     const session = diffSession({});
     const repoDiff = mock(async () => ({ patch: PATCH, files: FILES }));
-    const client = { ...fakeClient(session), repoDiff } satisfies SessionClient;
+    const client = { ...fakeClient(session), repoDiff } satisfies ThreadClient;
     const controller = createReviewController({
       sessionId: session.id,
       openClient: async () => client,
@@ -289,7 +289,7 @@ describe("serve mode pins the served thread to a frozen snapshot", () => {
   test("the served artifact wins over the thread's own capture and the live tree", async () => {
     const session = diffSession({ workbench: true });
     const repoDiff = mock(async () => ({ patch: PATCH, files: FILES }));
-    const client = { ...fakeClient(session), repoDiff } satisfies SessionClient;
+    const client = { ...fakeClient(session), repoDiff } satisfies ThreadClient;
     const controller = createReviewController({
       sessionId: session.id,
       openClient: async () => client,

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

@@ -12,7 +12,7 @@ function threadFixture(annotations: Annotation[] = []): Thread {
       { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
     ],
     annotations,
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
   };

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

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
 import { SCHEMA_VERSION, type Annotation, type ShareAccess, type Thread } from "@cueloop/schema";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import {
   createReviewController,
   SHARE_RECONNECT_MAX_MS,
@@ -43,7 +43,7 @@ function sessionFixture(overrides: Partial<Thread> = {}): Thread {
     artifact: { type: "plan", content: "# Plan\n", meta: {} },
     revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00.000Z" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
     ...overrides,
@@ -61,20 +61,20 @@ function annotation(id: string, author: string): Annotation {
   };
 }
 
-interface FakeSessionClient extends SessionClient {
-  sessionComment: Mock<SessionClient["sessionComment"]>;
+interface FakeThreadClient extends ThreadClient {
+  sessionComment: Mock<ThreadClient["sessionComment"]>;
 }
 
 const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
-function fakeClient(session: Thread): FakeSessionClient {
+function fakeClient(session: Thread): FakeThreadClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
-    sessionComment: mock<SessionClient["sessionComment"]>(async () => session),
+    sessionComment: mock<ThreadClient["sessionComment"]>(async () => session),
     sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
@@ -108,7 +108,7 @@ function fakeClient(session: Thread): FakeSessionClient {
     }),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     close: () => {},
   };
 }
@@ -119,7 +119,7 @@ async function connectedController(
   session: Thread,
   clock?: ManualClock,
   transport: ShareTransport = shareTransport,
-): Promise<{ controller: ReturnType<typeof createReviewController>; client: FakeSessionClient }> {
+): Promise<{ controller: ReturnType<typeof createReviewController>; client: FakeThreadClient }> {
   const client = fakeClient(session);
   const controller = createReviewController({
     sessionId: session.id,

package/src/thread-controller.switch-cache.test.ts

@@ -6,7 +6,7 @@ import {
   type Thread,
 } from "@cueloop/schema";
 import { curateDiff } from "@cueloop/daemon/curate";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import { createReviewController } from "./thread-controller";
 
 const PATCH_A = `diff --git a/src/a.ts b/src/a.ts
@@ -39,7 +39,7 @@ function diffSession(id: string, patch: string, files: DiffFileContents[]): Thre
     artifact: { type: "diff", content: patch, meta: { title: id }, files },
     revisions: [{ revision: 1, content: patch, submittedAt: "2026-01-01T00:00:00.000Z" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
   };
@@ -66,7 +66,7 @@ const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
 /** A fake client over a fixed set of sessions, so open(id) can switch between them from the inbox. */
-function fakeClient(sessions: Thread[]): SessionClient {
+function fakeClient(sessions: Thread[]): ThreadClient {
   const byId = new Map(sessions.map((session) => [session.id, session]));
 
   return {
@@ -108,7 +108,7 @@ function fakeClient(sessions: Thread[]): SessionClient {
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     close: () => {},
   };
 }

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

@@ -14,7 +14,7 @@ import {
   type Annotation,
   type Thread,
 } from "@cueloop/schema";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import { createReviewController, type ShareTransport } from "./thread-controller";
 import { mergeFromShare } from "./share";
 
@@ -39,7 +39,7 @@ function sessionFixture(): Thread {
     artifact: { type: "plan", content: "# Plan\n", meta: {} },
     revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
     annotations: [annotation("a1", "first")],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: AT,
   };
@@ -101,9 +101,9 @@ function fakeClient(session: Thread) {
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     close: () => {},
-  } satisfies SessionClient;
+  } satisfies ThreadClient;
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));

package/src/thread-controller.ts

@@ -9,7 +9,7 @@
 
 import { SystemClock, type Clock, type TimerHandle } from "@opentui/core";
 import { createStore, type StoreApi } from "zustand/vanilla";
-import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
+import { DaemonClient, type ThreadClient } from "@cueloop/daemon/client";
 import {
   applyPathView,
   createBranch,
@@ -36,7 +36,7 @@ import {
   type ShareLink,
   type Thread,
   type SessionHistory,
-  type VerdictKind,
+  type MessageOutcome,
 } from "@cueloop/schema";
 import { loadBundledExporters, type BundledExporter } from "./integrations";
 import {
@@ -140,7 +140,7 @@ function planCutId(base: { lineStart: number; lineEnd: number }): string {
 /**
  * Whether two records of the same thread yield the same document projection (display, rows, files,
  * models). Those derive only from the artifact content and the working copy, so an update that
- * touched only annotations, status, or the verdict leaves them identical - the projection can be
+ * touched only annotations, status, or the message leaves them identical - the projection can be
  * reused rather than re-parsed. Content and working copy are strings, compared here by value.
  */
 export function sameDerivationInputs(previous: Thread, next: Thread): boolean {
@@ -238,7 +238,7 @@ export interface ReviewControllerOptions {
    * daemon; the sharing gateway injects a blob-backed client so the same <App>
    * renders a decrypted share instead.
    */
-  openClient?: () => Promise<SessionClient>;
+  openClient?: () => Promise<ThreadClient>;
   shareTransport?: ShareTransport;
   /** Serve mode: pin this frozen diff onto the served thread so an observer sees a stable snapshot. */
   servedArtifact?: Artifact;
@@ -359,7 +359,7 @@ export interface ReviewController {
   /** Leave the walk; the viewed set stays on the session record. */
   walkLeave(): void;
   /** Resolve the review, run the export, start the completion hand-back. */
-  submit(verdict: VerdictKind, summary: string): void;
+  submit(message: MessageOutcome, summary: string): void;
   /** Publish the current session as a public share link; the ssh line lands on the clipboard. */
   share(): void;
   /** Stop sharing the current session, revoking every link at the gateway. Owner only. */
@@ -434,7 +434,7 @@ const DERIVED_CACHE_LIMIT = 8;
 
 class Controller implements ReviewController {
   readonly readOnly: boolean;
-  private client: SessionClient | null = null;
+  private client: ThreadClient | null = null;
   private closed = false;
   /** The controller's state lives in a zustand store; internal reads go through the snapshot getter. */
   private readonly store: StoreApi<ControllerSnapshot> = createStore<ControllerSnapshot>(() => ({
@@ -582,7 +582,7 @@ class Controller implements ReviewController {
   /**
    * The projection reuses when the same thread's derivation inputs are unchanged. display, rows,
    * files, and models derive only from the artifact and working copy - never from annotations,
-   * status, or the verdict - so an update that touched only those produces an all-new session
+   * status, or the message - so an update that touched only those produces an all-new session
    * record but an identical projection.
    */
   private reusesDerived(session: Thread, liveDiff: LiveWorkingDiff | null): boolean {
@@ -998,7 +998,7 @@ class Controller implements ReviewController {
     const session = this.snapshot.session;
 
     if (!session || session.status === "resolved") return null;
-    if (!session.artifact.files) {
+    if (!session.artifact.files?.length) {
       this.setStatus("hunk curation needs full file contents (PR diffs cannot be curated)");
 
       return null;
@@ -1503,7 +1503,7 @@ class Controller implements ReviewController {
     if (this.snapshot.walk) this.update({ walk: null });
   }
 
-  submit(verdict: VerdictKind, summary: string): void {
+  submit(message: MessageOutcome, summary: string): void {
     const session = this.snapshot.session;
 
     if (!session) return;
@@ -1511,14 +1511,14 @@ class Controller implements ReviewController {
     const actionBodies = Object.fromEntries(
       slashItemsFrom(this.quickActions).map((item) => [item.name, item.body]),
     );
-    this.client!.sessionResolve(session.id, verdict, summary, actionBodies)
+    this.client!.sessionSendMessage(session.id, message, summary, actionBodies)
       .then((resolved) => {
-        // The completion overlay heading already states the verdict, so the
+        // The completion overlay heading already states the message, so the
         // status line stays empty here - only export/error messages fill it.
         this.update({ session: resolved, status: "" });
         // notes-vault export: guarded by each exporter's policy (default manual = no-op)
         for (const exporter of this.exporters) {
-          if (!exporter.runsOn(verdict)) continue;
+          if (!exporter.runsOn(message)) continue;
           void exporter.run(resolved).then((exportResult) => {
             this.setStatus(
               exportResult.success && exportResult.path

package/src/tree-view.test.ts

@@ -20,7 +20,7 @@ function forked(): SessionHistory {
     id: "ses_1",
     revisions: [{ revision: 1, content: "v1", submittedAt: AT }],
     annotations: [],
-    verdict: null,
+    message: null,
     createdAt: AT,
   });
 

package/src/tree-view.ts

@@ -55,10 +55,10 @@ export function describeEntry(entry: SessionEntry, round?: number): EntryDescrip
       return { glyph: "·", text: "comment" };
     case "comment-removed":
       return { glyph: "·", text: "comment removed" };
-    case "verdict":
+    case "message":
       return {
-        glyph: entry.verdict.kind === "approve" ? "✓" : "✗",
-        text: entry.verdict.kind.replace("_", " "),
+        glyph: entry.message.outcome === "approved" ? "✓" : "✗",
+        text: entry.message.outcome.replace("_", " "),
       };
     case "branch-summary":
       return { glyph: "↩", text: entry.text ? `"${entry.text}"` : "returned" };

package/src/use-annotation-surface.tsx

@@ -87,7 +87,7 @@ export interface AnnotationSurfaceOptions {
    * thread anchors comments in plan coordinates, so a draft here would misanchor.
    */
   commentsEnabled?: boolean;
-  /** A verdict is in: no draft may open; the app answers with its read-only status. */
+  /** A message is in: no draft may open; the app answers with its read-only status. */
   resolved: boolean;
   /** True while a menu, dialog, or overlay owns the keyboard. */
   suspended: boolean;