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

package/src/client.ts

@@ -11,7 +11,7 @@ import type {
   Artifact,
   DiffFileStatus,
   HunkRejection,
-  ReviewSession,
+  Thread,
   VerdictKind,
   WorkspaceKey,
 } from "@cueloop/schema";
@@ -29,7 +29,7 @@ import type { SharedMerge } from "./api";
 
 export type { SharedMerge } from "./api";
 import { cueloopHome, ownerTokenPath, socketPath } from "./paths";
-import { Params, SessionRecordSchema, DiffFileContentsSchema } from "./validate";
+import { Params, ThreadRecordSchema, DiffFileContentsSchema } from "./validate";
 import type { WorkingTreeDiff } from "./working-tree";
 import { DAEMON_VERSION } from "./version";
 
@@ -66,25 +66,31 @@ const HerdrTabResultSchema = v.nullable(v.object({ tabId: v.string(), paneId: v.
 export interface SessionClient {
   onEvent(listener: (event: EventFrame) => void): () => void;
   subscribe(): Promise<void>;
-  sessionGet(id: string): Promise<ReviewSession>;
-  sessionList(filter?: { status?: "pending" | "resolved" }): Promise<ReviewSession[]>;
+  sessionGet(id: string): Promise<Thread>;
+  sessionList(filter?: { status?: "pending" | "resolved" }): Promise<Thread[]>;
+  /** Add a comment; the primary annotate method. `sessionAnnotate` is the retained alias. */
+  sessionComment(
+    id: string,
+    annotation: Omit<Annotation, "createdAt">,
+    authorName?: string,
+  ): Promise<Thread>;
   sessionAnnotate(
     id: string,
     annotation: Omit<Annotation, "createdAt">,
     authorName?: string,
-  ): Promise<ReviewSession>;
+  ): Promise<Thread>;
   /** Remove a comment; a non-owner connection removes only the comments of the author it is bound to. */
-  sessionRemoveAnnotation(id: string, annotationId: string): Promise<ReviewSession>;
-  sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession>;
+  sessionRemoveAnnotation(id: string, annotationId: string): Promise<Thread>;
+  sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<Thread>;
   /** Cut the `blockIndex`-th block of the working copy. */
-  sessionCutBlock(id: string, blockIndex: number): Promise<ReviewSession>;
+  sessionCutBlock(id: string, blockIndex: number): Promise<Thread>;
   /** Re-insert the `baseBlockIndex`-th block of the submitted revision before `line` (default: the end). */
-  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<ReviewSession>;
+  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<Thread>;
   /** Replace a diff review's reject decisions; the working copy follows. */
-  sessionCurate(id: string, rejections: HunkRejection[]): Promise<ReviewSession>;
-  sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession>;
+  sessionCurate(id: string, rejections: HunkRejection[]): Promise<Thread>;
+  sessionSetViewed(id: string, viewedPaths: string[]): Promise<Thread>;
   /** Rename a session's display title; an empty title restores the derived default. */
-  sessionSetTitle(id: string, title: string): Promise<ReviewSession>;
+  sessionSetTitle(id: string, title: string): Promise<Thread>;
   /** Tracked, repo-relative file paths for the session's workspace; a client with no local repo (a share) omits it. */
   projectFiles?(sessionId: string): Promise<string[]>;
   /** UTF-8 contents of a repo-relative file, or null when it cannot be read safely; omitted by a client with no local repo. */
@@ -98,32 +104,27 @@ export interface SessionClient {
   /** The live working-tree diff (patch plus per-file contents) at `cwd`. */
   repoDiff?(cwd: string): Promise<WorkingTreeDiff>;
   /** Find-or-create the per-repo workbench thread for `cwd`, so a bare launch's first comment persists. */
-  sessionWorkbench?(cwd: string): Promise<ReviewSession>;
+  sessionWorkbench?(cwd: string): Promise<Thread>;
   /** Move a branch's tip (the current one, or `branch` after switching to it) back to an entry on its path; a summary records the abandoned segment. */
-  sessionNavigate(
-    id: string,
-    entryId: string,
-    summary?: string,
-    branch?: string,
-  ): Promise<ReviewSession>;
+  sessionNavigate(id: string, entryId: string, summary?: string, branch?: string): Promise<Thread>;
   /** Start a branch at the current tip and switch to it. */
-  sessionBranch(id: string, name: string): Promise<ReviewSession>;
-  sessionSwitch(id: string, branch: string): Promise<ReviewSession>;
+  sessionBranch(id: string, name: string): Promise<Thread>;
+  sessionSwitch(id: string, branch: string): Promise<Thread>;
   /** Name the current tip as a checkpoint. */
-  sessionLabel(id: string, label: string): Promise<ReviewSession>;
+  sessionLabel(id: string, label: string): Promise<Thread>;
   /** Copy the current path into a new session; returns the fork. */
-  sessionFork(id: string): Promise<ReviewSession>;
-  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession>;
-  sessionMergeShared(id: string, incoming: SharedMerge): Promise<ReviewSession>;
+  sessionFork(id: string): Promise<Thread>;
+  sessionSetShareId(id: string, shareId: string): Promise<Thread>;
+  sessionMergeShared(id: string, incoming: SharedMerge): Promise<Thread>;
   sessionDelete(id: string): Promise<void>;
   /** Record the caller's own identity name (collaborator self-naming on a share). */
-  sessionSetSelfName(id: string, name: string): Promise<ReviewSession>;
+  sessionSetSelfName(id: string, name: string): Promise<Thread>;
   sessionResolve(
     id: string,
     verdictKind: VerdictKind,
     summary: string,
     actionBodies?: Record<string, string>,
-  ): Promise<ReviewSession>;
+  ): Promise<Thread>;
   close(): void;
 }
 
@@ -374,84 +375,86 @@ export class DaemonClient implements SessionClient {
   subscribe(): Promise<void> {
     return this.request("events.subscribe", {}, EmptyResultSchema).then(() => undefined);
   }
-  sessionCreate(workspace: WorkspaceKey, artifact: Artifact): Promise<ReviewSession> {
-    return this.request("session.create", { workspace, artifact }, SessionRecordSchema);
+  sessionCreate(workspace: WorkspaceKey, artifact: Artifact): Promise<Thread> {
+    return this.request("session.create", { workspace, artifact }, ThreadRecordSchema);
   }
-  sessionGet(id: string): Promise<ReviewSession> {
-    return this.request("session.get", { id }, SessionRecordSchema);
+  sessionGet(id: string): Promise<Thread> {
+    return this.request("session.get", { id }, ThreadRecordSchema);
   }
-  sessionList(filter?: { status?: "pending" | "resolved" }): Promise<ReviewSession[]> {
-    return this.request("session.list", { filter }, v.array(SessionRecordSchema));
+  sessionList(filter?: { status?: "pending" | "resolved" }): Promise<Thread[]> {
+    return this.request("session.list", { filter }, v.array(ThreadRecordSchema));
   }
   /** Long-poll; null = still pending after timeoutMs (re-poll to collect). */
-  sessionWait(id: string, timeoutMs: number): Promise<ReviewSession | null> {
+  sessionWait(id: string, timeoutMs: number): Promise<Thread | null> {
     return this.request(
       "session.wait",
       { id, timeoutMs },
-      v.nullable(SessionRecordSchema),
+      v.nullable(ThreadRecordSchema),
       timeoutMs + 10_000,
     );
   }
+  sessionComment(
+    id: string,
+    annotation: Omit<Annotation, "createdAt">,
+    authorName?: string,
+  ): Promise<Thread> {
+    return this.request("session.comment", { id, annotation, authorName }, ThreadRecordSchema);
+  }
   sessionAnnotate(
     id: string,
     annotation: Omit<Annotation, "createdAt">,
     authorName?: string,
-  ): Promise<ReviewSession> {
-    return this.request("session.annotate", { id, annotation, authorName }, SessionRecordSchema);
+  ): Promise<Thread> {
+    return this.request("session.annotate", { id, annotation, authorName }, ThreadRecordSchema);
   }
-  sessionRemoveAnnotation(id: string, annotationId: string): Promise<ReviewSession> {
-    return this.request("session.removeAnnotation", { id, annotationId }, SessionRecordSchema);
+  sessionRemoveAnnotation(id: string, annotationId: string): Promise<Thread> {
+    return this.request("session.removeAnnotation", { id, annotationId }, ThreadRecordSchema);
   }
   /** Register a display name for a participant - a collaborator's or an agent's own, on a share or locally. */
-  sessionSetParticipantName(id: string, author: string, name: string): Promise<ReviewSession> {
-    return this.request("session.setParticipantName", { id, author, name }, SessionRecordSchema);
+  sessionSetParticipantName(id: string, author: string, name: string): Promise<Thread> {
+    return this.request("session.setParticipantName", { id, author, name }, ThreadRecordSchema);
   }
-  sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession> {
-    return this.request("session.setWorkingCopy", { id, workingCopy }, SessionRecordSchema);
+  sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<Thread> {
+    return this.request("session.setWorkingCopy", { id, workingCopy }, ThreadRecordSchema);
   }
-  sessionCutBlock(id: string, blockIndex: number): Promise<ReviewSession> {
-    return this.request("session.cutBlock", { id, blockIndex }, SessionRecordSchema);
+  sessionCutBlock(id: string, blockIndex: number): Promise<Thread> {
+    return this.request("session.cutBlock", { id, blockIndex }, ThreadRecordSchema);
   }
-  sessionNavigate(
-    id: string,
-    entryId: string,
-    summary?: string,
-    branch?: string,
-  ): Promise<ReviewSession> {
+  sessionNavigate(id: string, entryId: string, summary?: string, branch?: string): Promise<Thread> {
     const params: v.InferInput<(typeof Params)["session.navigate"]> = { id, entryId };
 
     if (summary !== undefined) params.summary = summary;
     if (branch !== undefined) params.branch = branch;
 
-    return this.request("session.navigate", params, SessionRecordSchema);
+    return this.request("session.navigate", params, ThreadRecordSchema);
   }
-  sessionBranch(id: string, name: string): Promise<ReviewSession> {
-    return this.request("session.branch", { id, name }, SessionRecordSchema);
+  sessionBranch(id: string, name: string): Promise<Thread> {
+    return this.request("session.branch", { id, name }, ThreadRecordSchema);
   }
-  sessionSwitch(id: string, branch: string): Promise<ReviewSession> {
-    return this.request("session.switch", { id, branch }, SessionRecordSchema);
+  sessionSwitch(id: string, branch: string): Promise<Thread> {
+    return this.request("session.switch", { id, branch }, ThreadRecordSchema);
   }
-  sessionLabel(id: string, label: string): Promise<ReviewSession> {
-    return this.request("session.label", { id, label }, SessionRecordSchema);
+  sessionLabel(id: string, label: string): Promise<Thread> {
+    return this.request("session.label", { id, label }, ThreadRecordSchema);
   }
-  sessionFork(id: string): Promise<ReviewSession> {
-    return this.request("session.fork", { id }, SessionRecordSchema);
+  sessionFork(id: string): Promise<Thread> {
+    return this.request("session.fork", { id }, ThreadRecordSchema);
   }
-  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<ReviewSession> {
+  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<Thread> {
     return this.request(
       "session.restoreBlock",
       line === undefined ? { id, baseBlockIndex } : { id, baseBlockIndex, line },
-      SessionRecordSchema,
+      ThreadRecordSchema,
     );
   }
-  sessionCurate(id: string, rejections: HunkRejection[]): Promise<ReviewSession> {
-    return this.request("session.curate", { id, rejections }, SessionRecordSchema);
+  sessionCurate(id: string, rejections: HunkRejection[]): Promise<Thread> {
+    return this.request("session.curate", { id, rejections }, ThreadRecordSchema);
   }
-  sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
-    return this.request("session.setViewed", { id, viewedPaths }, SessionRecordSchema);
+  sessionSetViewed(id: string, viewedPaths: string[]): Promise<Thread> {
+    return this.request("session.setViewed", { id, viewedPaths }, ThreadRecordSchema);
   }
-  sessionSetTitle(id: string, title: string): Promise<ReviewSession> {
-    return this.request("session.setTitle", { id, title }, SessionRecordSchema);
+  sessionSetTitle(id: string, title: string): Promise<Thread> {
+    return this.request("session.setTitle", { id, title }, ThreadRecordSchema);
   }
   projectFiles(sessionId: string): Promise<string[]> {
     return this.request("session.projectFiles", { id: sessionId }, v.array(v.string()));
@@ -479,24 +482,24 @@ export class DaemonClient implements SessionClient {
       v.object({ patch: v.string(), files: v.array(DiffFileContentsSchema) }),
     );
   }
-  sessionWorkbench(cwd: string): Promise<ReviewSession> {
-    return this.request("session.workbench", { cwd }, SessionRecordSchema);
+  sessionWorkbench(cwd: string): Promise<Thread> {
+    return this.request("session.workbench", { cwd }, ThreadRecordSchema);
   }
   /** Re-capture a diff session's working tree; changed=true when the patch moved and an event fired. */
   sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
     return this.request("session.refreshDiff", { id }, RefreshDiffResultSchema);
   }
-  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession> {
-    return this.request("session.setShareId", { id, shareId }, SessionRecordSchema);
+  sessionSetShareId(id: string, shareId: string): Promise<Thread> {
+    return this.request("session.setShareId", { id, shareId }, ThreadRecordSchema);
   }
-  sessionMergeShared(id: string, incoming: SharedMerge): Promise<ReviewSession> {
-    return this.request("session.mergeShared", { id, ...incoming }, SessionRecordSchema);
+  sessionMergeShared(id: string, incoming: SharedMerge): Promise<Thread> {
+    return this.request("session.mergeShared", { id, ...incoming }, ThreadRecordSchema);
   }
   sessionDelete(id: string): Promise<void> {
     return this.request("session.delete", { id }, EmptyResultSchema).then(() => undefined);
   }
   /** Local sessions have no collaborator self-name; the share client owns this. */
-  sessionSetSelfName(id: string, _name: string): Promise<ReviewSession> {
+  sessionSetSelfName(id: string, _name: string): Promise<Thread> {
     return this.sessionGet(id);
   }
   sessionResolve(
@@ -504,22 +507,22 @@ export class DaemonClient implements SessionClient {
     verdictKind: VerdictKind,
     summary: string,
     actionBodies?: Record<string, string>,
-  ): Promise<ReviewSession> {
+  ): Promise<Thread> {
     return this.request(
       "session.resolve",
       { id, verdictKind, summary, actionBodies },
-      SessionRecordSchema,
+      ThreadRecordSchema,
     );
   }
   sessionSubmitRevision(
     id: string,
     content: string,
     addressedAnnotationIds: string[] = [],
-  ): Promise<ReviewSession> {
+  ): Promise<Thread> {
     return this.request(
       "session.submitRevision",
       { id, content, addressedAnnotationIds },
-      SessionRecordSchema,
+      ThreadRecordSchema,
     );
   }
   /** herdr adapter scratch: the tab opened for a review; local-only, off the SessionClient contract. */

package/src/herdr-pane.test.ts

@@ -4,7 +4,7 @@ import { afterAll, describe, expect, test } from "bun:test";
 import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { openHerdrPane, openHerdrPaneForReview } from "./herdr-pane";
 import type { HerdrTabPersistence } from "./herdr-pane";
 import type { HerdrTabHandle } from "./herdr-tab-store";
@@ -58,7 +58,7 @@ function fakePersistence(initial: HerdrTabHandle | null = null) {
   };
 }
 
-function newSession(overrides: Partial<ReviewSession> = {}): ReviewSession {
+function newSession(overrides: Partial<Thread> = {}): Thread {
   return {
     schemaVersion: "1",
     id: "ses_new1",

package/src/herdr-pane.ts

@@ -6,7 +6,7 @@
  * and never blocks review creation; each spawn is bounded by a timeout.
  */
 
-import { detectHerdr, type HerdrEnv, type ReviewSession } from "@cueloop/schema";
+import { detectHerdr, type HerdrEnv, type Thread } from "@cueloop/schema";
 import * as v from "valibot";
 import type { HerdrTabHandle } from "./herdr-tab-store";
 
@@ -117,7 +117,7 @@ function focusHerdrTab(binPath: string, tabId: string): void {
  * its handle. No-op outside herdr.
  */
 export async function openHerdrPaneForReview(
-  session: ReviewSession,
+  session: Thread,
   persistence: HerdrTabPersistence,
   env: HerdrEnv = process.env,
 ): Promise<void> {

package/src/herdr-tab-store.ts

@@ -1,7 +1,7 @@
 /**
  * herdr adapter scratch, kept out of the core session record: the tab cueloop
  * opened to render each review, keyed by session id. One JSON map, atomic write.
- * The core `ReviewSession` never mentions herdr; this side-store is the whole
+ * The core `Thread` never mentions herdr; this side-store is the whole
  * leak boundary.
  */
 

package/src/retention.test.ts

@@ -4,8 +4,8 @@ import { describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ReviewSession, SessionStatus } from "@cueloop/schema";
-import { SessionStore } from "./store";
+import type { Thread, SessionStatus } from "@cueloop/schema";
+import { ThreadStore } from "./store";
 import { reportsDir } from "./paths";
 import {
   DEFAULT_CLEANUP_PERIOD_DAYS,
@@ -28,7 +28,7 @@ function daysAgo(days: number): string {
   return new Date(NOW_MS - days * DAY_MS).toISOString();
 }
 
-function session(id: string, createdAt: string, status: SessionStatus = "resolved"): ReviewSession {
+function session(id: string, createdAt: string, status: SessionStatus = "resolved"): Thread {
   return {
     schemaVersion: "1",
     id,
@@ -112,7 +112,7 @@ describe("pruneExpiredSessions", () => {
   test("deletes resolved sessions past the window and keeps recent ones", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     store.upsert(session("ses_old", daysAgo(40)));
     store.upsert(session("ses_new", daysAgo(2)));
@@ -129,7 +129,7 @@ describe("pruneExpiredSessions", () => {
   test("never deletes an active pending session however old", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     store.upsert(session("ses_active", daysAgo(400), "pending"));
 
@@ -144,7 +144,7 @@ describe("pruneExpiredSessions", () => {
   test("a period of zero prunes nothing", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     store.upsert(session("ses_old", daysAgo(999)));
 

package/src/retention.ts

@@ -2,7 +2,7 @@ import { readdirSync, readFileSync, rmSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import * as v from "valibot";
-import type { SessionStore } from "./store";
+import type { ThreadStore } from "./store";
 
 export const DEFAULT_CLEANUP_PERIOD_DAYS = 30;
 export const LATEST_REPORT_FILENAME = "report.md";
@@ -68,7 +68,7 @@ export function isExpired(createdAt: string, periodDays: number, nowMs: number):
 }
 
 export function pruneExpiredSessions(
-  store: SessionStore,
+  store: ThreadStore,
   periodDays: number,
   nowMs: number,
 ): string[] {

package/src/review.test.ts

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { DaemonServer } from "./server";
 import { DaemonClient } from "./client";
 import { awaitResolve, openReview, resolveWorkspace } from "./review";
@@ -246,7 +246,7 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
   test("onProgress sees fresh sessions between chunks; the verdict ends the loop", async () => {
     // Arrange
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    const seen: ReviewSession[] = [];
+    const seen: Thread[] = [];
     const waiting = review.awaitVerdict({
       timeoutMs: Infinity,
       pollMs: 100,

package/src/review.ts

@@ -12,7 +12,7 @@ import {
   newAnnotationId,
   type ArtifactType,
   type DiffFileContents,
-  type ReviewSession,
+  type Thread,
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { verdictResponse } from "./api";
@@ -129,7 +129,7 @@ export interface AwaitVerdictOptions {
   /** Chunk length for the poll loop; between chunks the session is re-read for progress. */
   pollMs?: number;
   /** Called with the fresh session after each chunk that is still pending. */
-  onProgress?: (session: ReviewSession) => void;
+  onProgress?: (session: Thread) => void;
   signal?: AbortSignal;
 }
 
@@ -137,13 +137,13 @@ export interface AwaitVerdictOptions {
 export interface VerdictOutcome {
   allow: boolean;
   feedback: string;
-  session: ReviewSession;
+  session: Thread;
 }
 
 export class ReviewHandle {
   constructor(
     private readonly client: DaemonClient,
-    readonly session: ReviewSession,
+    readonly session: Thread,
   ) {}
 
   get id(): string {
@@ -184,7 +184,7 @@ export class ReviewHandle {
   }
 }
 
-function outcome(session: ReviewSession): VerdictOutcome {
+function outcome(session: Thread): VerdictOutcome {
   return { ...verdictResponse(session), session };
 }
 

package/src/server.ts

@@ -308,6 +308,11 @@ export class DaemonServer {
 
       return this.core.sessionAnnotate(params.id, params.annotation, params.authorName);
     },
+    "session.comment": (_connection, request) => {
+      const params = parseParams("session.comment", request.params);
+
+      return this.core.sessionAnnotate(params.id, params.annotation, params.authorName);
+    },
     "session.removeAnnotation": (connection, request) => {
       const params = parseParams("session.removeAnnotation", request.params);
 

package/src/share-blob.ts

@@ -1,5 +1,5 @@
 /**
- * The share-blob wire format: how a ReviewSession travels from `cueloop share`
+ * The share-blob wire format: how a Thread travels from `cueloop share`
  * to the gateway. The planner's CLI packs (this is the only thing it can do -
  * it holds no encryption key); the gateway unpacks, then encrypts for R2.
  *
@@ -10,8 +10,8 @@
  */
 
 import { gzipSync, gunzipSync } from "node:zlib";
-import type { ReviewSession } from "@cueloop/schema";
-import { validateSessionRecord } from "./validate";
+import type { Thread } from "@cueloop/schema";
+import { validateThreadRecord } from "./validate";
 
 /** Decompressed ceiling for one shared session (ADR 0004's payload cap). */
 export const MAX_BLOB_BYTES = 1024 * 1024;
@@ -24,12 +24,12 @@ export const DEFAULT_SHARE_HOST = "cueloop.dev";
 export const DEFAULT_SHARE_PORT = 22;
 
 /** Serialise + compress a session for upload. */
-export function packSessionBlob(session: ReviewSession): Buffer {
+export function packSessionBlob(session: Thread): Buffer {
   return gzipSync(Buffer.from(JSON.stringify(session), "utf8"));
 }
 
 /** Decompress + validate an uploaded blob, or throw a precise reason. */
-export function unpackSessionBlob(bytes: Uint8Array): ReviewSession {
+export function unpackSessionBlob(bytes: Uint8Array): Thread {
   let json: string;
 
   try {
@@ -47,7 +47,7 @@ export function unpackSessionBlob(bytes: Uint8Array): ReviewSession {
   } catch {
     throw new Error("blob is not valid JSON");
   }
-  const parsed = validateSessionRecord(raw);
+  const parsed = validateThreadRecord(raw);
 
   if (!parsed.ok) throw new Error(`blob is not a valid session: ${parsed.error}`);
 

package/src/store.conformance.test.ts

@@ -2,16 +2,16 @@ import { mkdtempSync, writeFileSync } from "node:fs";
 import * as v from "valibot";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { MemorySessionStore, SessionStore, type SessionRepository } from "./store";
+import { MemoryThreadStore, ThreadStore, type ThreadRepository } from "./store";
 import { sessionsDir } from "./paths";
-import { runSessionStoreConformance } from "./testing/store-conformance";
+import { runThreadStoreConformance } from "./testing/store-conformance";
 
-const homes = new WeakMap<SessionRepository, string>();
+const homes = new WeakMap<ThreadRepository, string>();
 
-runSessionStoreConformance("file store", {
+runThreadStoreConformance("file store", {
   open: (records) => {
     const home = mkdtempSync(join(tmpdir(), "cueloop-store-"));
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     // records land on disk the way an earlier daemon would have written them;
     // the file name comes from the record's id when it has one
@@ -26,7 +26,7 @@ runSessionStoreConformance("file store", {
     return store;
   },
   restart: (store) => {
-    const reopened = new SessionStore(homes.get(store)!);
+    const reopened = new ThreadStore(homes.get(store)!);
 
     homes.set(reopened, homes.get(store)!);
 
@@ -34,8 +34,8 @@ runSessionStoreConformance("file store", {
   },
 });
 
-runSessionStoreConformance("memory store", {
-  open: (records) => new MemorySessionStore(records),
+runThreadStoreConformance("memory store", {
+  open: (records) => new MemoryThreadStore(records),
   // nothing persists past the instance: a restart recovers what it was seeded with
-  restart: (store) => new MemorySessionStore(store.list()),
+  restart: (store) => new MemoryThreadStore(store.list()),
 });