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

package/src/config.test.ts

@@ -142,6 +142,25 @@ describe("loadConfig", () => {
     }
   });
 
+  test("[skills] path overrides the default and a malformed value never discards the config", () => {
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-skills-"));
+    const path = join(dir, "config.toml");
+
+    try {
+      writeFileSync(path, `[skills]\npath = "/custom/skills"\n`);
+      expect(loadConfig({ userConfigPath: path }).skillsPath).toBe("/custom/skills");
+
+      // a wrong-typed path falls back to the default without dropping the sibling [keys] setting
+      writeFileSync(path, `[skills]\npath = 123\n\n[keys]\ncomment = "z"\n`);
+      const config = loadConfig({ userConfigPath: path });
+
+      expect(config.keys["comment"]).toEqual(["z"]);
+      expect(config.skillsPath).toContain(".agents");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test('[ui] diff_view loads the pre-rename "unified" value as "stacked"', () => {
     // Arrange - an upgrade must not flip a user who had persisted the old spelling
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-diff-"));
@@ -372,7 +391,7 @@ describe("quick actions ([[actions]])", () => {
 
     // Assert
     expect(config.actions).toEqual(DEFAULT_QUICK_ACTIONS);
-    expect(config.actions).toHaveLength(7);
+    expect(config.actions).toHaveLength(8);
   });
 
   test("configured actions replace the defaults, with optional metadata", () => {
@@ -515,3 +534,13 @@ describe("[authors] rename map", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 });
+
+describe("the /lgtm default quick action", () => {
+  test("expands to a terse approving note", () => {
+    const lgtm = DEFAULT_QUICK_ACTIONS.find((action) => action.prompt.toLowerCase() === "lgtm");
+
+    expect(lgtm).toBeDefined();
+    // the reference is /lgtm, so the label is the prompt; it expands like every action (label, then note)
+    expect(quickActionBody(lgtm!)).toBe("LGTM\n\nThis looks good to me.");
+  });
+});

package/src/config.ts

@@ -70,6 +70,10 @@ export const DEFAULT_QUICK_ACTIONS: QuickAction[] = [
     metadata:
       "Follow the nearest existing pattern in this codebase rather than introducing a new one.",
   },
+  {
+    prompt: "LGTM",
+    metadata: "This looks good to me.",
+  },
 ];
 
 /** The comment body a quick action expands to: the prompt, then its system prompt when set. */
@@ -109,6 +113,8 @@ export interface CueloopConfig {
   authors: Record<string, string>;
   /** Marker-popover quick actions ([[actions]] tables); the 5 defaults when unset. */
   actions: QuickAction[];
+  /** Directory of user-level skills surfaced in the "/" palette ([skills] path); ~/.agents/skills default. */
+  skillsPath: string;
   integrations: IntegrationsConfig;
   /** Opt-in experimental features ([experimental] table); all default off. */
   experimental: ExperimentalConfig;
@@ -144,6 +150,15 @@ export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   walk: ["w"],
 };
 
+const SkillsSectionSchema = v.object({ path: v.optional(v.string()) });
+
+function skillsPathFrom(
+  raw: v.InferOutput<typeof SkillsSectionSchema> | undefined,
+  fallback: string,
+): string {
+  return raw?.path?.trim() ? raw.path.trim() : fallback;
+}
+
 const ConfigDocumentSchema = v.object({
   actions: v.optional(v.array(v.unknown())),
   authors: v.optional(v.unknown()),
@@ -152,6 +167,7 @@ const ConfigDocumentSchema = v.object({
   theme: v.optional(v.unknown()),
   ui: v.optional(v.unknown()),
   experimental: v.optional(v.unknown()),
+  skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
 });
 
 const QuickActionSchema = v.object({
@@ -236,6 +252,7 @@ function layer(
     ui: { ...base.ui },
     authors: { ...base.authors },
     actions: [...base.actions],
+    skillsPath: base.skillsPath,
     integrations: { obsidian: { ...base.integrations.obsidian } },
     experimental: { ...base.experimental },
   };
@@ -247,6 +264,7 @@ function layer(
   const experimental = v.safeParse(ExperimentalSchema, raw.experimental);
 
   if (actions) out.actions = actions;
+  out.skillsPath = skillsPathFrom(raw.skills, base.skillsPath);
   if (authors.success) {
     for (const [id, value] of Object.entries(authors.output)) {
       const name = v.safeParse(v.string(), value);
@@ -295,6 +313,7 @@ export function loadConfig(
     },
     authors: {},
     actions: [...DEFAULT_QUICK_ACTIONS],
+    skillsPath: join(homedir(), ".agents", "skills"),
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
     experimental: { prototypePixels: false },
   };

package/src/discussions.ts

@@ -5,7 +5,7 @@
  * plan thread view and the diff sheet group the same way.
  */
 
-import type { Annotation, ReviewSession } from "@cueloop/schema";
+import type { Annotation, Thread } from "@cueloop/schema";
 import type { Mark } from "./view-plan";
 import { comparePositions, type TextSpan } from "./thread-selection";
 
@@ -29,7 +29,7 @@ export function spanKey(span: TextSpan): string {
  * read as one conversation); replies join the discussion their replyTo names, or
  * stand as roots when that root is gone.
  */
-export function discussionsFrom(session: ReviewSession, marks: Map<number, Mark[]>): Discussion[] {
+export function discussionsFrom(session: Thread, marks: Map<number, Mark[]>): Discussion[] {
   const byId = new Map(session.annotations.map((annotation) => [annotation.id, annotation]));
   const spanOf = new Map<string, TextSpan>();
 

package/src/intent-dispatch.test.ts

@@ -7,9 +7,9 @@
 
 import { describe, expect, mock, test } from "bun:test";
 import type { SetStateAction } from "react";
-import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
 import { createIntentDispatch, type IntentDispatchDeps } from "./intent-dispatch";
-import type { ControllerSnapshot, CurationItem, ReviewController } from "./session-controller";
+import type { ControllerSnapshot, CurationItem, ReviewController } from "./thread-controller";
 import type { DisplayBlock } from "./view-plan";
 import type { TreeRow } from "./tree-view";
 
@@ -28,10 +28,7 @@ function annotation(id: string, overrides: Partial<Annotation> = {}): Annotation
   };
 }
 
-function sessionWith(
-  annotations: Annotation[],
-  overrides: Partial<ReviewSession> = {},
-): ReviewSession {
+function sessionWith(annotations: Annotation[], overrides: Partial<Thread> = {}): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",

package/src/intent-dispatch.ts

@@ -8,10 +8,10 @@
  */
 
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
-import { isAddressed, isAgentNote, type ReviewSession, type VerdictKind } from "@cueloop/schema";
+import { isAddressed, isAgentNote, type Thread, type VerdictKind } from "@cueloop/schema";
 import { displayText, spanKey, startSpan, type DisplayBlock, type SpanState } from "./view-plan";
 import type { DiffRow } from "./view-diff";
-import type { ReviewController } from "./session-controller";
+import type { ReviewController } from "./thread-controller";
 import type { Intent } from "./keymap";
 import type { TreeRow } from "./tree-view";
 import { quickActionBody, type QuickAction } from "./config";
@@ -54,13 +54,13 @@ export function activeSpanState(mode: Mode): SpanState | null {
  * annotation a revision already addressed is settled - it neither blocks the
  * verdict default nor re-enters the next feedback document.
  */
-export function reviewerAnnotations(session: ReviewSession) {
+export function reviewerAnnotations(session: Thread) {
   return session.annotations.filter(
     (annotation) => !isAgentNote(annotation) && !isAddressed(annotation),
   );
 }
 
-export function defaultVerdict(session: ReviewSession): VerdictKind {
+export function defaultVerdict(session: Thread): VerdictKind {
   return reviewerAnnotations(session).length || session.workingCopy !== undefined
     ? "request_changes"
     : "approve";
@@ -80,10 +80,10 @@ export interface IntentDispatchDeps {
   display: DisplayBlock[];
   rows: DiffRow[];
   cursor: number;
-  inbox: ReviewSession[] | null;
+  inbox: Thread[] | null;
   inboxCursor: number;
   mode: Mode;
-  session: ReviewSession | null;
+  session: Thread | null;
   focusedAnnotationId: string | undefined;
   /** The curation item selected for undo, if any. */
   selectedCurationId: string | undefined;

package/src/serve.test.ts

@@ -10,14 +10,14 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Client } from "ssh2";
 import { DaemonServer } from "@cueloop/daemon";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { serveClient, type ServeHandle } from "./serve";
 
 const PLAN = "# Rollout Plan\n\nShip the store move behind a flag.\n";
 
 let home: string;
 let daemon: DaemonServer;
-let session: ReviewSession;
+let session: Thread;
 let handle: ServeHandle;
 
 beforeEach(async () => {

package/src/share.ts

@@ -12,13 +12,8 @@ import {
   SHARE_UPLOAD_USER,
   packSessionBlob,
 } from "@cueloop/daemon/share-blob";
-import {
-  removalEntries,
-  viewFollowing,
-  type Annotation,
-  type ReviewSession,
-} from "@cueloop/schema";
-import { SessionRecordSchema } from "@cueloop/daemon/validate";
+import { removalEntries, viewFollowing, type Annotation, type Thread } from "@cueloop/schema";
+import { ThreadRecordSchema } from "@cueloop/daemon/validate";
 import type { SharedMerge } from "@cueloop/daemon/client";
 import * as v from "valibot";
 import { copyToClipboard } from "./clipboard";
@@ -42,7 +37,7 @@ export function shareIdFromLine(line: string): string | undefined {
 
 /** Upload the session to the gateway and copy the resulting ssh line. */
 export async function publishShare(
-  session: ReviewSession,
+  session: Thread,
   target: ShareTarget = {},
 ): Promise<ShareResult> {
   const { stdout, stderr, code } = await runShareSsh(
@@ -67,16 +62,16 @@ export async function publishShare(
  * the fingerprint that uploaded it through, so collaborator notes reach the
  * planner without exposing the master key.
  */
-export async function pullShare(shareId: string, target: ShareTarget = {}): Promise<ReviewSession> {
+export async function pullShare(shareId: string, target: ShareTarget = {}): Promise<Thread> {
   const { stdout, stderr, code } = await runShareSsh("cueloop-pull", Buffer.from(shareId), target);
 
   if (code !== 0) throw new Error(`gateway pull failed: ${stderr.trim() || `ssh exited ${code}`}`);
 
-  return v.parse(SessionRecordSchema, JSON.parse(stdout));
+  return v.parse(ThreadRecordSchema, JSON.parse(stdout));
 }
 
 /** A share's collaborator notes: the ones a viewer authored (author stamped). */
-export function collaboratorAnnotations(session: ReviewSession): Annotation[] {
+export function collaboratorAnnotations(session: Thread): Annotation[] {
   return session.annotations.filter((annotation) => annotation.author);
 }
 
@@ -84,7 +79,7 @@ export function collaboratorAnnotations(session: ReviewSession): Annotation[] {
  * What a pulled share hands the local merge: collaborators' notes, the
  * participant registry, and the removals the share recorded, by entry id.
  */
-export function mergeFromShare(remote: ReviewSession): SharedMerge {
+export function mergeFromShare(remote: Thread): SharedMerge {
   const merge: SharedMerge = { annotations: collaboratorAnnotations(remote) };
 
   if (remote.participants) merge.participants = remote.participants;
@@ -120,7 +115,7 @@ export async function pushShare(
 
 export interface ShareWatchHandlers {
   /** The whole session record, each time the share changes. */
-  onSession: (session: ReviewSession) => void;
+  onSession: (session: Thread) => void;
   /** The stream ended, for any reason; the caller decides whether to reconnect. */
   onClose: (reason: string) => void;
 }
@@ -128,7 +123,7 @@ export interface ShareWatchHandlers {
 const WatchFrameSchema = v.variant("type", [
   v.object({ type: v.literal("ready") }),
   v.object({ type: v.literal("ping") }),
-  v.object({ type: v.literal("session"), session: SessionRecordSchema }),
+  v.object({ type: v.literal("session"), session: ThreadRecordSchema }),
 ]);
 
 /**

package/src/skills.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadSkills } from "./skills";
+import { mergeSlashItems, type SlashItem } from "./slash-palette";
+
+function skillDir(): string {
+  const root = mkdtempSync(join(tmpdir(), "cueloop-skills-"));
+
+  mkdirSync(join(root, "typescript-magician"));
+  writeFileSync(
+    join(root, "typescript-magician", "SKILL.md"),
+    "---\nname: typescript-magician\ndescription: Design complex generic types.\n---\n\nbody\n",
+  );
+  mkdirSync(join(root, "no-frontmatter"));
+  writeFileSync(join(root, "no-frontmatter", "SKILL.md"), "just prose, no frontmatter\n");
+
+  return root;
+}
+
+describe("loadSkills", () => {
+  test("reads name and description from each SKILL.md frontmatter", () => {
+    const root = skillDir();
+
+    try {
+      const skills = loadSkills(root);
+      const magician = skills.find((skill) => skill.name === "typescript-magician");
+
+      expect(magician?.description).toBe("Design complex generic types.");
+      // a directory whose SKILL.md has no frontmatter is skipped, not crashed on
+      expect(skills.some((skill) => skill.name === "no-frontmatter")).toBe(false);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("a missing skills directory yields no skills", () => {
+    expect(loadSkills(join(tmpdir(), "cueloop-does-not-exist-xyz"))).toEqual([]);
+  });
+
+  test("CRLF delimiters parse, and a quoted name is unquoted", () => {
+    const root = mkdtempSync(join(tmpdir(), "cueloop-skills-crlf-"));
+
+    try {
+      mkdirSync(join(root, "review"));
+      writeFileSync(
+        join(root, "review", "SKILL.md"),
+        '---\r\nname: "review"\r\ndescription: Review the change.\r\n---\r\n',
+      );
+      const skills = loadSkills(root);
+
+      // no stray quotes and no CRLF-broken frontmatter
+      expect(skills.map((skill) => skill.name)).toEqual(["review"]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("mergeSlashItems", () => {
+  test("a quick action wins a name collision with a skill", () => {
+    const actions: SlashItem[] = [{ name: "lgtm", description: "action", body: "LGTM" }];
+    const skills: SlashItem[] = [
+      { name: "lgtm", description: "skill", body: "" },
+      { name: "vitest-patterns", description: "skill", body: "" },
+    ];
+    const merged = mergeSlashItems(actions, skills);
+
+    expect(merged.filter((item) => item.name === "lgtm")).toHaveLength(1);
+    expect(merged.find((item) => item.name === "lgtm")?.description).toBe("action");
+    expect(merged.some((item) => item.name === "vitest-patterns")).toBe(true);
+  });
+});

package/src/skills.ts

@@ -0,0 +1,68 @@
+import { createContext } from "react";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import * as v from "valibot";
+import type { SlashItem } from "./slash-palette";
+
+/** The default user-level skill store, harness-agnostic; a config path overrides it. */
+export function defaultSkillsDir(): string {
+  return join(homedir(), ".agents", "skills");
+}
+
+const SkillNameSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+
+/** One `key: value` line from the frontmatter, unquoted; undefined when the key is absent. */
+function frontmatterValue(frontmatter: string, key: string): string | undefined {
+  const match = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(frontmatter);
+
+  return match
+    ? match[1]!
+        .trim()
+        .replace(/^["']|["']$/g, "")
+        .trim()
+    : undefined;
+}
+
+/** User skills as palette items: each `<dir>/SKILL.md` whose frontmatter carries a name and description. */
+export function loadSkills(dir: string): SlashItem[] {
+  let entries;
+
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const items: SlashItem[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    let text;
+
+    try {
+      text = readFileSync(join(dir, entry.name, "SKILL.md"), "utf8");
+    } catch {
+      continue;
+    }
+    const frontmatter = /^---\n([\s\S]*?)\n---/.exec(text.replace(/\r\n/g, "\n"));
+
+    if (!frontmatter) continue;
+    const name = v.safeParse(
+      SkillNameSchema,
+      frontmatterValue(frontmatter[1]!, "name") ?? entry.name,
+    );
+
+    if (!name.success) continue;
+
+    items.push({
+      name: name.output,
+      description: frontmatterValue(frontmatter[1]!, "description") ?? "",
+      body: "",
+    });
+  }
+
+  return items;
+}
+
+/** Skills reach the composer palette through context, so no surface needs a new prop to list them. */
+export const SlashSkillsContext = createContext<SlashItem[]>([]);

package/src/slash-palette.ts

@@ -81,17 +81,24 @@ export interface InlineSlash {
   suggestion: SlashItem;
 }
 
-/** The inline completion state: the trailing "/word" and its closest skill, or null. */
+/** The inline completion state: the trailing "/word" and its closest item, or null. */
 export function resolveInlineSuggestion(
   slashActive: boolean,
   text: string,
-  quickActions: QuickAction[],
+  items: SlashItem[],
 ): InlineSlash | null {
   if (slashActive) return null;
   const token = inlineSlashToken(text);
 
   if (token === null) return null;
-  const suggestion = slashFilter(slashItemsFrom(quickActions), token.slice(1))[0];
+  const suggestion = slashFilter(items, token.slice(1))[0];
 
   return suggestion ? { token, suggestion } : null;
 }
+
+/** Quick actions and user skills in one palette; a quick action wins a name collision (it expands). */
+export function mergeSlashItems(actions: SlashItem[], skills: SlashItem[]): SlashItem[] {
+  const taken = new Set(actions.map((action) => action.name));
+
+  return [...actions, ...skills.filter((skill) => !taken.has(skill.name))];
+}

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

@@ -6,11 +6,11 @@ import {
   SCHEMA_VERSION,
   type DiffFileContents,
   type HunkRejection,
-  type ReviewSession,
+  type Thread,
 } from "@cueloop/schema";
 import { curateDiff } from "@cueloop/daemon/curate";
 import type { SessionClient } from "@cueloop/daemon/client";
-import { createReviewController } from "./session-controller";
+import { createReviewController } from "./thread-controller";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -32,7 +32,7 @@ const FILES: DiffFileContents[] = [
   },
 ];
 
-function diffSession(files?: DiffFileContents[]): ReviewSession {
+function diffSession(files?: DiffFileContents[]): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_diff",
@@ -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: ReviewSession, sink: WorkingCopySink): SessionClient {
+function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
   let session = initial;
 
   return {
@@ -62,6 +62,7 @@ function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClien
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
+    sessionComment: unimplemented("sessionComment"),
     sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
@@ -126,7 +127,7 @@ function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClien
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 
-async function connected(session: ReviewSession) {
+async function connected(session: Thread) {
   const sink: WorkingCopySink = {};
   const client = fakeClient(session, sink);
   const controller = createReviewController({
@@ -302,7 +303,7 @@ const PLAN_CONTENT = "# Title\n\nFirst paragraph.\n\nSecond paragraph.\n";
 // the working copy with the "Second paragraph." block cut out
 const PLAN_CUT = "# Title\n\nFirst paragraph.\n";
 
-function planSession(workingCopy?: string): ReviewSession {
+function planSession(workingCopy?: string): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_plan",
@@ -371,7 +372,7 @@ const TAIL_PATCH = `diff --git a/src/store.ts b/src/store.ts
 +  private items = new Map();
 `;
 
-function tailSession(): ReviewSession {
+function tailSession(): Thread {
   return {
     ...diffSession(),
     artifact: {

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

@@ -6,9 +6,9 @@
  */
 
 import { describe, expect, mock, test } from "bun:test";
-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, 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,7 +31,7 @@ const FILES = [
 ];
 
 const shareTransport: ShareTransport = {
-  publish: mock(async (session: ReviewSession) => ({
+  publish: mock(async (session: Thread) => ({
     line: `ssh p_${session.id}@cueloop.dev`,
     copied: true,
   })),
@@ -43,7 +43,7 @@ const shareTransport: ShareTransport = {
   mergeFromShare,
 };
 
-function planSession(id = "ses_plan", repoRoot = "/repo"): ReviewSession {
+function planSession(id = "ses_plan", repoRoot = "/repo"): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id,
@@ -60,12 +60,13 @@ function planSession(id = "ses_plan", repoRoot = "/repo"): ReviewSession {
 const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
-function fakeClient(session: ReviewSession): SessionClient {
+function fakeClient(session: Thread): SessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
+    sessionComment: unimplemented("sessionComment"),
     sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
@@ -123,7 +124,7 @@ describe("live working-tree diff for a non-diff thread", () => {
     let sent: Annotation | undefined;
     const client = {
       ...fakeClient(session),
-      sessionAnnotate: async (_id: string, annotation: Annotation) => {
+      sessionComment: async (_id: string, annotation: Annotation) => {
         sent = annotation;
 
         return { ...session, annotations: [{ ...annotation, createdAt: AT }] };