@cueloop/daemon 0.1.0-alpha.97 → 0.1.0-alpha.99

package/src/store.jsonl.test.ts

@@ -28,6 +28,7 @@ describe("JSONL thread store", () => {
   test("a thread is written under a per-project bucket keyed by root commit", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(
       createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", {
@@ -36,6 +37,7 @@ describe("JSONL thread store", () => {
     );
 
     const bucket = threadBucket("abcdef0123456789", home);
+
     expect(readdirSync(bucket)).toContain("ses_a.jsonl");
   });
 
@@ -52,6 +54,7 @@ describe("JSONL thread store", () => {
   test("a repo-less thread lands in the standalone bucket", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(createTestThreadRecord("ses_s", "2026-09-01T00:00:00.000Z"));
 
@@ -60,8 +63,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 = createTestThreadRecord("ses_old", "2026-09-01T00:00:00.000Z");
+
     writeFileSync(join(sessionsDir(home), "ses_old.json"), JSON.stringify(legacy));
 
     const store = new ThreadStore(home);
@@ -80,6 +85,7 @@ describe("JSONL thread store", () => {
     const home = tmpHome();
     // a newer JSONL already holds this thread (e.g. written after a rollback)
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(
       createTestThreadRecord("ses_x", "2026-09-01T00:00:00.000Z", {
@@ -99,6 +105,7 @@ describe("JSONL thread store", () => {
     );
 
     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");
@@ -108,6 +115,7 @@ describe("JSONL thread store", () => {
   test("a long log compacts to a single line, and the record survives it", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     // more upserts than the compaction threshold
     for (let iteration = 0; iteration < 60; iteration++) {
@@ -123,9 +131,11 @@ describe("JSONL thread store", () => {
     const lines = readFileSync(file, "utf8")
       .split("\n")
       .filter((l) => l.trim());
+
     expect(lines.length).toBeLessThan(60);
     // the latest snapshot survives the compaction and a restart
     const reopened = new ThreadStore(home);
+
     reopened.recover();
     expect(reopened.get("ses_a")?.workspace.branch).toBe("b59");
   });
@@ -133,15 +143,18 @@ describe("JSONL thread store", () => {
   test("a crash's torn trailing line is skipped; the last valid snapshot wins", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     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 ThreadStore(home);
     const report = reopened.recover();
+
     expect(report.recovered).toEqual(["ses_a"]);
     expect(reopened.get("ses_a")?.id).toBe("ses_a");
 
@@ -153,6 +166,7 @@ describe("JSONL thread store", () => {
       }),
     );
     const restarted = new ThreadStore(home);
+
     restarted.recover();
     expect(restarted.get("ses_a")?.workspace.branch).toBe("after-tear");
   });

package/src/store.ts

@@ -94,6 +94,7 @@ export class ThreadStore implements ThreadRepository {
       for (const file of readdirSync(bucketPath)) {
         if (!file.endsWith(".jsonl")) continue;
         const filePath = join(bucketPath, file);
+
         try {
           const { session, lines, torn } = readThread(filePath);
 
@@ -181,19 +182,25 @@ export class ThreadStore implements ThreadRepository {
   }
 
   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;
 
     // the first write, an over-long log, and a resolved (now immutable) thread all compact to one
     // line; every other mutation is a cheap append that a torn tail on crash simply drops on read
-    if (filePath === undefined || lines >= COMPACT_THRESHOLD || session.status === "resolved") {
+    if (
+      filePath === undefined ||
+      lines >= COMPACT_THRESHOLD ||
+      session.status === "resolved" ||
+      session.messageOperations?.length
+    ) {
       this.writeWhole(session);
+      this.sessions.set(session.id, session);
 
       return;
     }
     appendFileSync(filePath, JSON.stringify(session) + "\n");
     this.lineCounts.set(session.id, lines + 1);
+    this.sessions.set(session.id, session);
   }
 
   delete(id: string): boolean {
@@ -290,9 +297,11 @@ export class MemoryThreadStore implements 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/thread-agent-validation.ts

@@ -0,0 +1,119 @@
+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("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(),
+        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"])),
+      }),
+    ),
+  ),
+  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),
+  })),
+);

package/src/thread-agent.test.ts

@@ -0,0 +1,412 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SCHEMA_VERSION, type Thread, type AgentHarnessAdapter } from "@cueloop/schema";
+import { ThreadAgentManager } from "./thread-agent";
+
+function createTestThread(home: string): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "adapter-test",
+    workspace: { repoRoot: home, branch: "main" },
+    artifact: { type: "plan", content: "Review the retry", meta: {} },
+    revisions: [],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "2026-10-04",
+  };
+}
+
+test("a non-ACP harness streams and resumes through the same Thread manager", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-harness-"));
+  const thread = createTestThread(home);
+  const sessions: (string | undefined)[] = [];
+  const adapter: AgentHarnessAdapter = {
+    id: "test-native",
+    label: "Native agent",
+    connect(options) {
+      sessions.push(options.sessionId);
+
+      return {
+        start: async () => options.sessionId ?? "native-session",
+        prompt: async () => {
+          options.onEvent({
+            kind: "tool",
+            id: "read",
+            title: "Read retry",
+            toolKind: "read",
+            status: "completed",
+          });
+          options.onEvent({ kind: "message", id: crypto.randomUUID(), text: "Native answer" });
+
+          return { outcome: "completed" as const };
+        },
+        cancel() {},
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  let manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {},
+  });
+  const finish = async () => {
+    for (let attempt = 0; manager.get(thread.id).phase.kind !== "idle" && attempt < 100; attempt++)
+      await Bun.sleep(1);
+    expect(manager.get(thread.id).phase).toEqual({ kind: "idle" });
+  };
+
+  try {
+    manager.prompt({ id: thread.id, text: "Explain" });
+    await finish();
+    expect(manager.get(thread.id).harness).toEqual({
+      id: "test-native",
+      label: "Native agent",
+      sessionId: "native-session",
+    });
+    expect(manager.get(thread.id).messages[1]?.text).toBe("Native answer");
+    const promptDiscussion = { id: manager.get(thread.id).submissions![0]!.id };
+
+    expect(manager.isReadOnly(thread.id, promptDiscussion.id)).toBe(true);
+    const promptReply = manager.reply(thread.id, promptDiscussion.id, "The prompt is clear");
+
+    expect(promptReply.comments.at(-1)?.replyTo).toBe(promptDiscussion.id);
+    const answer = manager.get(thread.id).messages[1]!;
+
+    manager.comment({
+      id: thread.id,
+      comment: {
+        id: "answer-question",
+        messageId: answer.id,
+        anchor: { quote: "Native", prefix: "", suffix: " answer", blockIndex: 0, start: 0, end: 6 },
+        body: "Explain this",
+        sent: false,
+      },
+    });
+    const replied = manager.reply(thread.id, "answer-question", "This is the explanation");
+
+    expect(replied.comments.at(-1)).toMatchObject({
+      replyTo: "answer-question",
+      messageId: answer.id,
+      sent: true,
+      author: "embedded-agent",
+    });
+    manager.comment({
+      id: thread.id,
+      comment: {
+        ...replied.comments.find((entry) => entry.id === "answer-question")!,
+        id: "answer-followup",
+        replyTo: "answer-question",
+        body: "Why?",
+        sent: false,
+      },
+    });
+    manager.prompt({ id: thread.id, text: "" });
+    expect(
+      manager.get(thread.id).submissions?.find((entry) => entry.commentId === "answer-followup")
+        ?.context,
+    ).toContain("This is the explanation");
+    await finish();
+    manager.dispose();
+    manager = new ThreadAgentManager({
+      home,
+      enabled: true,
+      adapter,
+      getThread: () => thread,
+      onChange() {},
+    });
+    manager.prompt({ id: thread.id, text: "Continue" });
+    await finish();
+    expect(sessions).toEqual([undefined, "native-session"]);
+    const other = new ThreadAgentManager({
+      home,
+      enabled: true,
+      adapter: { ...adapter, id: "another-agent" },
+      getThread: () => thread,
+      onChange() {},
+    });
+
+    expect(() => other.prompt({ id: thread.id, text: "Mix sessions" })).toThrow(
+      "different harness",
+    );
+    other.dispose();
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("the first prototype's fx records migrate without losing session identity", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-harness-migrate-"));
+  const thread = createTestThread(home);
+  const path = join(home, "thread-agents");
+
+  mkdirSync(path);
+  writeFileSync(
+    join(path, `${thread.id}.json`),
+    JSON.stringify({
+      threadId: thread.id,
+      fxSessionId: "saved-fx-session",
+      phase: { kind: "idle" },
+      messages: [],
+      tools: [],
+      comments: [],
+    }),
+  );
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: false,
+    getThread: () => thread,
+    onChange() {},
+  });
+
+  try {
+    expect(manager.get(thread.id).harness).toEqual({
+      id: "fx",
+      label: "fx",
+      sessionId: "saved-fx-session",
+    });
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("empty input is a no-op; queued comments freeze once and retries reuse their mirrors", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-queue-"));
+  const thread = createTestThread(home);
+  const prompts: string[] = [];
+  const finishes: ((outcome: "completed" | "cancelled") => void)[] = [];
+  const adapter: AgentHarnessAdapter = {
+    id: "test",
+    label: "Test",
+    connect(options) {
+      return {
+        start: async () => "session",
+        prompt: (text) => {
+          prompts.push(text);
+          options.onEvent({
+            kind: "message",
+            id: `answer-${prompts.length}`,
+            text: `Reply ${prompts.length}`,
+          });
+
+          return new Promise((resolve) => finishes.push((outcome) => resolve({ outcome })));
+        },
+        cancel() {
+          finishes.at(-1)?.("cancelled");
+        },
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {},
+  });
+  const tick = () => new Promise<void>((resolve) => setImmediate(resolve));
+
+  try {
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toEqual([]);
+    expect(manager.get(thread.id).messages).toEqual([]);
+    thread.annotations.push({
+      id: "first",
+      kind: "comment",
+      body: "Explain first",
+      anchor: {
+        quote: "Review",
+        prefix: "",
+        suffix: " the retry",
+        blockIndex: 0,
+        start: 0,
+        end: 6,
+      },
+      createdAt: thread.createdAt,
+    });
+    manager.prompt({ id: thread.id, text: "" });
+    await tick();
+    expect(manager.isReadOnly(thread.id, "first")).toBe(true);
+    thread.annotations.push({ ...thread.annotations[0]!, id: "second", body: "Explain second" });
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toHaveLength(1);
+    expect(manager.get(thread.id).submissions?.map((entry) => entry.status)).toEqual([
+      "running",
+      "queued",
+    ]);
+    finishes[0]!("completed");
+    await tick();
+    expect(prompts).toHaveLength(2);
+    expect(prompts[1]).toContain("Input: Explain second");
+    expect(prompts[1]).toContain("Reply 1");
+    finishes[1]!("cancelled");
+    await tick();
+    const failed = manager.get(thread.id).submissions![1]!;
+    const mirrors = manager.get(thread.id).messages.filter((entry) => entry.role === "user");
+
+    manager.prompt({ id: thread.id, text: "", retry: failed.id });
+    await tick();
+    expect(manager.get(thread.id).messages.filter((entry) => entry.role === "user")).toEqual(
+      mirrors,
+    );
+    expect(manager.isReadOnly(thread.id, "second")).toBe(true);
+    finishes[2]!("completed");
+    await tick();
+    expect(manager.get(thread.id).submissions?.map((entry) => entry.status)).toEqual([
+      "completed",
+      "completed",
+    ]);
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toHaveLength(3);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("rejected first batches leave originals editable and create no queued turn", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-rejected-"));
+  const thread = createTestThread(home);
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter: {
+      id: "test",
+      label: "Test",
+      connect() {
+        throw new Error("A rejected batch must not start");
+      },
+    },
+    getThread: () => thread,
+    onChange() {},
+  });
+  const original = {
+    id: "valid",
+    kind: "comment",
+    body: "Explain",
+    anchor: { quote: "Review", prefix: "", suffix: " the retry", blockIndex: 0, start: 0, end: 6 },
+    createdAt: thread.createdAt,
+  };
+
+  try {
+    thread.annotations.push(original, { ...original, id: "oversized", body: "x".repeat(320001) });
+    expect(() => manager.prompt({ id: thread.id, text: "" })).toThrow("320 KiB");
+    expect(manager.get(thread.id).messages).toEqual([]);
+    expect(manager.get(thread.id).submissions).toBeUndefined();
+    expect(manager.isReadOnly(thread.id, "valid")).toBe(false);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("prompt operation receipts survive restart without requeueing accepted inputs", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-receipt-"));
+  const thread = createTestThread(home);
+  const adapter: AgentHarnessAdapter = {
+    id: "receipt-test",
+    label: "Receipt test",
+    connect: () => ({
+      start: async () => "session",
+      prompt: () => new Promise(() => {}),
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const options = { home, enabled: true, adapter, getThread: () => thread, onChange() {} };
+  let manager = new ThreadAgentManager(options);
+
+  try {
+    const input = { id: thread.id, text: "Once", operationId: "once" };
+    const accepted = manager.prompt(input);
+
+    manager.dispose();
+    manager = new ThreadAgentManager(options);
+    const replay = manager.prompt(input);
+
+    expect(replay.promptOperations?.[0]?.result).toEqual(accepted.promptOperations?.[0]?.result);
+    expect(replay.submissions).toHaveLength(1);
+    expect(replay.promptOperations?.[0]?.outcome).toBe("failed");
+    expect(() => manager.prompt({ ...input, text: "Different" })).toThrow(
+      "Operation payload conflict",
+    );
+    manager.prompt({
+      id: thread.id,
+      text: "",
+      retry: replay.submissions![0]!.id,
+      operationId: "retry",
+    });
+    expect(manager.get(thread.id).promptOperations?.[0]?.outcome).toBe("failed");
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("retrying accepted work after a failed running-state save starts the harness once", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-start-save-"));
+  const thread = createTestThread(home);
+  const blockedPath = join(home, "thread-agents", `${thread.id}.json.tmp`);
+  let saves = 0;
+  let prompts = 0;
+  const started = Promise.withResolvers<void>();
+  const adapter: AgentHarnessAdapter = {
+    id: "start-save-test",
+    label: "Start save test",
+    connect: () => ({
+      start: async () => "session",
+      prompt: () => {
+        prompts++;
+        started.resolve();
+
+        return new Promise(() => {});
+      },
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {
+      if (++saves === 1) mkdirSync(blockedPath);
+    },
+  });
+
+  try {
+    const input = { id: thread.id, text: "Start once", operationId: "start-once" };
+
+    expect(() => manager.prompt(input)).toThrow();
+    expect(manager.get(thread.id).phase.kind).toBe("idle");
+    expect(manager.get(thread.id).submissions?.[0]?.status).toBe("queued");
+    expect(prompts).toBe(0);
+    const acceptedIds = manager.get(thread.id).promptOperations?.[0]?.result;
+
+    rmSync(blockedPath, { recursive: true });
+    const replay = manager.prompt(input);
+
+    expect(replay.promptOperations?.[0]?.result).toEqual(acceptedIds);
+    expect(replay.submissions).toHaveLength(1);
+    await started.promise;
+    expect(prompts).toBe(1);
+    manager.prompt(input);
+    expect(prompts).toBe(1);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});