@cueloop/daemon 0.1.0-alpha.16 → 0.1.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -9,7 +9,7 @@
     "./review": "./src/review.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.16",
+    "@cueloop/schema": "0.1.0-alpha.17",
     "valibot": "^1.4.2"
   },
   "publishConfig": {

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,40 +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 s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionSetViewed(s.id, ["src/a.ts", "src/b.ts", "src/a.ts"]);
-    expect(core.sessionGet(s.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts"]);
+    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(s.id, ["src/c.ts"]);
-    expect(core.sessionGet(s.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+    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(s.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
-    core.sessionSetViewed(s.id, []);
-    expect(core.sessionGet(s.id).viewedPaths).toBeUndefined();
+    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();
@@ -113,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");
   });
 
@@ -161,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,92 +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. The full list replaces the stored one
-   * (last write wins - one reviewer walks at a time); an empty list clears
-   * the field so untouched records stay lean. Duplicates collapse here so
-   * the record never accumulates repeats from racing clients.
-   */
-  /**
-   * 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.
+   * 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 s = this.mutable(id);
-    if (viewedPaths.length === 0) delete s.viewedPaths;
-    else s.viewedPaths = [...new Set([...(s.viewedPaths ?? []), ...viewedPaths])];
-    this.store.upsert(s);
+    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 s;
+    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,6 +1,6 @@
 /**
  * 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.
  */
 
@@ -15,25 +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 writer: BackpressureWriter | null = null;
-  private pending = new Map<number, Pending>();
+  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 });
@@ -41,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> {
@@ -61,14 +61,14 @@ 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() {},
@@ -80,12 +80,12 @@ export class DaemonClient {
     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;
@@ -93,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> {
@@ -112,13 +112,13 @@ 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.writer!.write(JSON.stringify({ id, method, params }) + "\n");

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,15 +25,15 @@ 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);
     }
   }

package/src/review.test.ts

@@ -33,8 +33,8 @@ afterEach(() => {
 });
 
 function sh(args: string[], cwd: string): void {
-  const p = Bun.spawnSync(args, { cwd, stdout: "ignore", stderr: "ignore" });
-  if (p.exitCode !== 0) throw new Error(`${args.join(" ")} failed`);
+  const gitResult = Bun.spawnSync(args, { cwd, stdout: "ignore", stderr: "ignore" });
+  if (gitResult.exitCode !== 0) throw new Error(`${args.join(" ")} failed`);
 }
 
 describe("resolveWorkspace", () => {
@@ -63,13 +63,13 @@ describe("resolveWorkspace", () => {
 describe("openReview", () => {
   test("shapes the artifact: agent, derived title, cwd", async () => {
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home, agent: "test-agent" });
-    const s = review.session;
-    expect(s.status).toBe("pending");
-    expect(s.artifact.type).toBe("plan");
-    expect(s.artifact.meta.agent).toBe("test-agent");
-    expect(s.artifact.meta.title).toBe("Rollout Plan");
-    expect(s.artifact.meta.cwd).toBe(home);
-    expect(s.workspace).toEqual({ repoRoot: home, branch: "detached" });
+    const session = review.session;
+    expect(session.status).toBe("pending");
+    expect(session.artifact.type).toBe("plan");
+    expect(session.artifact.meta.agent).toBe("test-agent");
+    expect(session.artifact.meta.title).toBe("Rollout Plan");
+    expect(session.artifact.meta.cwd).toBe(home);
+    expect(session.workspace).toEqual({ repoRoot: home, branch: "detached" });
   });
 
   test("an explicit title wins; diffs never derive one from content", async () => {
@@ -150,7 +150,7 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
     const waiting = review.awaitVerdict({
       timeoutMs: Infinity,
       pollMs: 100,
-      onProgress: (s) => seen.push(s),
+      onProgress: (progress) => seen.push(progress),
     });
     await client.sessionAnnotate(review.id, {
       id: "a1",
@@ -159,8 +159,8 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
       body: "Name them.",
     });
     // give the loop a chunk to observe the annotation before resolving
-    for (let i = 0; i < 100 && !seen.some((s) => s.annotations.length === 1); i++) await Bun.sleep(20);
-    expect(seen.some((s) => s.annotations.length === 1)).toBe(true);
+    for (let i = 0; i < 100 && !seen.some((snapshot) => snapshot.annotations.length === 1); i++) await Bun.sleep(20);
+    expect(seen.some((snapshot) => snapshot.annotations.length === 1)).toBe(true);
     await client.sessionResolve(review.id, "request_changes", "Too vague.");
     const verdict = await waiting;
     if (verdict === "pending") throw new Error("expected a verdict");

package/src/review.ts

@@ -2,7 +2,7 @@
  * The shared review core: one open/wait/verdict path for every consumer -
  * CLI commands and agent adapters. openReview resolves the workspace, shapes
  * the artifact, and opens-or-revises by agentSessionId; awaitVerdict maps the
- * wait contract (#14) onto the agent contract through verdictResponse. An
+ * wait contract onto the agent contract through verdictResponse. An
  * adapter keeps only two bespoke parts: parsing its host's event shape and
  * serializing the decision in its host's contract.
  */
@@ -26,16 +26,16 @@ async function git(args: string[], cwd: string): Promise<string | null> {
   }
 }
 
-/** Workspace key resolution (#9): repo root + branch from the cwd. */
+/** Workspace key resolution: repo root + branch from the cwd. */
 export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKey> {
   const repoRoot = (await git(["rev-parse", "--show-toplevel"], cwd)) ?? cwd;
   const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)) ?? "detached";
   return { repoRoot, branch };
 }
 
-function firstHeading(md: string): string | undefined {
-  const m = md.match(/^#\s+(.+)$/m);
-  return m?.[1]?.trim();
+function firstHeading(markdown: string): string | undefined {
+  const headingMatch = markdown.match(/^#\s+(.+)$/m);
+  return headingMatch?.[1]?.trim();
 }
 
 export interface OpenReviewOptions {
@@ -115,13 +115,13 @@ function raceAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Pro
     };
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
-      (v) => {
+      (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve(v);
+        resolve(value);
       },
-      (e) => {
+      (error) => {
         signal.removeEventListener("abort", onAbort);
-        reject(e);
+        reject(error);
       },
     );
   });
@@ -140,11 +140,11 @@ export class ReviewHandle {
   /**
    * Block on the verdict. "pending" means the budget ran out or the signal
    * aborted - the session stays open and the verdict is collectable later
-   * (verdicts outlive waits, #14). With only timeoutMs this is one long-poll;
+   * (verdicts outlive waits). With only timeoutMs this is one long-poll;
    * pollMs/onProgress/signal switch to the chunked loop.
    */
-  async awaitVerdict(opts: AwaitVerdictOptions): Promise<VerdictOutcome | "pending"> {
-    const { timeoutMs, pollMs, onProgress, signal } = opts;
+  async awaitVerdict(options: AwaitVerdictOptions): Promise<VerdictOutcome | "pending"> {
+    const { timeoutMs, pollMs, onProgress, signal } = options;
     if (pollMs === undefined && onProgress === undefined && signal === undefined) {
       const resolved = await this.client.sessionWait(this.session.id, timeoutMs);
       return resolved === null ? "pending" : outcome(resolved);
@@ -170,38 +170,38 @@ function outcome(session: ReviewSession): VerdictOutcome {
 }
 
 /** Open a review session (or revise the agent session's existing one) and hand back the wait surface. */
-export async function openReview(client: DaemonClient, opts: OpenReviewOptions): Promise<ReviewHandle> {
-  const cwd = opts.cwd ?? process.cwd();
-  const workspace = opts.workspace ?? (await resolveWorkspace(cwd));
+export async function openReview(client: DaemonClient, options: OpenReviewOptions): Promise<ReviewHandle> {
+  const cwd = options.cwd ?? process.cwd();
+  const workspace = options.workspace ?? (await resolveWorkspace(cwd));
   // Resubmits from the same agent session become revisions, not new sessions.
-  if (opts.agentSessionId !== undefined) {
+  if (options.agentSessionId !== undefined) {
     const existing = (await client.sessionList()).find(
-      (s) => s.artifact.meta.agentSessionId === opts.agentSessionId,
+      (candidate) => candidate.artifact.meta.agentSessionId === options.agentSessionId,
     );
     if (existing !== undefined) {
-      let revised = await client.sessionSubmitRevision(existing.id, opts.content);
-      if (opts.notes?.length) {
-        await attachNotes(client, revised.id, opts.notes);
+      let revised = await client.sessionSubmitRevision(existing.id, options.content);
+      if (options.notes?.length) {
+        await attachNotes(client, revised.id, options.notes);
         revised = await client.sessionGet(revised.id);
       }
       return new ReviewHandle(client, revised);
     }
   }
   let session = await client.sessionCreate(workspace, {
-    type: opts.type,
-    content: opts.content,
+    type: options.type,
+    content: options.content,
     meta: {
-      agent: opts.agent,
-      agentSessionId: opts.agentSessionId,
-      planPath: opts.planPath,
-      pr: opts.pr,
-      herdrPane: opts.herdrPane,
-      title: opts.title ?? (opts.type === "plan" ? firstHeading(opts.content) : undefined),
+      agent: options.agent,
+      agentSessionId: options.agentSessionId,
+      planPath: options.planPath,
+      pr: options.pr,
+      herdrPane: options.herdrPane,
+      title: options.title ?? (options.type === "plan" ? firstHeading(options.content) : undefined),
       cwd,
     },
   });
-  if (opts.notes?.length) {
-    await attachNotes(client, session.id, opts.notes);
+  if (options.notes?.length) {
+    await attachNotes(client, session.id, options.notes);
     session = await client.sessionGet(session.id);
   }
   return new ReviewHandle(client, session);

package/src/server.test.ts

@@ -28,16 +28,16 @@ afterEach(() => {
 describe("socket round-trip", () => {
   test("ping and full session flow over the wire", async () => {
     expect((await client.ping()).pid).toBe(process.pid);
-    const s = await client.sessionCreate(WS, PLAN);
-    expect(s.status).toBe("pending");
-    await client.sessionAnnotate(s.id, {
+    const session = await client.sessionCreate(WS, PLAN);
+    expect(session.status).toBe("pending");
+    await client.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "Body text", prefix: "", suffix: "." },
       body: "More detail please.",
     });
-    const wait = client.sessionWait(s.id, 5_000);
-    await client.sessionResolve(s.id, "request_changes", "Expand it.");
+    const wait = client.sessionWait(session.id, 5_000);
+    await client.sessionResolve(session.id, "request_changes", "Expand it.");
     const resolved = (await wait)!;
     expect(resolved.verdict!.kind).toBe("request_changes");
     expect(resolved.verdict!.feedback).toContain("More detail please.");
@@ -47,18 +47,18 @@ describe("socket round-trip", () => {
     expect(client.sessionGet("nope")).rejects.toBeInstanceOf(DaemonClientError);
     try {
       await client.sessionGet("nope");
-    } catch (e) {
-      expect((e as DaemonClientError).code).toBe("not_found");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("not_found");
     }
   });
 
   test("events push to subscribed connections only", async () => {
     const observer = await DaemonClient.connect({ home });
     const seen: string[] = [];
-    observer.onEvent((e) => seen.push(e.event));
+    observer.onEvent((event) => seen.push(event.event));
     await observer.subscribe();
-    const s = await client.sessionCreate(WS, PLAN);
-    await client.sessionResolve(s.id, "approve", "");
+    const session = await client.sessionCreate(WS, PLAN);
+    await client.sessionResolve(session.id, "approve", "");
     // events are pushed async over the socket; give the loop a beat
     await Bun.sleep(50);
     expect(seen).toContain("session.created");
@@ -71,43 +71,43 @@ describe("socket round-trip", () => {
     try {
       await client.request("session.create", { artifact: { type: "plan", content: "x" } });
       throw new Error("should have thrown");
-    } catch (e) {
-      expect((e as DaemonClientError).code).toBe("invalid_params");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("invalid_params");
     }
     // wrong types
     try {
       await client.request("session.wait", { id: 42 });
       throw new Error("should have thrown");
-    } catch (e) {
-      expect((e as DaemonClientError).code).toBe("invalid_params");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("invalid_params");
     }
     // unknown method
     try {
       await client.request("session.nuke", {});
       throw new Error("should have thrown");
-    } catch (e) {
-      expect((e as DaemonClientError).code).toBe("unknown_method");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("unknown_method");
     }
     // the daemon is still fully alive afterwards
-    const s = await client.sessionCreate(WS, PLAN);
-    expect((await client.sessionGet(s.id)).id).toBe(s.id);
+    const session = await client.sessionCreate(WS, PLAN);
+    expect((await client.sessionGet(session.id)).id).toBe(session.id);
   });
 
   test("meta fields survive the wire: herdrPane set on create comes back from get", async () => {
-    const s = await client.sessionCreate(WS, {
+    const session = await client.sessionCreate(WS, {
       type: "plan",
       content: "# P",
       meta: { agent: "claude-code", herdrPane: "%7" },
     });
-    const got = await client.sessionGet(s.id);
+    const got = await client.sessionGet(session.id);
     expect(got.artifact.meta.herdrPane).toBe("%7");
     expect(got.artifact.meta.agent).toBe("claude-code");
   });
 
   test("two clients see the same state (thin-renderer model)", async () => {
     const second = await DaemonClient.connect({ home });
-    const s = await client.sessionCreate(WS, PLAN);
-    const fromSecond = await second.sessionGet(s.id);
+    const session = await client.sessionCreate(WS, PLAN);
+    const fromSecond = await second.sessionGet(session.id);
     expect(fromSecond.artifact.content).toBe(PLAN.content);
     second.close();
   });

package/src/server.ts

@@ -1,6 +1,6 @@
 /**
  * The socket server: binds DaemonCore's methods to the unix socket, owns the
- * pidfile, stale-socket cleanup, and the idle-exit timer (#14). File
+ * pidfile, stale-socket cleanup, and the idle-exit timer. File
  * permissions are the local auth: the socket and state dir are 0700/0600.
  */
 
@@ -11,7 +11,7 @@ import { isKnownMethod, parseParams } from "./validate";
 import { BackpressureWriter, LineBuffer, type Request } from "./protocol";
 import { cueloopHome, lockPath, pidPath, socketPath } from "./paths";
 
-interface Conn {
+interface Connection {
   write(data: string): void;
   subscribed: boolean;
 }
@@ -33,20 +33,20 @@ const HELD_HOMES = new Set<string>();
 export class DaemonServer {
   readonly core: DaemonCore;
   readonly home: string;
-  private conns = new Set<Conn>();
+  private connections = new Set<Connection>();
   private server: ReturnType<typeof Bun.listen> | null = null;
   private idleTimer: ReturnType<typeof setTimeout> | null = null;
   private lockFd: number | null = null;
   private readonly idleExitMs: number;
   private readonly onIdleExit: () => void;
 
-  constructor(opts: DaemonOptions = {}) {
-    this.home = opts.home ?? cueloopHome();
-    this.idleExitMs = opts.idleExitMs ?? 15 * 60 * 1000;
-    this.onIdleExit = opts.onIdleExit ?? (() => process.exit(0));
+  constructor(options: DaemonOptions = {}) {
+    this.home = options.home ?? cueloopHome();
+    this.idleExitMs = options.idleExitMs ?? 15 * 60 * 1000;
+    this.onIdleExit = options.onIdleExit ?? (() => process.exit(0));
     mkdirSync(this.home, { recursive: true, mode: 0o700 });
     this.core = new DaemonCore(this.home);
-    this.core.onEvent((e) => this.broadcast(e));
+    this.core.onEvent((event) => this.broadcast(event));
   }
 
   /**
@@ -119,19 +119,19 @@ export class DaemonServer {
     // socket file left behind is stale
     if (existsSync(path)) rmSync(path, { force: true });
     const self = this;
-    this.server = Bun.listen<{ buffer: LineBuffer; conn: Conn; writer: BackpressureWriter }>({
+    this.server = Bun.listen<{ buffer: LineBuffer; connection: Connection; writer: BackpressureWriter }>({
       unix: path,
       socket: {
         open(socket) {
           const writer = new BackpressureWriter(socket);
-          const conn: Conn = { write: (data) => writer.write(data), subscribed: false };
-          socket.data = { buffer: new LineBuffer(), conn, writer };
-          self.conns.add(conn);
+          const connection: Connection = { write: (data) => writer.write(data), subscribed: false };
+          socket.data = { buffer: new LineBuffer(), connection, writer };
+          self.connections.add(connection);
           self.scheduleIdleCheck();
         },
         data(socket, data) {
           socket.data.buffer.push(data.toString(), (line) => {
-            void self.handleLine(socket.data.conn, line);
+            void self.respondToRequestLine(socket.data.connection, line);
           });
         },
         drain(socket) {
@@ -140,7 +140,7 @@ export class DaemonServer {
           socket.data?.writer.drain();
         },
         close(socket) {
-          self.conns.delete(socket.data.conn);
+          self.connections.delete(socket.data.connection);
           self.scheduleIdleCheck();
         },
         error() {},
@@ -161,9 +161,9 @@ export class DaemonServer {
     this.releaseLock();
   }
 
-  private broadcast(e: DaemonEvent): void {
-    const frame = JSON.stringify(e) + "\n";
-    for (const c of this.conns) if (c.subscribed) c.write(frame);
+  private broadcast(event: DaemonEvent): void {
+    const frame = JSON.stringify(event) + "\n";
+    for (const connection of this.connections) if (connection.subscribed) connection.write(frame);
     this.scheduleIdleCheck();
   }
 
@@ -172,7 +172,7 @@ export class DaemonServer {
     if (this.idleExitMs <= 0) return;
     if (this.idleTimer) clearTimeout(this.idleTimer);
     this.idleTimer = setTimeout(() => {
-      if (this.conns.size === 0 && !this.core.hasPendingSessions()) {
+      if (this.connections.size === 0 && !this.core.hasPendingSessions()) {
         this.stop();
         this.onIdleExit();
       } else {
@@ -181,31 +181,31 @@ export class DaemonServer {
     }, this.idleExitMs);
   }
 
-  private async handleLine(conn: Conn, line: string): Promise<void> {
-    let req: Request;
+  private async respondToRequestLine(connection: Connection, line: string): Promise<void> {
+    let request: Request;
     try {
-      req = JSON.parse(line) as Request;
+      request = JSON.parse(line) as Request;
     } catch {
-      conn.write(JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) + "\n");
+      connection.write(JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) + "\n");
       return;
     }
     try {
-      const result = await this.dispatch(conn, req);
-      conn.write(JSON.stringify({ id: req.id, result }) + "\n");
+      const result = await this.dispatch(connection, request);
+      connection.write(JSON.stringify({ id: request.id, result }) + "\n");
     } catch (err) {
       const code = err instanceof DaemonError ? err.code : "internal";
       const message = err instanceof Error ? err.message : String(err);
-      conn.write(JSON.stringify({ id: req.id, error: { code, message } }) + "\n");
+      connection.write(JSON.stringify({ id: request.id, error: { code, message } }) + "\n");
     }
   }
 
-  private async dispatch(conn: Conn, req: Request): Promise<unknown> {
+  private async dispatch(connection: Connection, request: Request): Promise<unknown> {
     // The wire is untrusted JSON: validate before DaemonCore sees anything.
-    if (typeof req.method !== "string" || !isKnownMethod(req.method)) {
-      throw new DaemonError("unknown_method", `unknown method ${String(req.method)}`);
+    if (typeof request.method !== "string" || !isKnownMethod(request.method)) {
+      throw new DaemonError("unknown_method", `unknown method ${String(request.method)}`);
     }
     const core = this.core;
-    switch (req.method) {
+    switch (request.method) {
       case "daemon.ping":
         return { pid: process.pid };
       case "daemon.shutdown":
@@ -215,46 +215,46 @@ export class DaemonServer {
         }, 10);
         return {};
       case "events.subscribe":
-        conn.subscribed = true;
+        connection.subscribed = true;
         return {};
       case "session.create": {
-        const p = parseParams("session.create", req.params);
-        return core.sessionCreate({ workspace: p.workspace, artifact: p.artifact });
+        const params = parseParams("session.create", request.params);
+        return core.sessionCreate({ workspace: params.workspace, artifact: params.artifact });
       }
       case "session.get":
-        return core.sessionGet(parseParams("session.get", req.params).id);
+        return core.sessionGet(parseParams("session.get", request.params).id);
       case "session.list":
-        return core.sessionList(parseParams("session.list", req.params).filter);
+        return core.sessionList(parseParams("session.list", request.params).filter);
       case "session.wait": {
-        const p = parseParams("session.wait", req.params);
-        return core.sessionWait(p.id, p.timeoutMs);
+        const params = parseParams("session.wait", request.params);
+        return core.sessionWait(params.id, params.timeoutMs);
       }
       case "session.annotate": {
-        const p = parseParams("session.annotate", req.params);
-        return core.sessionAnnotate(p.id, p.annotation);
+        const params = parseParams("session.annotate", request.params);
+        return core.sessionAnnotate(params.id, params.annotation);
       }
       case "session.removeAnnotation": {
-        const p = parseParams("session.removeAnnotation", req.params);
-        return core.sessionRemoveAnnotation(p.id, p.annotationId);
+        const params = parseParams("session.removeAnnotation", request.params);
+        return core.sessionRemoveAnnotation(params.id, params.annotationId);
       }
       case "session.setWorkingCopy": {
-        const p = parseParams("session.setWorkingCopy", req.params);
-        return core.sessionSetWorkingCopy(p.id, p.workingCopy);
+        const params = parseParams("session.setWorkingCopy", request.params);
+        return core.sessionSetWorkingCopy(params.id, params.workingCopy);
       }
       case "session.setViewed": {
-        const p = parseParams("session.setViewed", req.params);
-        return core.sessionSetViewed(p.id, p.viewedPaths);
+        const params = parseParams("session.setViewed", request.params);
+        return core.sessionSetViewed(params.id, params.viewedPaths);
       }
       case "session.resolve": {
-        const p = parseParams("session.resolve", req.params);
-        return core.sessionResolve(p.id, p.verdictKind, p.summary);
+        const params = parseParams("session.resolve", request.params);
+        return core.sessionResolve(params.id, params.verdictKind, params.summary);
       }
       case "session.submitRevision": {
-        const p = parseParams("session.submitRevision", req.params);
-        return core.sessionSubmitRevision(p.id, p.content);
+        const params = parseParams("session.submitRevision", request.params);
+        return core.sessionSubmitRevision(params.id, params.content);
       }
       default:
-        throw new DaemonError("unknown_method", `unknown method ${req.method}`);
+        throw new DaemonError("unknown_method", `unknown method ${request.method}`);
     }
   }
 }

package/src/single-instance.test.ts

@@ -1,5 +1,5 @@
 /**
- * Single-instance guarantee (#14): one daemon per home. Two daemons over one
+ * Single-instance guarantee: one daemon per home. Two daemons over one
  * state directory means divergent in-memory sessions and clients seeing
  * whichever half they connect to.
  */
@@ -23,14 +23,14 @@ beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-lock-"));
 });
 afterEach(() => {
-  for (const s of servers.splice(0)) s.stop();
+  for (const runningServer of servers.splice(0)) runningServer.stop();
   rmSync(home, { recursive: true, force: true });
 });
 
 function server(): DaemonServer {
-  const s = new DaemonServer({ home, idleExitMs: 0 });
-  servers.push(s);
-  return s;
+  const daemonServer = new DaemonServer({ home, idleExitMs: 0 });
+  servers.push(daemonServer);
+  return daemonServer;
 }
 
 describe("one daemon per home", () => {
@@ -63,8 +63,8 @@ describe("one daemon per home", () => {
     // a pid that cannot be running (init is never a cueloop daemon, and this
     // simulates the record a crashed process leaves behind)
     writeFileSync(lockPath(home), "999999");
-    const s = server();
-    expect(s.start()).toBe(socketPath(home));
+    const daemonServer = server();
+    expect(daemonServer.start()).toBe(socketPath(home));
   });
 
   test("stopping releases the lock so a restart works", () => {
@@ -84,12 +84,12 @@ describe("one daemon per home", () => {
       DaemonClient.connect({ home, autostart: true }),
     ]);
     try {
-      const pids = await Promise.all(clients.map((c) => c.ping()));
-      const unique = new Set(pids.map((p) => p.pid));
+      const pids = await Promise.all(clients.map((client) => client.ping()));
+      const unique = new Set(pids.map((ping) => ping.pid));
       expect(unique.size).toBe(1);
       // and state is shared: one client's session is visible to the others
-      const s = await clients[0]!.sessionCreate(WS, PLAN);
-      expect((await clients[2]!.sessionGet(s.id)).id).toBe(s.id);
+      const session = await clients[0]!.sessionCreate(WS, PLAN);
+      expect((await clients[2]!.sessionGet(session.id)).id).toBe(session.id);
     } finally {
       for (const c of clients) c.close();
       // the autostarted daemon is not one of `servers` - shut it down

package/src/store.ts

@@ -1,5 +1,5 @@
 /**
- * Session persistence (#14): one JSON document per session, every write
+ * Session persistence: one JSON document per session, every write
  * through a temp file + atomic rename so a crash mid-write can never leave
  * a corrupt record. Recovery is a read-only scan; records that fail to
  * parse are skipped and reported, never deleted.
@@ -49,15 +49,15 @@ export class SessionStore {
   }
 
   list(): ReviewSession[] {
-    return [...this.sessions.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return [...this.sessions.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
   }
 
   upsert(session: ReviewSession): void {
     this.sessions.set(session.id, session);
     const path = join(this.dir, `${session.id}.json`);
-    const tmp = path + ".tmp";
-    writeFileSync(tmp, JSON.stringify(session, null, 2));
-    renameSync(tmp, path);
+    const tempPath = path + ".tmp";
+    writeFileSync(tempPath, JSON.stringify(session, null, 2));
+    renameSync(tempPath, path);
   }
 
   delete(id: string): boolean {

package/src/validate.test.ts

@@ -38,11 +38,11 @@ describe("method allowlist", () => {
 
 describe("parseParams", () => {
   test("accepts a well-formed create and defaults meta", () => {
-    const p = parseParams("session.create", {
+    const params = parseParams("session.create", {
       workspace: { repoRoot: "/repo", branch: "main" },
       artifact: { type: "plan", content: "# P" },
     });
-    expect(p.artifact.meta).toEqual({});
+    expect(params.artifact.meta).toEqual({});
   });
 
   test("rejects a missing workspace with a pathed message", () => {
@@ -81,12 +81,12 @@ describe("parseParams", () => {
   });
 
   test("annotation kinds stay open (extension kinds are allowed)", () => {
-    const p = parseParams("session.annotate", {
+    const params = parseParams("session.annotate", {
       id: "s",
       annotation: { id: "a1", kind: "praise", anchor: { quote: "x" }, body: "nice" },
     });
-    expect(p.annotation.kind).toBe("praise");
-    expect(p.annotation.anchor.prefix).toBe("");
+    expect(params.annotation.kind).toBe("praise");
+    expect(params.annotation.anchor.prefix).toBe("");
   });
 
   test("setViewed takes a full path list and rejects non-string entries", () => {
@@ -122,25 +122,25 @@ describe("validateSessionRecord", () => {
   });
 
   test("rejects a foreign schema version with a readable reason", () => {
-    const r = validateSessionRecord({ ...record, schemaVersion: "99" });
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.error).toContain("schemaVersion");
+    const result = validateSessionRecord({ ...record, schemaVersion: "99" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toContain("schemaVersion");
   });
 
   test("rejects a structurally broken record", () => {
-    const r = validateSessionRecord({ ...record, revisions: "nope" });
-    expect(r.ok).toBe(false);
+    const result = validateSessionRecord({ ...record, revisions: "nope" });
+    expect(result.ok).toBe(false);
   });
 });
 
 /**
- * Wire pins (#70): every schema's entries must cover exactly the keys of the
+ * Wire pins: every schema's entries must cover exactly the keys of the
  * schema type it mirrors. Runtime complement to the compile-time EntriesOf
  * check - the samples are fully populated and typed, so a new field in
  * @cueloop/schema shows up here too.
  */
 describe("wire pins", () => {
-  const keys = (o: object) => Object.keys(o).sort();
+  const keys = (subject: object) => Object.keys(subject).sort();
   const entryKeys = (schema: { entries: object }) => Object.keys(schema.entries).sort();
 
   const fullMeta: Required<ArtifactMeta> = {

package/src/validate.ts

@@ -1,5 +1,5 @@
 /**
- * Runtime validation of the wire boundary (#14). Everything arriving over the
+ * Runtime validation of the wire boundary. Everything arriving over the
  * socket is untrusted JSON: adapters, the CLI, extensions, and any script a
  * user writes all speak this protocol. Validating here means DaemonCore only
  * ever sees well-formed input, and a malformed request gets a precise error
@@ -67,7 +67,7 @@ export const AnchorSchema = v.object({
 /** Wire annotations arrive without createdAt - the daemon stamps it. */
 export const AnnotationSchema = v.object({
   id: NonEmpty,
-  /** Open kind set (#2): built-ins are comment and suggestion. */
+  /** Open kind set: built-ins are comment and suggestion. */
   kind: NonEmpty,
   anchor: AnchorSchema,
   body: v.string(),
@@ -118,7 +118,7 @@ export function parseParams<M extends MethodName>(method: M, params: unknown): v
   const result = v.safeParse(Params[method], params ?? {});
   if (!result.success) {
     const issue = result.issues[0]!;
-    const path = issue.path?.map((p) => String(p.key)).join(".") ?? "";
+    const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
     throw new DaemonError("invalid_params", `${method}: ${path ? path + " - " : ""}${issue.message}`);
   }
   return result.output;
@@ -156,6 +156,6 @@ export function validateSessionRecord(raw: unknown): { ok: true; value: v.InferO
   const result = v.safeParse(SessionRecordSchema, raw);
   if (result.success) return { ok: true, value: result.output };
   const issue = result.issues[0]!;
-  const path = issue.path?.map((p) => String(p.key)).join(".") ?? "";
+  const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
   return { ok: false, error: `${path ? path + ": " : ""}${issue.message}` };
 }