@cueloop/daemon 0.1.0-alpha.2 → 0.1.0-alpha.20

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.20",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
-    "./client": "./src/client.ts"
+    "./client": "./src/client.ts",
+    "./review": "./src/review.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.2",
+    "@cueloop/schema": "0.1.0-alpha.20",
     "valibot": "^1.4.2"
   },
   "publishConfig": {
@@ -25,5 +26,10 @@
     "type": "git",
     "url": "git+https://github.com/mmurakaru/cueloop.git",
     "directory": "packages/daemon"
-  }
-}
+  },
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
+  "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits"
+}

package/src/api.test.ts

@@ -24,42 +24,42 @@ afterEach(() => rmSync(home, { recursive: true, force: true }));
 
 describe("session lifecycle", () => {
   test("create → get → list", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    expect(s.status).toBe("pending");
-    expect(s.revisions.length).toBe(1);
-    expect(core.sessionGet(s.id).id).toBe(s.id);
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    expect(session.status).toBe("pending");
+    expect(session.revisions.length).toBe(1);
+    expect(core.sessionGet(session.id).id).toBe(session.id);
     expect(core.sessionList({ status: "pending" }).length).toBe(1);
   });
 
   test("annotate upserts by id; remove deletes", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, {
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "How carefully?",
     });
-    core.sessionAnnotate(s.id, {
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "Define carefully.",
     });
-    expect(core.sessionGet(s.id).annotations.length).toBe(1);
-    expect(core.sessionGet(s.id).annotations[0]!.body).toBe("Define carefully.");
-    core.sessionRemoveAnnotation(s.id, "a1");
-    expect(core.sessionGet(s.id).annotations.length).toBe(0);
+    expect(core.sessionGet(session.id).annotations.length).toBe(1);
+    expect(core.sessionGet(session.id).annotations[0]!.body).toBe("Define carefully.");
+    core.sessionRemoveAnnotation(session.id, "a1");
+    expect(core.sessionGet(session.id).annotations.length).toBe(0);
   });
 
   test("resolve produces feedback.md and maps to the agent contract", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, {
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "Spell out the steps.",
     });
-    const resolved = core.sessionResolve(s.id, "request_changes", "Needs detail.");
+    const resolved = core.sessionResolve(session.id, "request_changes", "Needs detail.");
     expect(resolved.verdict!.feedback).toContain("# Review: request changes");
     expect(resolved.verdict!.feedback).toContain("> carefully");
     expect(verdictResponse(resolved)).toEqual({ allow: false, feedback: resolved.verdict!.feedback });
@@ -69,26 +69,40 @@ describe("session lifecycle", () => {
   });
 
   test("mutating a resolved session throws", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionResolve(s.id, "approve", "");
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionResolve(session.id, "approve", "");
     expect(() =>
-      core.sessionAnnotate(s.id, { id: "a1", kind: "comment", anchor: { quote: "x", prefix: "", suffix: "" }, body: "b" }),
+      core.sessionAnnotate(session.id, { id: "a1", kind: "comment", anchor: { quote: "x", prefix: "", suffix: "" }, body: "b" }),
     ).toThrow("already resolved");
   });
 
   test("working copy stores edits and clears on revert or no-op", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionSetWorkingCopy(s.id, PLAN.content.replace("carefully", "very carefully"));
-    expect(core.sessionGet(s.id).workingCopy).toContain("very carefully");
-    core.sessionSetWorkingCopy(s.id, PLAN.content);
-    expect(core.sessionGet(s.id).workingCopy).toBeUndefined();
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionSetWorkingCopy(session.id, PLAN.content.replace("carefully", "very carefully"));
+    expect(core.sessionGet(session.id).workingCopy).toContain("very carefully");
+    core.sessionSetWorkingCopy(session.id, PLAN.content);
+    expect(core.sessionGet(session.id).workingCopy).toBeUndefined();
+  });
+
+  test("viewed paths merge, dedupe, clear on empty, and survive a daemon restart", () => {
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionSetViewed(session.id, ["src/a.ts", "src/b.ts", "src/a.ts"]);
+    expect(core.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts"]);
+    // merge-additive: a stale client sending only its own new mark loses nothing
+    core.sessionSetViewed(session.id, ["src/c.ts"]);
+    expect(core.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+    // a resumed review reads its progress back after a daemon restart
+    const reborn = new DaemonCore(home);
+    expect(reborn.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+    core.sessionSetViewed(session.id, []);
+    expect(core.sessionGet(session.id).viewedPaths).toBeUndefined();
   });
 
   test("revision reopens the session and resets working copy + verdict", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionSetWorkingCopy(s.id, PLAN.content + "\nedit");
-    core.sessionResolve(s.id, "request_changes", "redo");
-    const revised = core.sessionSubmitRevision(s.id, "# Plan v2\n");
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionSetWorkingCopy(session.id, PLAN.content + "\nedit");
+    core.sessionResolve(session.id, "request_changes", "redo");
+    const revised = core.sessionSubmitRevision(session.id, "# Plan v2\n");
     expect(revised.status).toBe("pending");
     expect(revised.verdict).toBeNull();
     expect(revised.workingCopy).toBeUndefined();
@@ -99,37 +113,37 @@ describe("session lifecycle", () => {
 
 describe("the wait contract: verdicts outlive waits", () => {
   test("wait resolves when the verdict arrives", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const wait = core.sessionWait(s.id, 5_000);
-    core.sessionResolve(s.id, "approve", "");
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const wait = core.sessionWait(session.id, 5_000);
+    core.sessionResolve(session.id, "approve", "");
     const resolved = await wait;
     expect(resolved!.verdict!.kind).toBe("approve");
   });
 
   test("wait times out to null; a later wait collects the stored verdict", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const first = await core.sessionWait(s.id, 30);
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const first = await core.sessionWait(session.id, 30);
     expect(first).toBeNull();
-    core.sessionResolve(s.id, "request_changes", "later");
-    const second = await core.sessionWait(s.id, 30);
+    core.sessionResolve(session.id, "request_changes", "later");
+    const second = await core.sessionWait(session.id, 30);
     expect(second!.verdict!.summary).toBe("later");
   });
 
   test("multiple waiters all resolve", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const waits = [core.sessionWait(s.id, 5_000), core.sessionWait(s.id, 5_000)];
-    core.sessionResolve(s.id, "approve", "");
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const waits = [core.sessionWait(session.id, 5_000), core.sessionWait(session.id, 5_000)];
+    core.sessionResolve(session.id, "approve", "");
     const results = await Promise.all(waits);
-    expect(results.every((r) => r?.status === "resolved")).toBe(true);
+    expect(results.every((result) => result?.status === "resolved")).toBe(true);
   });
 });
 
 describe("persistence and recovery", () => {
   test("sessions survive a daemon restart", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionResolve(s.id, "approve", "done");
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionResolve(session.id, "approve", "done");
     const reborn = new DaemonCore(home);
-    const recovered = reborn.sessionGet(s.id);
+    const recovered = reborn.sessionGet(session.id);
     expect(recovered.verdict!.summary).toBe("done");
   });
 
@@ -147,10 +161,10 @@ describe("persistence and recovery", () => {
 describe("events", () => {
   test("lifecycle events fire in order", () => {
     const seen: string[] = [];
-    core.onEvent((e) => seen.push(e.event));
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, { id: "a1", kind: "comment", anchor: { quote: "thing", prefix: "", suffix: "" }, body: "b" });
-    core.sessionResolve(s.id, "approve", "");
+    core.onEvent((event) => seen.push(event.event));
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    core.sessionAnnotate(session.id, { id: "a1", kind: "comment", anchor: { quote: "thing", prefix: "", suffix: "" }, body: "b" });
+    core.sessionResolve(session.id, "approve", "");
     expect(seen).toEqual(["session.created", "inbox.changed", "session.updated", "session.resolved", "inbox.changed"]);
   });
 });

package/src/api.ts

@@ -1,5 +1,5 @@
 /**
- * The daemon's method surface (#14). Transport-independent: the socket
+ * The daemon's method surface. Transport-independent: the socket
  * server and the in-process test harness both call these handlers.
  * The wait contract: verdicts outlive waits - session.wait long-polls,
  * and a verdict resolved while nobody waited is delivered on next contact.
@@ -31,7 +31,7 @@ export interface DaemonEvent {
   sessionId: string;
 }
 
-type EventListener = (e: DaemonEvent) => void;
+type EventListener = (event: DaemonEvent) => void;
 
 export class DaemonCore {
   readonly store: SessionStore;
@@ -50,12 +50,12 @@ export class DaemonCore {
   }
 
   private emit(event: EventName, sessionId: string): void {
-    for (const l of this.listeners) l({ event, sessionId });
+    for (const listener of this.listeners) listener({ event, sessionId });
   }
 
   /** True when nothing awaits a verdict - drives idle-exit. */
   hasPendingSessions(): boolean {
-    return this.store.list().some((s) => s.status === "pending");
+    return this.store.list().some((session) => session.status === "pending");
   }
 
   sessionCreate(params: { workspace: WorkspaceKey; artifact: Artifact }): ReviewSession {
@@ -78,16 +78,16 @@ export class DaemonCore {
   }
 
   sessionGet(id: string): ReviewSession {
-    const s = this.store.get(id);
-    if (!s) throw new DaemonError("not_found", `no session ${id}`);
-    return s;
+    const session = this.store.get(id);
+    if (!session) throw new DaemonError("not_found", `no session ${id}`);
+    return session;
   }
 
   sessionList(filter?: { status?: "pending" | "resolved"; workspace?: Partial<WorkspaceKey> }): ReviewSession[] {
-    return this.store.list().filter((s) => {
-      if (filter?.status && s.status !== filter.status) return false;
-      if (filter?.workspace?.repoRoot && s.workspace.repoRoot !== filter.workspace.repoRoot) return false;
-      if (filter?.workspace?.branch && s.workspace.branch !== filter.workspace.branch) return false;
+    return this.store.list().filter((session) => {
+      if (filter?.status && session.status !== filter.status) return false;
+      if (filter?.workspace?.repoRoot && session.workspace.repoRoot !== filter.workspace.repoRoot) return false;
+      if (filter?.workspace?.branch && session.workspace.branch !== filter.workspace.branch) return false;
       return true;
     });
   }
@@ -98,16 +98,16 @@ export class DaemonCore {
    * still pending - the caller re-polls later; the verdict is never lost).
    */
   sessionWait(id: string, timeoutMs: number): Promise<ReviewSession | null> {
-    const s = this.sessionGet(id);
-    if (s.status === "resolved") return Promise.resolve(s);
+    const current = this.sessionGet(id);
+    if (current.status === "resolved") return Promise.resolve(current);
     return new Promise((resolve) => {
       const list = this.waiters.get(id) ?? [];
       let done = false;
       const timer = setTimeout(() => {
         if (done) return;
         done = true;
-        const idx = list.indexOf(waiter);
-        if (idx !== -1) list.splice(idx, 1);
+        const waiterIndex = list.indexOf(waiter);
+        if (waiterIndex !== -1) list.splice(waiterIndex, 1);
         resolve(null);
       }, timeoutMs);
       const waiter = (session: ReviewSession) => {
@@ -122,72 +122,86 @@ export class DaemonCore {
   }
 
   sessionAnnotate(id: string, annotation: Omit<Annotation, "createdAt">): ReviewSession {
-    const s = this.mutable(id);
-    const existing = s.annotations.findIndex((a) => a.id === annotation.id);
+    const session = this.mutable(id);
+    const existing = session.annotations.findIndex((candidate) => candidate.id === annotation.id);
     const full: Annotation = { ...annotation, createdAt: new Date().toISOString() };
-    if (existing === -1) s.annotations.push(full);
-    else s.annotations[existing] = { ...full, createdAt: s.annotations[existing]!.createdAt };
-    this.store.upsert(s);
+    if (existing === -1) session.annotations.push(full);
+    else session.annotations[existing] = { ...full, createdAt: session.annotations[existing]!.createdAt };
+    this.store.upsert(session);
     this.emit("session.updated", id);
-    return s;
+    return session;
   }
 
   sessionRemoveAnnotation(id: string, annotationId: string): ReviewSession {
-    const s = this.mutable(id);
-    s.annotations = s.annotations.filter((a) => a.id !== annotationId);
-    this.store.upsert(s);
+    const session = this.mutable(id);
+    session.annotations = session.annotations.filter((candidate) => candidate.id !== annotationId);
+    this.store.upsert(session);
     this.emit("session.updated", id);
-    return s;
+    return session;
   }
 
   /** The reviewer's working copy; undefined clears it (revert all edits). */
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): ReviewSession {
-    const s = this.mutable(id);
-    if (workingCopy === undefined || workingCopy === s.artifact.content) delete s.workingCopy;
-    else s.workingCopy = workingCopy;
-    this.store.upsert(s);
+    const session = this.mutable(id);
+    if (workingCopy === undefined || workingCopy === session.artifact.content) delete session.workingCopy;
+    else session.workingCopy = workingCopy;
+    this.store.upsert(session);
     this.emit("session.updated", id);
-    return s;
+    return session;
+  }
+
+  /**
+   * The guided walk's viewed marks. Merge-additive: walking only ever adds
+   * marks, so concurrent or stale clients converge instead of overwriting
+   * each other. An empty array is the explicit reset.
+   */
+  sessionSetViewed(id: string, viewedPaths: string[]): ReviewSession {
+    const session = this.mutable(id);
+    if (viewedPaths.length === 0) delete session.viewedPaths;
+    else session.viewedPaths = [...new Set([...(session.viewedPaths ?? []), ...viewedPaths])];
+    this.store.upsert(session);
+    this.emit("session.updated", id);
+    return session;
   }
 
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): ReviewSession {
-    const s = this.mutable(id);
+    const session = this.mutable(id);
     const verdict: Verdict = {
       kind: verdictKind,
       summary,
-      feedback: feedbackForSession(s, verdictKind, summary),
+      feedback: feedbackForSession(session, verdictKind, summary),
       resolvedAt: new Date().toISOString(),
     };
-    s.verdict = verdict;
-    s.status = "resolved";
-    this.store.upsert(s);
+    session.verdict = verdict;
+    session.status = "resolved";
+    this.store.upsert(session);
     const parked = this.waiters.get(id) ?? [];
     this.waiters.delete(id);
-    for (const w of parked) w(s);
+    for (const parkedWaiter of parked) parkedWaiter(session);
     this.emit("session.resolved", id);
     this.emit("inbox.changed", id);
-    return s;
+    return session;
   }
 
   /** Agent resubmits: new revision becomes the artifact, session reopens. */
   sessionSubmitRevision(id: string, content: string): ReviewSession {
-    const s = this.sessionGet(id);
+    const session = this.sessionGet(id);
     const now = new Date().toISOString();
-    s.revisions.push({ revision: s.revisions.length + 1, content, submittedAt: now });
-    s.artifact = { ...s.artifact, content };
-    delete s.workingCopy;
-    s.verdict = null;
-    s.status = "pending";
-    this.store.upsert(s);
+    session.revisions.push({ revision: session.revisions.length + 1, content, submittedAt: now });
+    session.artifact = { ...session.artifact, content };
+    delete session.workingCopy;
+    session.verdict = null;
+    session.status = "pending";
+    this.store.upsert(session);
     this.emit("session.revised", id);
     this.emit("inbox.changed", id);
-    return s;
+    return session;
   }
 
   private mutable(id: string): ReviewSession {
-    const s = this.sessionGet(id);
-    if (s.status === "resolved") throw new DaemonError("resolved", `session ${id} is already resolved`);
-    return s;
+    const session = this.sessionGet(id);
+    if (session.status === "resolved") throw new DaemonError("resolved", `session ${id} is already resolved`);
+    return session;
   }
 }
 

package/src/client.ts

@@ -1,12 +1,12 @@
 /**
  * Daemon client: the one library every consumer shares - CLI verbs, the TUI,
- * adapters, and tests. Also owns the lazy-launch story (#14): connect() with
+ * adapters, and tests. Also owns the lazy-launch story: connect() with
  * autostart spawns a detached daemon when the socket is dead, then attaches.
  */
 
 import { existsSync, rmSync } from "node:fs";
 import type { Annotation, Artifact, ReviewSession, VerdictKind, WorkspaceKey } from "@cueloop/schema";
-import { LineBuffer, type EventFrame, type Response } from "./protocol";
+import { BackpressureWriter, LineBuffer, type EventFrame, type Response } from "./protocol";
 import { cueloopHome, socketPath } from "./paths";
 
 export interface ConnectOptions {
@@ -15,24 +15,25 @@ export interface ConnectOptions {
   autostart?: boolean;
 }
 
-type Pending = { resolve: (v: unknown) => void; reject: (e: Error) => void };
+type PendingRequest = { resolve: (value: unknown) => void; reject: (error: Error) => void };
 
 export class DaemonClient {
   private socket: Awaited<ReturnType<typeof Bun.connect>> | null = null;
-  private pending = new Map<number, Pending>();
+  private writer: BackpressureWriter | null = null;
+  private pending = new Map<number, PendingRequest>();
   private nextId = 1;
-  private eventListeners = new Set<(e: EventFrame) => void>();
+  private eventListeners = new Set<(event: EventFrame) => void>();
   private closed = false;
 
-  static async connect(opts: ConnectOptions = {}): Promise<DaemonClient> {
-    const home = opts.home ?? cueloopHome();
+  static async connect(options: ConnectOptions = {}): Promise<DaemonClient> {
+    const home = options.home ?? cueloopHome();
     const path = socketPath(home);
     const client = new DaemonClient();
     try {
       await client.dial(path);
       return client;
     } catch (err) {
-      if (!opts.autostart) throw err;
+      if (!options.autostart) throw err;
     }
     // Socket dead or absent: clean a stale file and spawn the daemon detached.
     if (existsSync(path)) rmSync(path, { force: true });
@@ -40,17 +41,17 @@ export class DaemonClient {
     // Generous: a cold or loaded machine pays for a runtime start before the
     // socket exists, and giving up early looks to callers like a broken daemon.
     const deadline = Date.now() + Number(process.env.CUELOOP_START_TIMEOUT_MS ?? 30_000);
-    let lastErr: unknown;
+    let lastError: unknown;
     while (Date.now() < deadline) {
       try {
         await client.dial(path);
         return client;
       } catch (err) {
-        lastErr = err;
+        lastError = err;
         await Bun.sleep(50);
       }
     }
-    throw new Error(`daemon did not come up at ${path}: ${String(lastErr)}`);
+    throw new Error(`daemon did not come up at ${path}: ${String(lastError)}`);
   }
 
   private async dial(path: string): Promise<void> {
@@ -60,27 +61,31 @@ export class DaemonClient {
       unix: path,
       socket: {
         data(_socket, data) {
-          buffer.push(data.toString(), (line) => self.handleFrame(line));
+          buffer.push(data.toString(), (line) => self.routeInboundFrame(line));
+        },
+        drain() {
+          self.writer?.drain();
         },
         close() {
           self.closed = true;
-          for (const p of self.pending.values()) p.reject(new Error("daemon connection closed"));
+          for (const pendingRequest of self.pending.values()) pendingRequest.reject(new Error("daemon connection closed"));
           self.pending.clear();
         },
         error() {},
       },
     });
+    this.writer = new BackpressureWriter(this.socket);
     // Verify liveness: a dead socket file accepts connects on some platforms
     // only to fail later, so a ping is the actual handshake.
     await this.request("daemon.ping", {}, 2_000);
   }
 
-  onEvent(listener: (e: EventFrame) => void): () => void {
+  onEvent(listener: (event: EventFrame) => void): () => void {
     this.eventListeners.add(listener);
     return () => this.eventListeners.delete(listener);
   }
 
-  private handleFrame(line: string): void {
+  private routeInboundFrame(line: string): void {
     let frame: Response | EventFrame;
     try {
       frame = JSON.parse(line) as Response | EventFrame;
@@ -88,14 +93,14 @@ export class DaemonClient {
       return;
     }
     if ("event" in frame) {
-      for (const l of this.eventListeners) l(frame);
+      for (const listener of this.eventListeners) listener(frame);
       return;
     }
-    const p = this.pending.get(frame.id);
-    if (!p) return;
+    const pendingRequest = this.pending.get(frame.id);
+    if (!pendingRequest) return;
     this.pending.delete(frame.id);
-    if (frame.error) p.reject(new DaemonClientError(frame.error.code, frame.error.message));
-    else p.resolve(frame.result);
+    if (frame.error) pendingRequest.reject(new DaemonClientError(frame.error.code, frame.error.message));
+    else pendingRequest.resolve(frame.result);
   }
 
   request<T = unknown>(method: string, params: unknown, timeoutMs = 30_000): Promise<T> {
@@ -107,16 +112,16 @@ export class DaemonClient {
         reject(new Error(`request ${method} timed out`));
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: (v) => {
+        resolve: (value) => {
           clearTimeout(timer);
-          resolve(v as T);
+          resolve(value as T);
         },
-        reject: (e) => {
+        reject: (error) => {
           clearTimeout(timer);
-          reject(e);
+          reject(error);
         },
       });
-      this.socket!.write(JSON.stringify({ id, method, params }) + "\n");
+      this.writer!.write(JSON.stringify({ id, method, params }) + "\n");
     });
   }
 
@@ -154,6 +159,9 @@ export class DaemonClient {
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession> {
     return this.request("session.setWorkingCopy", { id, workingCopy });
   }
+  sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
+    return this.request("session.setViewed", { id, viewedPaths });
+  }
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession> {
     return this.request("session.resolve", { id, verdictKind, summary });
   }

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from "./api";
-export * from "./errors";
-export * from "./validate";
-export * from "./store";
-export * from "./server";
-export * from "./protocol";
-export * from "./paths";
-export { DaemonClient, DaemonClientError, type ConnectOptions } from "./client";
+/**
+ * The daemon's public surface. Consumers reach the client and the review
+ * helpers through the ./client and ./review subpaths; this barrel carries
+ * only the two names imported bare: the server and the home-dir resolver.
+ */
+
+export { DaemonServer, type DaemonOptions } from "./server";
+export { cueloopHome } from "./paths";

package/src/protocol.ts

@@ -1,5 +1,5 @@
 /**
- * Wire protocol (#14): newline-delimited JSON over the unix socket.
+ * Wire protocol: newline-delimited JSON over the unix socket.
  * Requests: { id, method, params }  Responses: { id, result } | { id, error }
  * Events (push, after events.subscribe): { event, sessionId }
  */
@@ -25,16 +25,53 @@ export type Frame = Response | EventFrame;
 
 /** Incremental NDJSON splitter; tolerates partial writes. */
 export class LineBuffer {
-  private buf = "";
+  private buffered = "";
 
   push(chunk: string, onLine: (line: string) => void): void {
-    this.buf += chunk;
+    this.buffered += chunk;
     for (;;) {
-      const nl = this.buf.indexOf("\n");
-      if (nl === -1) return;
-      const line = this.buf.slice(0, nl).trim();
-      this.buf = this.buf.slice(nl + 1);
+      const newlineIndex = this.buffered.indexOf("\n");
+      if (newlineIndex === -1) return;
+      const line = this.buffered.slice(0, newlineIndex).trim();
+      this.buffered = this.buffered.slice(newlineIndex + 1);
       if (line) onLine(line);
     }
   }
 }
+
+/** The surface both Bun.listen and Bun.connect sockets satisfy. */
+interface WritableSocket {
+  write(data: Buffer): number;
+}
+
+/**
+ * Outbound writes honoring socket backpressure. A frame larger than the
+ * kernel buffer is written partially by the socket; the unwritten tail must
+ * wait for the drain callback or the frame truncates mid-line and the NDJSON
+ * stream corrupts for good. Frames never reorder: while a tail is pending,
+ * new writes append behind it.
+ */
+export class BackpressureWriter {
+  private pending: Buffer | null = null;
+
+  constructor(private socket: WritableSocket) {}
+
+  write(data: string): void {
+    const bytes = Buffer.from(data, "utf8");
+    if (this.pending) {
+      this.pending = Buffer.concat([this.pending, bytes]);
+      return;
+    }
+    const written = Math.max(0, this.socket.write(bytes));
+    if (written < bytes.length) this.pending = bytes.subarray(written);
+  }
+
+  /** Call from the socket's drain handler. */
+  drain(): void {
+    if (!this.pending) return;
+    const tail = this.pending;
+    this.pending = null;
+    const written = Math.max(0, this.socket.write(tail));
+    if (written < tail.length) this.pending = tail.subarray(written);
+  }
+}