@cueloop/daemon 0.1.0-alpha.64 → 0.1.0-alpha.65

package/src/testing/store-conformance.ts

@@ -0,0 +1,194 @@
+/**
+ * The session repository contract as executable cases. Every adapter runs the
+ * same suite: what a store returns, in which order, what survives a restart,
+ * what a bad record does, and how a record without a history reads.
+ *
+ * `restart` gives back a fresh adapter over the same persisted state (or the
+ * same seed) so recovery is tested through the contract, never past it.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type ReviewSession } from "@cueloop/schema";
+import type { SessionRepository } from "../store";
+
+export interface StoreHarness {
+  /** A fresh, empty adapter that will recover `records` on `recover()`. */
+  open: (records: unknown[]) => SessionRepository;
+  /** A new adapter over whatever `store` persisted, as after a daemon restart. */
+  restart: (store: SessionRepository) => SessionRepository;
+}
+
+export function createTestSessionRecord(
+  id: string,
+  createdAt: string,
+  overrides: Partial<ReviewSession> = {},
+): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: `# ${id}`, meta: {} },
+    revisions: [{ revision: 1, content: `# ${id}`, submittedAt: createdAt }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt,
+    ...overrides,
+  };
+}
+
+export function runSessionStoreConformance(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");
+
+      // Act
+      store.upsert(newer);
+      store.upsert(older);
+
+      // Assert
+      expect(store.get("ses_a")).toEqual(older);
+      expect(store.list().map((session) => session.id)).toEqual(["ses_a", "ses_b"]);
+      expect(store.get("ses_zzz")).toBeUndefined();
+    });
+
+    test("upsert replaces by id and delete reports whether anything was removed", () => {
+      // Arrange
+      const store = harness.open([]);
+
+      store.recover();
+      store.upsert(createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z"));
+
+      // Act
+      store.upsert(
+        createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", { status: "resolved" }),
+      );
+
+      // Assert
+      expect(store.list()).toHaveLength(1);
+      expect(store.get("ses_a")?.status).toBe("resolved");
+      expect(store.delete("ses_a")).toBe(true);
+      expect(store.delete("ses_a")).toBe(false);
+      expect(store.list()).toEqual([]);
+    });
+
+    test("what was upserted survives a restart, deletions included", () => {
+      // Arrange
+      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.delete("ses_gone");
+
+      // Act
+      const reopened = harness.restart(store);
+      const report = reopened.recover();
+
+      // Assert
+      expect(report.recovered).toEqual(["ses_keep"]);
+      expect(reopened.get("ses_keep")?.artifact.content).toBe("# ses_keep");
+      expect(reopened.get("ses_gone")).toBeUndefined();
+    });
+
+    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", {
+        artifact: { type: "plan", content: "v2", meta: {} },
+        revisions: [
+          { revision: 1, content: "v1", submittedAt: "2026-09-01T00:00:00.000Z" },
+          { revision: 2, content: "v2", submittedAt: "2026-09-01T02:00:00.000Z" },
+        ],
+        annotations: [
+          {
+            id: "a1",
+            kind: "comment",
+            anchor: { quote: "v1", prefix: "", suffix: "" },
+            body: "why",
+            createdAt: "2026-09-01T01:00:00.000Z",
+          },
+        ],
+      });
+      const store = harness.open([legacy]);
+
+      // Act
+      const report = store.recover();
+      const history = store.get("ses_old")?.history;
+
+      // Assert
+      expect(report.recovered).toEqual(["ses_old"]);
+      expect(history?.branch).toBe("main");
+      expect(history?.entries.map((entry) => entry.type)).toEqual([
+        "revision",
+        "comment",
+        "revision",
+      ]);
+      expect(history?.entries.at(-1)).toMatchObject({ type: "revision", content: "v2" });
+      expect(history?.tips.main).toBe(history?.entries.at(-1)?.id);
+    });
+
+    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: [] }),
+      ]);
+
+      // Act
+      const report = store.recover();
+
+      // Assert
+      expect(report.recovered).toEqual(["ses_empty"]);
+      expect(store.get("ses_empty")?.history).toBeUndefined();
+    });
+
+    test("a record that already carries a history keeps it untouched", () => {
+      // Arrange
+      const withTree = createTestSessionRecord("ses_tree", "2026-09-01T00:00:00.000Z", {
+        history: {
+          entries: [
+            {
+              id: "root",
+              parentId: null,
+              type: "revision",
+              by: "agent",
+              content: "# ses_tree",
+              createdAt: "2026-09-01T00:00:00.000Z",
+            },
+          ],
+          tips: { main: "root", ramble: "root" },
+          branch: "ramble",
+          labels: { root: "start" },
+        },
+      });
+      const store = harness.open([withTree]);
+
+      // Act
+      store.recover();
+
+      // Assert
+      expect(store.get("ses_tree")?.history).toEqual(withTree.history);
+    });
+
+    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"),
+        { schemaVersion: SCHEMA_VERSION, id: "ses_bad" },
+      ]);
+
+      // Act
+      const report = store.recover();
+
+      // Assert
+      expect(report.recovered).toEqual(["ses_good"]);
+      expect(report.skipped).toHaveLength(1);
+      expect(report.skipped[0]!.error).toContain("invalid record");
+      expect(store.get("ses_bad")).toBeUndefined();
+    });
+  });
+}

package/src/validate.test.ts

@@ -192,6 +192,7 @@ describe("wire pins", () => {
     prefix: "p",
     suffix: "s",
     blockIndex: 0,
+    endBlockIndex: 0,
     start: 0,
     end: 1,
     selector: "div.card",
@@ -203,6 +204,7 @@ describe("wire pins", () => {
     body: "b",
     orphan: false,
     author: "SHA256:abc",
+    replyTo: "a0",
     resolution: { revision: 2, source: "agent" },
     createdAt: "now",
   };
@@ -233,6 +235,36 @@ describe("wire pins", () => {
     artifact: fullArtifact,
     revisions: [fullRevision],
     annotations: [fullAnnotation],
+    history: {
+      entries: [
+        {
+          id: "e1",
+          parentId: null,
+          type: "revision",
+          by: "agent",
+          content: "# P",
+          createdAt: "now",
+        },
+        { id: "e2", parentId: "e1", type: "comment", annotationId: "a1", createdAt: "now" },
+        { id: "e3", parentId: "e2", type: "comment-removed", annotationId: "a1", createdAt: "now" },
+        { id: "e4", parentId: "e3", type: "verdict", verdict: fullVerdict, createdAt: "now" },
+        {
+          id: "e5",
+          parentId: "e4",
+          type: "branch-summary",
+          text: "tried a thing",
+          abandoned: ["e3"],
+          createdAt: "now",
+        },
+      ],
+      tips: { main: "e5" },
+      branch: "main",
+      labels: { e1: "start" },
+    },
+    curation: [{ path: "src/a.ts", hunkIndex: 0, changeIndex: 1 }],
+    shelvedAnnotations: [fullAnnotation],
+    parentSessionId: "ses_0",
+    shareBranch: "main",
     workingCopy: "# P edited",
     viewedPaths: ["src/a.ts"],
     verdict: fullVerdict,
@@ -243,6 +275,29 @@ describe("wire pins", () => {
     participants: [fullIdentity],
   };
 
+  test("a history whose tree is broken is refused even when every entry is well-formed", () => {
+    // Arrange: a parent cycle
+    const record = {
+      ...fullSession,
+      history: {
+        entries: [
+          { id: "a", parentId: "b", type: "revision", by: "agent", content: "x", createdAt: "now" },
+          { id: "b", parentId: "a", type: "comment", annotationId: "a1", createdAt: "now" },
+        ],
+        tips: { main: "b" },
+        branch: "main",
+        labels: {},
+      },
+    };
+
+    // Act
+    const parsed = validateSessionRecord(record);
+
+    // Assert
+    expect(parsed.ok).toBe(false);
+    if (!parsed.ok) expect(parsed.error).toContain("history:");
+  });
+
   test("schema key sets match the schema types", () => {
     expect(entryKeys(WorkspaceSchema)).toEqual(keys(fullWorkspace));
     expect(entryKeys(ArtifactMetaSchema)).toEqual(keys(fullMeta));

package/src/validate.ts

@@ -20,7 +20,10 @@ import {
   type DiffFileContents,
   type Identity,
   type ReviewSession,
+  type HunkRejection,
   type Revision,
+  type SessionHistory,
+  validateHistory,
   type Verdict,
   type WorkspaceKey,
 } from "@cueloop/schema";
@@ -75,6 +78,7 @@ export const AnchorSchema = v.object({
   prefix: v.optional(v.string(), ""),
   suffix: v.optional(v.string(), ""),
   blockIndex: v.optional(v.number()),
+  endBlockIndex: v.optional(v.number()),
   start: v.optional(v.number()),
   end: v.optional(v.number()),
   selector: v.optional(v.string()),
@@ -89,6 +93,7 @@ export const AnnotationSchema = v.object({
   body: v.string(),
   orphan: v.optional(v.boolean()),
   author: v.optional(v.string()),
+  replyTo: v.optional(NonEmpty),
   resolution: v.optional(
     v.object({
       revision: v.number(),
@@ -137,8 +142,39 @@ export const Params = {
     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()) }),
+  "session.cutBlock": v.object({
+    id: SessionId,
+    blockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+  }),
+  "session.restoreBlock": v.object({
+    id: SessionId,
+    baseBlockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    line: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+  }),
+  "session.curate": v.object({
+    id: SessionId,
+    rejections: v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+        changeIndex: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  }),
   "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.navigate": v.object({
+    id: SessionId,
+    entryId: NonEmpty,
+    summary: v.optional(v.string()),
+    // stand on this branch first, so a move on another branch is one request
+    branch: v.optional(NonEmpty),
+  }),
+  "session.branch": v.object({ id: SessionId, name: NonEmpty }),
+  "session.switch": v.object({ id: SessionId, branch: NonEmpty }),
+  "session.label": v.object({ id: SessionId, label: NonEmpty }),
+  "session.fork": v.object({ id: SessionId }),
   "session.refreshDiff": v.object({ id: SessionId }),
   "session.setShareId": v.object({ id: SessionId, shareId: NonEmpty }),
   "session.delete": v.object({ id: SessionId }),
@@ -146,6 +182,10 @@ export const Params = {
     id: SessionId,
     annotations: v.array(FullAnnotationSchema),
     participants: v.optional(v.array(IdentitySchema)),
+    // the removal entries a share recorded, carried by id so a merge applies each once
+    removals: v.optional(
+      v.array(v.object({ id: NonEmpty, annotationId: NonEmpty, createdAt: v.string() })),
+    ),
   }),
   "session.resolve": v.object({
     id: SessionId,
@@ -160,7 +200,13 @@ export const Params = {
   }),
   "events.subscribe": v.object({}),
   "daemon.ping": v.object({}),
-  "daemon.hello": v.object({ role: v.picklist(["owner", "collaborator", "agent"]) }),
+  // the owner token proves ownership; without it a request for owner stays a collaborator
+  "daemon.hello": v.object({
+    role: v.picklist(["owner", "collaborator", "agent"]),
+    token: v.optional(v.string()),
+    // the author a non-owner acts as, bound once for the connection
+    author: v.optional(NonEmpty),
+  }),
   "daemon.shutdown": v.object({}),
   // herdr adapter scratch: the review's opened tab, kept off the session record.
   "herdr.getTab": v.object({ id: SessionId }),
@@ -206,6 +252,47 @@ export const VerdictSchema = v.object({
   resolvedAt: v.string(),
 } satisfies EntriesOf<Verdict>);
 
+const EntryBaseEntries = {
+  id: NonEmpty,
+  parentId: v.nullable(NonEmpty),
+  createdAt: v.string(),
+};
+
+/** One record of a session's history; the tree pointers plus the entry's own fields. */
+export const SessionEntrySchema = v.variant("type", [
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("revision"),
+    by: v.picklist(["agent", "reviewer"]),
+    content: v.string(),
+  }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment-removed"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("verdict"), verdict: VerdictSchema }),
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("branch-summary"),
+    text: v.string(),
+    abandoned: v.array(NonEmpty),
+  }),
+]);
+
+export const SessionHistorySchema = v.pipe(
+  v.object({
+    entries: v.array(SessionEntrySchema),
+    tips: v.record(v.string(), NonEmpty),
+    branch: NonEmpty,
+    labels: v.record(v.string(), v.string()),
+  } satisfies EntriesOf<SessionHistory>),
+  // the shape is not enough: the tree itself must hold, or a walk hangs or rewires the path
+  v.rawCheck(({ dataset, addIssue }) => {
+    if (!dataset.typed) return;
+    const problem = validateHistory(dataset.value);
+
+    if (problem !== null) addIssue({ message: `history: ${problem}` });
+  }),
+);
+
 /** Persisted records are validated on recovery: a bad file is skipped, not fatal. */
 export const SessionRecordSchema = v.object({
   schemaVersion: v.literal(SCHEMA_VERSION),
@@ -214,12 +301,25 @@ export const SessionRecordSchema = v.object({
   artifact: ArtifactSchema,
   revisions: v.array(RevisionSchema),
   annotations: v.array(FullAnnotationSchema),
+  history: v.optional(SessionHistorySchema),
+  curation: v.optional(
+    v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.number(),
+        changeIndex: v.optional(v.number()),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  ),
   workingCopy: v.optional(v.string()),
   viewedPaths: v.optional(v.array(v.string())),
   verdict: v.nullable(VerdictSchema),
   status: v.picklist(["pending", "resolved"]),
   createdAt: v.string(),
+  shelvedAnnotations: v.optional(v.array(FullAnnotationSchema)),
+  parentSessionId: v.optional(v.string()),
   shareId: v.optional(v.string()),
+  shareBranch: v.optional(v.string()),
   owner: v.optional(v.string()),
   participants: v.optional(v.array(IdentitySchema)),
 } satisfies EntriesOf<ReviewSession>);