@cueloop/daemon 0.1.0-alpha.11 → 0.1.0-alpha.111

package/src/testing/store-conformance.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 Thread } from "@cueloop/schema";
+import type { ThreadRepository } from "../store";
+
+export interface StoreHarness {
+  open: (records: unknown[]) => ThreadRepository;
+  restart: (store: ThreadRepository) => ThreadRepository;
+}
+
+export function createTestThreadRecord(
+  id: string,
+  createdAt: string,
+  overrides: Partial<Thread> = {},
+): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: `# ${id}`, meta: {} },
+    revisions: [{ revision: 1, content: `# ${id}`, submittedAt: createdAt }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt,
+    ...overrides,
+  };
+}
+
+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 = createTestThreadRecord("ses_b", "2026-09-02T00:00:00.000Z");
+      const older = createTestThreadRecord("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(createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z"));
+
+      // Act
+      store.upsert(
+        createTestThreadRecord("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(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
+      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 = 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" },
+          { 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([
+        createTestThreadRecord("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 = createTestThreadRecord("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([
+        createTestThreadRecord("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/thread-agent-validation.ts

@@ -0,0 +1,141 @@
+import * as v from "valibot";
+import type { ThreadAgentState } from "@cueloop/schema";
+
+const AgentAnchorSchema = v.object({
+  quote: v.pipe(v.string(), v.minLength(1), v.maxLength(32_768)),
+  prefix: v.string(),
+  suffix: v.string(),
+  blockIndex: v.number(),
+  start: v.number(),
+  end: v.number(),
+  endBlockIndex: v.optional(v.number()),
+});
+
+/** Validate agent comments at the socket and persisted transcript boundaries. */
+export const AgentCommentSchema = v.object({
+  id: v.string(),
+  messageId: v.string(),
+  anchor: AgentAnchorSchema,
+  body: v.pipe(v.string(), v.minLength(1), v.maxLength(32_768)),
+  sent: v.boolean(),
+  replyTo: v.optional(v.string()),
+  author: v.optional(v.string()),
+});
+
+/** Validate persisted agent transcripts independently of submitted artifacts. */
+const StoredAgentSchema = v.object({
+  threadId: v.string(),
+  fxSessionId: v.optional(v.string()),
+  harness: v.optional(
+    v.object({ id: v.string(), label: v.string(), sessionId: v.optional(v.string()) }),
+  ),
+  phase: v.variant("kind", [
+    v.object({ kind: v.literal("idle") }),
+    v.object({ kind: v.literal("running") }),
+    v.object({ kind: v.literal("offline") }),
+    v.object({ kind: v.literal("failed"), error: v.string() }),
+    v.object({
+      kind: v.literal("permission"),
+      permission: v.object({
+        id: v.string(),
+        title: v.string(),
+        options: v.array(
+          v.object({
+            optionId: v.string(),
+            name: v.string(),
+            kind: v.string(),
+          }),
+        ),
+      }),
+    }),
+  ]),
+  messages: v.array(
+    v.object({
+      id: v.string(),
+      role: v.picklist(["user", "agent"]),
+      text: v.string(),
+      complete: v.boolean(),
+      revision: v.number(),
+      submissionId: v.optional(v.string()),
+    }),
+  ),
+  tools: v.array(
+    v.object({
+      id: v.string(),
+      turnId: v.string(),
+      title: v.string(),
+      kind: v.string(),
+      status: v.picklist(["pending", "in_progress", "completed", "failed", "cancelled"]),
+      output: v.string(),
+      locations: v.array(v.object({ path: v.string(), line: v.optional(v.number()) })),
+    }),
+  ),
+  comments: v.array(AgentCommentSchema),
+  submissions: v.optional(
+    v.array(
+      v.object({
+        id: v.string(),
+        commentId: v.optional(v.string()),
+        messageId: v.optional(v.string()),
+        prompt: v.string(),
+        harnessPrompt: v.optional(v.string()),
+        attemptId: v.optional(v.string()),
+        quote: v.optional(v.string()),
+        context: v.optional(v.string()),
+        status: v.picklist(["queued", "running", "completed", "failed"]),
+        cancelled: v.optional(v.boolean()),
+      }),
+    ),
+  ),
+  promptOperations: v.optional(
+    v.array(
+      v.object({
+        operationId: v.string(),
+        fingerprint: v.string(),
+        result: v.array(v.string()),
+        outcome: v.optional(v.picklist(["completed", "failed", "cancelled"])),
+      }),
+    ),
+  ),
+  continuation: v.optional(v.string()),
+  handoff: v.optional(
+    v.intersect([
+      v.object({
+        target: v.string(),
+        requestedTarget: v.optional(v.string()),
+        operationId: v.string(),
+        prompt: v.optional(v.string()),
+        source: v.optional(
+          v.object({ id: v.string(), label: v.string(), sessionId: v.optional(v.string()) }),
+        ),
+      }),
+      v.variant("status", [
+        v.object({ status: v.literal("queued") }),
+        v.object({ status: v.literal("summarizing") }),
+        v.object({ status: v.literal("prepared"), text: v.string() }),
+      ]),
+    ]),
+  ),
+  configOptions: v.optional(
+    v.array(
+      v.object({
+        id: v.string(),
+        name: v.string(),
+        category: v.optional(v.string()),
+        currentValue: v.string(),
+        options: v.array(v.object({ value: v.string(), name: v.string() })),
+      }),
+    ),
+  ),
+});
+
+/** Read the first fx prototype's records without discarding their session identity. */
+export const ThreadAgentSchema: v.GenericSchema<ThreadAgentState> = v.pipe(
+  StoredAgentSchema,
+  v.transform(({ fxSessionId, ...state }) => ({
+    ...state,
+    harness:
+      state.harness ??
+      (fxSessionId ? { id: "fx", label: "fx", sessionId: fxSessionId } : undefined),
+  })),
+);