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

package/src/store.jsonl.test.ts

@@ -16,9 +16,9 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { SessionStore } from "./store";
+import { ThreadStore } from "./store";
 import { migratedSessionsDir, sessionsDir, threadBucket } from "./paths";
-import { createTestSessionRecord } from "./testing/store-conformance";
+import { createTestThreadRecord } from "./testing/store-conformance";
 
 function tmpHome(): string {
   return mkdtempSync(join(tmpdir(), "cueloop-jsonl-"));
@@ -27,10 +27,10 @@ function tmpHome(): string {
 describe("JSONL thread store", () => {
   test("a thread is written under a per-project bucket keyed by root commit", () => {
     const home = tmpHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     store.recover();
     store.upsert(
-      createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+      createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", {
         workspace: { repoRoot: "/repo", branch: "main", rootCommit: "abcdef0123456789" },
       }),
     );
@@ -51,9 +51,9 @@ describe("JSONL thread store", () => {
 
   test("a repo-less thread lands in the standalone bucket", () => {
     const home = tmpHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     store.recover();
-    store.upsert(createTestSessionRecord("ses_s", "2026-09-01T00:00:00.000Z"));
+    store.upsert(createTestThreadRecord("ses_s", "2026-09-01T00:00:00.000Z"));
 
     expect(readdirSync(threadBucket(undefined, home))).toContain("ses_s.jsonl");
   });
@@ -61,10 +61,10 @@ describe("JSONL thread store", () => {
   test("boot migrates the old whole-record file and parks the original", () => {
     const home = tmpHome();
     mkdirSync(sessionsDir(home), { recursive: true });
-    const legacy = createTestSessionRecord("ses_old", "2026-09-01T00:00:00.000Z");
+    const legacy = createTestThreadRecord("ses_old", "2026-09-01T00:00:00.000Z");
     writeFileSync(join(sessionsDir(home), "ses_old.json"), JSON.stringify(legacy));
 
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     const report = store.recover();
 
     expect(report.recovered).toEqual(["ses_old"]);
@@ -79,10 +79,10 @@ describe("JSONL thread store", () => {
   test("migration never overwrites a newer JSONL with an older legacy snapshot", () => {
     const home = tmpHome();
     // a newer JSONL already holds this thread (e.g. written after a rollback)
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     store.recover();
     store.upsert(
-      createTestSessionRecord("ses_x", "2026-09-01T00:00:00.000Z", {
+      createTestThreadRecord("ses_x", "2026-09-01T00:00:00.000Z", {
         status: "pending",
         workspace: { repoRoot: "/repo", branch: "newer" },
       }),
@@ -92,13 +92,13 @@ describe("JSONL thread store", () => {
     writeFileSync(
       join(sessionsDir(home), "ses_x.json"),
       JSON.stringify(
-        createTestSessionRecord("ses_x", "2026-09-01T00:00:00.000Z", {
+        createTestThreadRecord("ses_x", "2026-09-01T00:00:00.000Z", {
           workspace: { repoRoot: "/repo", branch: "older" },
         }),
       ),
     );
 
-    const reopened = new SessionStore(home);
+    const reopened = new ThreadStore(home);
     reopened.recover();
     // the newer JSONL wins; the legacy snapshot is parked, not applied
     expect(reopened.get("ses_x")?.workspace.branch).toBe("newer");
@@ -107,12 +107,12 @@ describe("JSONL thread store", () => {
 
   test("a long log compacts to a single line, and the record survives it", () => {
     const home = tmpHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     store.recover();
     // more upserts than the compaction threshold
     for (let iteration = 0; iteration < 60; iteration++) {
       store.upsert(
-        createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+        createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", {
           status: "pending",
           workspace: { repoRoot: "/repo", branch: `b${iteration}` },
         }),
@@ -125,34 +125,34 @@ describe("JSONL thread store", () => {
       .filter((l) => l.trim());
     expect(lines.length).toBeLessThan(60);
     // the latest snapshot survives the compaction and a restart
-    const reopened = new SessionStore(home);
+    const reopened = new ThreadStore(home);
     reopened.recover();
     expect(reopened.get("ses_a")?.workspace.branch).toBe("b59");
   });
 
   test("a crash's torn trailing line is skipped; the last valid snapshot wins", () => {
     const home = tmpHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
     store.recover();
-    store.upsert(createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z"));
+    store.upsert(createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z"));
 
     // simulate a crash mid-append: a half-written line at the end
     const file = join(threadBucket(undefined, home), "ses_a.jsonl");
     appendFileSync(file, '{"id":"ses_a","half');
 
-    const reopened = new SessionStore(home);
+    const reopened = new ThreadStore(home);
     const report = reopened.recover();
     expect(report.recovered).toEqual(["ses_a"]);
     expect(reopened.get("ses_a")?.id).toBe("ses_a");
 
     // an update after a torn recovery must not fuse onto the torn fragment and vanish on restart
     reopened.upsert(
-      createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+      createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", {
         status: "pending",
         workspace: { repoRoot: "/repo", branch: "after-tear" },
       }),
     );
-    const restarted = new SessionStore(home);
+    const restarted = new ThreadStore(home);
     restarted.recover();
     expect(restarted.get("ses_a")?.workspace.branch).toBe("after-tear");
   });

package/src/store.ts

@@ -7,7 +7,7 @@
  * that fail to parse are skipped and reported, never deleted; records from before histories existed
  * are given one on read.
  *
- * `SessionRepository` is the contract every adapter satisfies; the conformance
+ * `ThreadRepository` is the contract every adapter satisfies; the conformance
  * suite in ./testing/store-conformance.ts pins it for the file store and the
  * in-memory store alike.
  */
@@ -24,9 +24,9 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { historyFromLinear, type ReviewSession } from "@cueloop/schema";
+import { historyFromLinear, type Thread } from "@cueloop/schema";
 import { migratedSessionsDir, sessionsDir, threadBucket, threadsDir } from "./paths";
-import { validateSessionRecord } from "./validate";
+import { validateThreadRecord } from "./validate";
 
 /** A thread's log is rewritten to a single snapshot line once it grows past this many, so an
  *  active thread's file never bloats unbounded while writes stay cheap appends in between. */
@@ -38,13 +38,13 @@ export interface RecoveryReport {
 }
 
 /** What the daemon needs from session storage. */
-export interface SessionRepository {
+export interface ThreadRepository {
   /** Load what is stored; called once on boot. */
   recover(): RecoveryReport;
-  get(id: string): ReviewSession | undefined;
+  get(id: string): Thread | undefined;
   /** Every session, oldest first. */
-  list(): ReviewSession[];
-  upsert(session: ReviewSession): void;
+  list(): Thread[];
+  upsert(session: Thread): void;
   /** True when a session was removed. */
   delete(id: string): boolean;
 }
@@ -54,19 +54,19 @@ export interface SessionRepository {
  * one. A record with no revision has no head to derive from and keeps
  * reading without a history - migration never loses a record.
  */
-export function withHistory(session: ReviewSession): ReviewSession {
+export function withHistory(session: Thread): Thread {
   if (session.history || session.revisions.length === 0) return session;
 
   return { ...session, history: historyFromLinear(session) };
 }
 
 /** Records in the order `list()` promises: oldest first. */
-function oldestFirst(sessions: Iterable<ReviewSession>): ReviewSession[] {
+function oldestFirst(sessions: Iterable<Thread>): Thread[] {
   return [...sessions].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
 
-export class SessionStore implements SessionRepository {
-  private sessions = new Map<string, ReviewSession>();
+export class ThreadStore implements ThreadRepository {
+  private sessions = new Map<string, Thread>();
   /** id -> its JSONL path (the bucket depends on the record's root commit, so it is tracked). */
   private files = new Map<string, string>();
   /** id -> lines in its log, so upsert knows when to compact instead of append. */
@@ -124,10 +124,10 @@ export class SessionStore implements SessionRepository {
     for (const file of readdirSync(legacyDir)) {
       if (!file.endsWith(".json")) continue;
       const legacyPath = join(legacyDir, file);
-      let session: ReviewSession;
+      let session: Thread;
 
       try {
-        const parsed = validateSessionRecord(JSON.parse(readFileSync(legacyPath, "utf8")));
+        const parsed = validateThreadRecord(JSON.parse(readFileSync(legacyPath, "utf8")));
 
         if (!parsed.ok) throw new Error(`invalid record - ${parsed.error}`);
         session = withHistory(parsed.value);
@@ -155,7 +155,7 @@ export class SessionStore implements SessionRepository {
   }
 
   /** Rewrite the thread to a single snapshot line, atomically - the first write and every compaction. */
-  private writeWhole(session: ReviewSession): void {
+  private writeWhole(session: Thread): void {
     const filePath =
       this.files.get(session.id) ??
       join(threadBucket(session.workspace.rootCommit, this.home), `${session.id}.jsonl`);
@@ -169,15 +169,15 @@ export class SessionStore implements SessionRepository {
     this.lineCounts.set(session.id, 1);
   }
 
-  get(id: string): ReviewSession | undefined {
+  get(id: string): Thread | undefined {
     return this.sessions.get(id);
   }
 
-  list(): ReviewSession[] {
+  list(): Thread[] {
     return oldestFirst(this.sessions.values());
   }
 
-  upsert(session: ReviewSession): void {
+  upsert(session: Thread): void {
     this.sessions.set(session.id, session);
     const filePath = this.files.get(session.id);
     const lines = this.lineCounts.get(session.id) ?? 0;
@@ -223,7 +223,7 @@ function readThread(filePath: string) {
     } catch {
       continue;
     }
-    const parsed = validateSessionRecord(record);
+    const parsed = validateThreadRecord(record);
 
     if (parsed.ok) {
       return {
@@ -241,8 +241,8 @@ function readThread(filePath: string) {
  * in for what a file store finds on recovery, so validation and migration are
  * exercised the same way.
  */
-export class MemorySessionStore implements SessionRepository {
-  private sessions = new Map<string, ReviewSession>();
+export class MemoryThreadStore implements ThreadRepository {
+  private sessions = new Map<string, Thread>();
 
   constructor(private readonly seed: unknown[] = []) {}
 
@@ -250,7 +250,7 @@ export class MemorySessionStore implements SessionRepository {
     const report: RecoveryReport = { recovered: [], skipped: [] };
 
     this.seed.forEach((record, index) => {
-      const parsed = validateSessionRecord(record);
+      const parsed = validateThreadRecord(record);
 
       if (!parsed.ok) {
         report.skipped.push({ file: `seed[${index}]`, error: `invalid record - ${parsed.error}` });
@@ -266,15 +266,15 @@ export class MemorySessionStore implements SessionRepository {
     return report;
   }
 
-  get(id: string): ReviewSession | undefined {
+  get(id: string): Thread | undefined {
     return this.sessions.get(id);
   }
 
-  list(): ReviewSession[] {
+  list(): Thread[] {
     return oldestFirst(this.sessions.values());
   }
 
-  upsert(session: ReviewSession): void {
+  upsert(session: Thread): void {
     this.sessions.set(session.id, session);
   }
 
@@ -282,3 +282,14 @@ export class MemorySessionStore implements SessionRepository {
     return this.sessions.delete(id);
   }
 }
+
+/** @deprecated use ThreadRepository */
+export type SessionRepository = ThreadRepository;
+/** @deprecated use ThreadStore */
+export const SessionStore = ThreadStore;
+/** @deprecated use ThreadStore */
+export type SessionStore = ThreadStore;
+/** @deprecated use MemoryThreadStore */
+export const MemorySessionStore = MemoryThreadStore;
+/** @deprecated use MemoryThreadStore */
+export type MemorySessionStore = MemoryThreadStore;

package/src/testing/store-conformance.ts

@@ -8,21 +8,21 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { SCHEMA_VERSION, type ReviewSession } from "@cueloop/schema";
-import type { SessionRepository } from "../store";
+import { SCHEMA_VERSION, type Thread } from "@cueloop/schema";
+import type { ThreadRepository } from "../store";
 
 export interface StoreHarness {
   /** A fresh, empty adapter that will recover `records` on `recover()`. */
-  open: (records: unknown[]) => SessionRepository;
+  open: (records: unknown[]) => ThreadRepository;
   /** A new adapter over whatever `store` persisted, as after a daemon restart. */
-  restart: (store: SessionRepository) => SessionRepository;
+  restart: (store: ThreadRepository) => ThreadRepository;
 }
 
-export function createTestSessionRecord(
+export function createTestThreadRecord(
   id: string,
   createdAt: string,
-  overrides: Partial<ReviewSession> = {},
-): ReviewSession {
+  overrides: Partial<Thread> = {},
+): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id,
@@ -37,15 +37,15 @@ export function createTestSessionRecord(
   };
 }
 
-export function runSessionStoreConformance(name: string, harness: StoreHarness): void {
+export function runThreadStoreConformance(name: string, harness: StoreHarness): void {
   describe(`${name} - session repository contract`, () => {
     test("a stored session reads back whole and lists oldest first", () => {
       // Arrange
       const store = harness.open([]);
 
       store.recover();
-      const newer = createTestSessionRecord("ses_b", "2026-09-02T00:00:00.000Z");
-      const older = createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z");
+      const newer = createTestThreadRecord("ses_b", "2026-09-02T00:00:00.000Z");
+      const older = createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z");
 
       // Act
       store.upsert(newer);
@@ -62,11 +62,11 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
       const store = harness.open([]);
 
       store.recover();
-      store.upsert(createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z"));
+      store.upsert(createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z"));
 
       // Act
       store.upsert(
-        createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", { status: "resolved" }),
+        createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", { status: "resolved" }),
       );
 
       // Assert
@@ -82,8 +82,8 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
       const store = harness.open([]);
 
       store.recover();
-      store.upsert(createTestSessionRecord("ses_keep", "2026-09-01T00:00:00.000Z"));
-      store.upsert(createTestSessionRecord("ses_gone", "2026-09-02T00:00:00.000Z"));
+      store.upsert(createTestThreadRecord("ses_keep", "2026-09-01T00:00:00.000Z"));
+      store.upsert(createTestThreadRecord("ses_gone", "2026-09-02T00:00:00.000Z"));
       store.delete("ses_gone");
 
       // Act
@@ -98,7 +98,7 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
 
     test("a record without a history reads as a one-branch tree whose head is the artifact", () => {
       // Arrange: written before histories existed, with two revisions and a comment
-      const legacy = createTestSessionRecord("ses_old", "2026-09-01T00:00:00.000Z", {
+      const legacy = createTestThreadRecord("ses_old", "2026-09-01T00:00:00.000Z", {
         artifact: { type: "plan", content: "v2", meta: {} },
         revisions: [
           { revision: 1, content: "v1", submittedAt: "2026-09-01T00:00:00.000Z" },
@@ -135,7 +135,7 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
     test("a record with no revision still recovers, without a history", () => {
       // Arrange
       const store = harness.open([
-        createTestSessionRecord("ses_empty", "2026-09-01T00:00:00.000Z", { revisions: [] }),
+        createTestThreadRecord("ses_empty", "2026-09-01T00:00:00.000Z", { revisions: [] }),
       ]);
 
       // Act
@@ -148,7 +148,7 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
 
     test("a record that already carries a history keeps it untouched", () => {
       // Arrange
-      const withTree = createTestSessionRecord("ses_tree", "2026-09-01T00:00:00.000Z", {
+      const withTree = createTestThreadRecord("ses_tree", "2026-09-01T00:00:00.000Z", {
         history: {
           entries: [
             {
@@ -177,7 +177,7 @@ export function runSessionStoreConformance(name: string, harness: StoreHarness):
     test("a record that fails validation is skipped and reported, never dropped from the report", () => {
       // Arrange
       const store = harness.open([
-        createTestSessionRecord("ses_good", "2026-09-01T00:00:00.000Z"),
+        createTestThreadRecord("ses_good", "2026-09-01T00:00:00.000Z"),
         { schemaVersion: SCHEMA_VERSION, id: "ses_bad" },
       ]);
 

package/src/validate.test.ts

@@ -11,12 +11,12 @@ import {
   ArtifactSchema,
   IdentitySchema,
   RevisionSchema,
-  SessionRecordSchema,
+  ThreadRecordSchema,
   VerdictSchema,
   WorkspaceSchema,
   isKnownMethod,
   parseParams,
-  validateSessionRecord,
+  validateThreadRecord,
 } from "./validate";
 import {
   ARTIFACT_TYPES,
@@ -26,7 +26,7 @@ import {
   type Artifact,
   type ArtifactMeta,
   type Identity,
-  type ReviewSession,
+  type Thread,
   type Revision,
   type Verdict,
   type WorkspaceKey,
@@ -132,7 +132,7 @@ describe("parseParams", () => {
   });
 });
 
-describe("validateSessionRecord", () => {
+describe("validateThreadRecord", () => {
   const record = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
@@ -146,12 +146,12 @@ describe("validateSessionRecord", () => {
   };
 
   test("accepts a valid record", () => {
-    expect(validateSessionRecord(record).ok).toBe(true);
+    expect(validateThreadRecord(record).ok).toBe(true);
   });
 
   test("rejects a foreign schema version with a readable reason", () => {
     // Act
-    const result = validateSessionRecord({ ...record, schemaVersion: "99" });
+    const result = validateThreadRecord({ ...record, schemaVersion: "99" });
 
     // Assert
     expect(result.ok).toBe(false);
@@ -160,7 +160,7 @@ describe("validateSessionRecord", () => {
 
   test("rejects a structurally broken record", () => {
     // Act
-    const result = validateSessionRecord({ ...record, revisions: "nope" });
+    const result = validateThreadRecord({ ...record, revisions: "nope" });
 
     // Assert
     expect(result.ok).toBe(false);
@@ -235,7 +235,7 @@ describe("wire pins", () => {
     name: "Al",
     handle: "abc",
   };
-  const fullSession: Required<ReviewSession> = {
+  const fullSession: Required<Thread> = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
     workspace: fullWorkspace,
@@ -298,7 +298,7 @@ describe("wire pins", () => {
     };
 
     // Act
-    const parsed = validateSessionRecord(record);
+    const parsed = validateThreadRecord(record);
 
     // Assert
     expect(parsed.ok).toBe(false);
@@ -317,9 +317,9 @@ describe("wire pins", () => {
     expect(entryKeys(RevisionSchema)).toEqual(keys(fullRevision));
     expect(entryKeys(VerdictSchema)).toEqual(keys(fullVerdict));
     expect(entryKeys(IdentitySchema)).toEqual(keys(fullIdentity));
-    expect(entryKeys(SessionRecordSchema)).toEqual(keys(fullSession));
+    expect(entryKeys(ThreadRecordSchema)).toEqual(keys(fullSession));
     // persisted annotations carry the stamped createdAt
-    const stored = SessionRecordSchema.entries.annotations.item;
+    const stored = ThreadRecordSchema.entries.annotations.item;
 
     expect(entryKeys(stored)).toEqual(keys(fullAnnotation));
   });

package/src/validate.ts

@@ -20,7 +20,7 @@ import {
   type ArtifactMeta,
   type DiffFileContents,
   type Identity,
-  type ReviewSession,
+  type Thread,
   type HunkRejection,
   type Revision,
   type SessionHistory,
@@ -153,6 +153,12 @@ export const Params = {
     annotation: AnnotationSchema,
     authorName: v.optional(v.string()),
   }),
+  // "session.comment" is the primary annotate method; "session.annotate" stays an accepted alias
+  "session.comment": v.object({
+    id: SessionId,
+    annotation: AnnotationSchema,
+    authorName: v.optional(v.string()),
+  }),
   "session.removeAnnotation": v.object({ id: SessionId, annotationId: NonEmpty }),
   "session.setParticipantName": v.object({ id: SessionId, author: NonEmpty, name: NonEmpty }),
   "session.setWorkingCopy": v.object({ id: SessionId, workingCopy: v.optional(v.string()) }),
@@ -315,7 +321,7 @@ export const SessionHistorySchema = v.pipe(
 );
 
 /** Persisted records are validated on recovery: a bad file is skipped, not fatal. */
-export const SessionRecordSchema = v.object({
+export const ThreadRecordSchema = v.object({
   schemaVersion: v.literal(SCHEMA_VERSION),
   id: NonEmpty,
   workspace: WorkspaceSchema,
@@ -343,12 +349,12 @@ export const SessionRecordSchema = v.object({
   shareBranch: v.optional(v.string()),
   owner: v.optional(v.string()),
   participants: v.optional(v.array(IdentitySchema)),
-} satisfies EntriesOf<ReviewSession>);
+} satisfies EntriesOf<Thread>);
 
-export function validateSessionRecord(
+export function validateThreadRecord(
   raw: Parameters<typeof v.safeParse>[1],
-): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {
-  const result = v.safeParse(SessionRecordSchema, raw);
+): { ok: true; value: v.InferOutput<typeof ThreadRecordSchema> } | { ok: false; error: string } {
+  const result = v.safeParse(ThreadRecordSchema, raw);
 
   if (result.success) return { ok: true, value: result.output };
   const issue = result.issues[0]!;
@@ -356,3 +362,8 @@ export function validateSessionRecord(
 
   return { ok: false, error: `${path ? path + ": " : ""}${issue.message}` };
 }
+
+/** @deprecated use ThreadRecordSchema */
+export const SessionRecordSchema = ThreadRecordSchema;
+/** @deprecated use validateThreadRecord */
+export const validateSessionRecord = validateThreadRecord;