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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.62",
+  "version": "0.1.0-alpha.64",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -23,6 +23,7 @@
     "./review": "./src/review.ts",
     "./working-tree": "./src/working-tree.ts",
     "./store": "./src/store.ts",
+    "./validate": "./src/validate.ts",
     "./paths": "./src/paths.ts",
     "./retention": "./src/retention.ts",
     "./herdr-pane": "./src/herdr-pane.ts",
@@ -33,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.62",
+    "@cueloop/schema": "0.1.0-alpha.64",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/api.ts

@@ -442,7 +442,7 @@ function isLiveDiffSession(session: ReviewSession): boolean {
 }
 
 /** Convenience for adapters: map a resolved session to the agent contract. */
-export function verdictResponse(session: ReviewSession): { allow: boolean; feedback: string } {
+export function verdictResponse(session: ReviewSession) {
   if (!session.verdict) throw new DaemonError("pending", "session has no verdict");
 
   return { allow: verdictAllows(session.verdict.kind), feedback: session.verdict.feedback };

package/src/capabilities.ts

@@ -6,6 +6,8 @@
  * This is the single source of truth the server dispatch enforces.
  */
 
+import * as v from "valibot";
+
 export type DaemonRole = "owner" | "collaborator" | "agent";
 
 /** Methods a non-owner role may call: read the session and annotate, plus connection plumbing. */
@@ -24,7 +26,8 @@ export function roleAllowsMethod(role: DaemonRole, method: string): boolean {
   return role === "owner" || NON_OWNER_METHODS.has(method);
 }
 
-/** Parse an untrusted role string, defaulting unknown values to the capped "agent". */
-export function asDaemonRole(value: unknown): DaemonRole {
-  return value === "owner" || value === "collaborator" ? value : "agent";
+export function asDaemonRole(value: Parameters<typeof v.safeParse>[1]): DaemonRole {
+  const result = v.safeParse(v.picklist(["owner", "collaborator"]), value);
+
+  return result.success ? result.output : "agent";
 }

package/src/client.ts

@@ -5,6 +5,7 @@
  */
 
 import { existsSync, rmSync } from "node:fs";
+import * as v from "valibot";
 import type {
   Annotation,
   Artifact,
@@ -13,10 +14,18 @@ import type {
   VerdictKind,
   WorkspaceKey,
 } from "@cueloop/schema";
-import { BackpressureWriter, LineBuffer, type EventFrame, type Response } from "./protocol";
+import {
+  BackpressureWriter,
+  LineBuffer,
+  parseInboundFrame,
+  type EventFrame,
+  type Request,
+  type Response,
+} from "./protocol";
 import type { DaemonRole } from "./capabilities";
 import type { HerdrTabHandle } from "./herdr-tab-store";
 import { cueloopHome, socketPath } from "./paths";
+import { SessionRecordSchema } from "./validate";
 
 export type { EventFrame } from "./protocol";
 
@@ -28,7 +37,15 @@ export interface ConnectOptions {
   role?: DaemonRole;
 }
 
-type PendingRequest = { resolve: (value: unknown) => void; reject: (error: Error) => void };
+type PendingRequest = {
+  resolve: (value: Response["result"]) => void;
+  reject: (error: Error) => void;
+};
+
+const EmptyResultSchema = v.object({});
+const PingResultSchema = v.object({ pid: v.number() });
+const RefreshDiffResultSchema = v.object({ changed: v.boolean() });
+const HerdrTabResultSchema = v.nullable(v.object({ tabId: v.string(), paneId: v.string() }));
 
 /**
  * The session verbs the review controller drives. DaemonClient is the local
@@ -128,9 +145,10 @@ export class DaemonClient implements SessionClient {
     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);
+    await this.request("daemon.ping", {}, PingResultSchema, 2_000);
     // Cap this connection's role for the daemon's capability gate (owner is the default).
-    if (this.role !== "owner") await this.request("daemon.hello", { role: this.role }, 2_000);
+    if (this.role !== "owner")
+      await this.request("daemon.hello", { role: this.role }, EmptyResultSchema, 2_000);
   }
 
   onEvent(listener: (event: EventFrame) => void): () => void {
@@ -140,10 +158,10 @@ export class DaemonClient implements SessionClient {
   }
 
   private routeInboundFrame(line: string): void {
-    let frame: Response | EventFrame;
+    let frame;
 
     try {
-      frame = JSON.parse(line) as Response | EventFrame;
+      frame = parseInboundFrame(line);
     } catch {
       return;
     }
@@ -161,11 +179,16 @@ export class DaemonClient implements SessionClient {
     else pendingRequest.resolve(frame.result);
   }
 
-  request<T = unknown>(method: string, params: unknown, timeoutMs = 30_000): Promise<T> {
+  request<TOutput>(
+    method: string,
+    params: Request["params"],
+    resultSchema: v.GenericSchema<unknown, TOutput>,
+    timeoutMs = 30_000,
+  ): Promise<TOutput> {
     if (this.closed || !this.socket) return Promise.reject(new Error("not connected"));
     const id = this.nextId++;
 
-    return new Promise<T>((resolve, reject) => {
+    return new Promise<TOutput>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`request ${method} timed out`));
@@ -174,7 +197,7 @@ export class DaemonClient implements SessionClient {
       this.pending.set(id, {
         resolve: (value) => {
           clearTimeout(timer);
-          resolve(value as T);
+          resolve(v.parse(resultSchema, value));
         },
         reject: (error) => {
           clearTimeout(timer);
@@ -192,79 +215,88 @@ export class DaemonClient implements SessionClient {
 
   // ── typed verbs ─────────────────────────────
   ping(): Promise<{ pid: number }> {
-    return this.request("daemon.ping", {});
+    return this.request("daemon.ping", {}, PingResultSchema);
   }
   subscribe(): Promise<void> {
-    return this.request("events.subscribe", {});
+    return this.request("events.subscribe", {}, EmptyResultSchema).then(() => undefined);
   }
   sessionCreate(workspace: WorkspaceKey, artifact: Artifact): Promise<ReviewSession> {
-    return this.request("session.create", { workspace, artifact });
+    return this.request("session.create", { workspace, artifact }, SessionRecordSchema);
   }
   sessionGet(id: string): Promise<ReviewSession> {
-    return this.request("session.get", { id });
+    return this.request("session.get", { id }, SessionRecordSchema);
   }
   sessionList(filter?: { status?: "pending" | "resolved" }): Promise<ReviewSession[]> {
-    return this.request("session.list", { filter });
+    return this.request("session.list", { filter }, v.array(SessionRecordSchema));
   }
   /** Long-poll; null = still pending after timeoutMs (re-poll to collect). */
   sessionWait(id: string, timeoutMs: number): Promise<ReviewSession | null> {
-    return this.request("session.wait", { id, timeoutMs }, timeoutMs + 10_000);
+    return this.request(
+      "session.wait",
+      { id, timeoutMs },
+      v.nullable(SessionRecordSchema),
+      timeoutMs + 10_000,
+    );
   }
   sessionAnnotate(
     id: string,
     annotation: Omit<Annotation, "createdAt">,
     authorName?: string,
   ): Promise<ReviewSession> {
-    return this.request("session.annotate", { id, annotation, authorName });
+    return this.request("session.annotate", { id, annotation, authorName }, SessionRecordSchema);
   }
   sessionRemoveAnnotation(id: string, annotationId: string): Promise<ReviewSession> {
-    return this.request("session.removeAnnotation", { id, annotationId });
+    return this.request("session.removeAnnotation", { id, annotationId }, SessionRecordSchema);
   }
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession> {
-    return this.request("session.setWorkingCopy", { id, workingCopy });
+    return this.request("session.setWorkingCopy", { id, workingCopy }, SessionRecordSchema);
   }
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
-    return this.request("session.setViewed", { id, viewedPaths });
+    return this.request("session.setViewed", { id, viewedPaths }, SessionRecordSchema);
   }
   /** Re-capture a diff session's working tree; changed=true when the patch moved and an event fired. */
   sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
-    return this.request("session.refreshDiff", { id });
+    return this.request("session.refreshDiff", { id }, RefreshDiffResultSchema);
   }
   sessionSetShareId(id: string, shareId: string): Promise<ReviewSession> {
-    return this.request("session.setShareId", { id, shareId });
+    return this.request("session.setShareId", { id, shareId }, SessionRecordSchema);
   }
   sessionMergeShared(
     id: string,
     incoming: { annotations: Annotation[]; participants?: Identity[] },
   ): Promise<ReviewSession> {
-    return this.request("session.mergeShared", { id, ...incoming });
+    return this.request("session.mergeShared", { id, ...incoming }, SessionRecordSchema);
   }
   sessionDelete(id: string): Promise<void> {
-    return this.request("session.delete", { id });
+    return this.request("session.delete", { id }, EmptyResultSchema).then(() => undefined);
   }
   /** Local sessions have no collaborator self-name; the share client owns this. */
   sessionSetSelfName(id: string, _name: string): Promise<ReviewSession> {
     return this.sessionGet(id);
   }
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession> {
-    return this.request("session.resolve", { id, verdictKind, summary });
+    return this.request("session.resolve", { id, verdictKind, summary }, SessionRecordSchema);
   }
   sessionSubmitRevision(
     id: string,
     content: string,
     addressedAnnotationIds: string[] = [],
   ): Promise<ReviewSession> {
-    return this.request("session.submitRevision", { id, content, addressedAnnotationIds });
+    return this.request(
+      "session.submitRevision",
+      { id, content, addressedAnnotationIds },
+      SessionRecordSchema,
+    );
   }
   /** herdr adapter scratch: the tab opened for a review; local-only, off the SessionClient contract. */
   herdrGetTab(id: string): Promise<HerdrTabHandle | null> {
-    return this.request("herdr.getTab", { id });
+    return this.request("herdr.getTab", { id }, HerdrTabResultSchema);
   }
   async herdrSetTab(id: string, handle: HerdrTabHandle): Promise<void> {
-    await this.request("herdr.setTab", { id, ...handle });
+    await this.request("herdr.setTab", { id, ...handle }, EmptyResultSchema);
   }
   shutdown(): Promise<void> {
-    return this.request("daemon.shutdown", {});
+    return this.request("daemon.shutdown", {}, EmptyResultSchema).then(() => undefined);
   }
 }
 

package/src/diff-watcher.ts

@@ -64,10 +64,7 @@ export class DiffWatcher {
     }
     // a watcher error (the root is deleted mid-review) must not take down the
     // daemon; the inherited EventEmitter `on` is absent from Bun's FSWatcher type
-    (handle as FSWatcher & { on(event: "error", listener: (error: Error) => void): void }).on(
-      "error",
-      () => {},
-    );
+    handle.on("error", () => {});
     this.repoWatches.set(repoRoot, { handle, sessionIds: new Set([sessionId]), debounce: null });
   }
 

package/src/herdr-pane.test.ts

@@ -16,7 +16,7 @@ const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-pane-"));
  * pane_id and tab_id (herdr 0.8.2 shape), and answers `pane get` alive or dead
  * per `paneAlive` so the liveness branch can be exercised.
  */
-function makeStub(name: string, paneAlive = false): { binPath: string; logPath: string } {
+function makeStub(name: string, paneAlive = false) {
   const logPath = join(dir, `${name}.log`);
   const binPath = join(dir, `${name}.sh`);
   const paneGet = paneAlive ? `printf '{"result":{"pane":{"pane_id":"w1:p2"}}}'` : "exit 1";
@@ -44,16 +44,13 @@ function readLines(logPath: string): string[] {
 }
 
 /** In-memory persistence double: records what openHerdrPaneForReview saves. */
-function fakePersistence(initial: HerdrTabHandle | null = null): {
-  persistence: HerdrTabPersistence;
-  saved: () => HerdrTabHandle | null;
-} {
+function fakePersistence(initial: HerdrTabHandle | null = null) {
   let stored = initial;
 
   return {
     persistence: {
       herdrGetTab: async () => stored,
-      herdrSetTab: async (_sessionId, handle) => {
+      herdrSetTab: async (_sessionId: string, handle: HerdrTabHandle) => {
         stored = handle;
       },
     },

package/src/herdr-pane.ts

@@ -7,9 +7,22 @@
  */
 
 import { detectHerdr, type HerdrEnv, type ReviewSession } from "@cueloop/schema";
+import * as v from "valibot";
 import type { HerdrTabHandle } from "./herdr-tab-store";
 
 const HERDR_SPAWN_TIMEOUT_MS = 2000;
+const CreatedTabSchema = v.object({
+  result: v.optional(
+    v.object({
+      root_pane: v.optional(
+        v.object({ pane_id: v.optional(v.string()), tab_id: v.optional(v.string()) }),
+      ),
+    }),
+  ),
+});
+const PaneResultSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.unknown()) })),
+});
 
 export interface OpenHerdrPaneOptions {
   sessionId: string;
@@ -40,11 +53,11 @@ export function openHerdrPane(options: OpenHerdrPaneOptions): HerdrTabHandle | n
     );
 
     if (created.exitCode !== 0) return null;
-    const parsed = JSON.parse(created.stdout.toString()) as {
-      result?: { root_pane?: { pane_id?: string; tab_id?: string } };
-    };
-    const paneId = parsed.result?.root_pane?.pane_id;
-    const tabId = parsed.result?.root_pane?.tab_id;
+    const parsed = v.safeParse(CreatedTabSchema, JSON.parse(created.stdout.toString()));
+
+    if (!parsed.success) return null;
+    const paneId = parsed.output.result?.root_pane?.pane_id;
+    const tabId = parsed.output.result?.root_pane?.tab_id;
 
     if (!paneId || !tabId) return null;
     // A fresh tab hosts a plain shell, so the review is typed in like a human.
@@ -77,9 +90,9 @@ function herdrPaneAlive(binPath: string, paneId: string): boolean {
     });
 
     if (got.exitCode !== 0) return false;
-    const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: unknown } };
+    const parsed = v.safeParse(PaneResultSchema, JSON.parse(got.stdout.toString()));
 
-    return parsed.result?.pane != null;
+    return parsed.success && parsed.output.result?.pane != null;
   } catch {
     return false;
   }

package/src/herdr-split.test.ts

@@ -9,7 +9,7 @@ import { launchHarnessInSplit } from "./herdr-split";
 const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-split-"));
 
 /** A stub herdr binary that logs argv and prints the pane-split result (pane_id of the new split). */
-function makeStub(name: string, splitOk = true): { binPath: string; logPath: string } {
+function makeStub(name: string, splitOk = true) {
   const logPath = join(dir, `${name}.log`);
   const binPath = join(dir, `${name}.sh`);
   const splitResult = splitOk

package/src/herdr-split.ts

@@ -7,8 +7,12 @@
  */
 
 import { detectHerdr, type HerdrEnv } from "@cueloop/schema";
+import * as v from "valibot";
 
 const HERDR_SPAWN_TIMEOUT_MS = 2000;
+const SplitPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ pane_id: v.optional(v.string()) })) })),
+});
 
 /** How much of the current pane the launched harness split takes (herdr --ratio). */
 const HARNESS_SPLIT_RATIO = "0.4";
@@ -55,10 +59,10 @@ export function launchHarnessInSplit(
     );
 
     if (split.exitCode !== 0) return false;
-    const parsed = JSON.parse(split.stdout.toString()) as {
-      result?: { pane?: { pane_id?: string } };
-    };
-    const paneId = parsed.result?.pane?.pane_id;
+    const parsed = v.safeParse(SplitPaneSchema, JSON.parse(split.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const paneId = parsed.output.result?.pane?.pane_id;
 
     if (!paneId) return false;
     sendText(herdr.binPath, paneId, options.command);

package/src/herdr-tab-store.ts

@@ -6,6 +6,7 @@
  */
 
 import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import * as v from "valibot";
 import { herdrTabsPath } from "./paths";
 
 /** The tab and its root pane: pane id checks liveness, tab id focuses it. */
@@ -14,15 +15,11 @@ export interface HerdrTabHandle {
   paneId: string;
 }
 
-/** Guard a persisted entry - both ids must be present strings, or it is dropped. */
-function isHerdrTabHandle(value: unknown): value is HerdrTabHandle {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof (value as HerdrTabHandle).tabId === "string" &&
-    typeof (value as HerdrTabHandle).paneId === "string"
-  );
-}
+const HerdrTabHandleSchema = v.object({
+  tabId: v.string(),
+  paneId: v.string(),
+});
+const HerdrTabsSchema = v.record(v.string(), v.unknown());
 
 export class HerdrTabStore {
   private tabs = new Map<string, HerdrTabHandle>();
@@ -35,12 +32,12 @@ export class HerdrTabStore {
 
   private load(): void {
     try {
-      const parsed: unknown = JSON.parse(readFileSync(this.path, "utf8"));
+      const parsed = v.parse(HerdrTabsSchema, JSON.parse(readFileSync(this.path, "utf8")));
 
-      if (typeof parsed !== "object" || parsed === null) return;
       for (const [sessionId, value] of Object.entries(parsed)) {
-        if (isHerdrTabHandle(value))
-          this.tabs.set(sessionId, { tabId: value.tabId, paneId: value.paneId });
+        const handle = v.safeParse(HerdrTabHandleSchema, value);
+
+        if (handle.success) this.tabs.set(sessionId, handle.output);
       }
     } catch {
       // absent, unreadable, or malformed: start empty - a stale tab just reopens on resubmit

package/src/protocol.ts

@@ -4,6 +4,8 @@
  * Events (push, after events.subscribe): { event, sessionId }
  */
 
+import * as v from "valibot";
+
 export interface Request {
   id: number;
   method: string;
@@ -23,6 +25,29 @@ export interface EventFrame {
 
 export type Frame = Response | EventFrame;
 
+const RequestSchema = v.object({
+  id: v.number(),
+  method: v.string(),
+  params: v.optional(v.unknown()),
+});
+const ResponseSchema = v.object({
+  id: v.number(),
+  result: v.optional(v.unknown()),
+  error: v.optional(v.object({ code: v.string(), message: v.string() })),
+});
+const EventFrameSchema = v.object({
+  event: v.string(),
+  sessionId: v.string(),
+});
+
+export function parseRequestFrame(line: string): Request {
+  return v.parse(RequestSchema, JSON.parse(line));
+}
+
+export function parseInboundFrame(line: string): Frame {
+  return v.parse(v.union([ResponseSchema, EventFrameSchema]), JSON.parse(line));
+}
+
 /** Incremental NDJSON splitter; tolerates partial writes. */
 export class LineBuffer {
   private buffered = "";

package/src/retention.test.ts

@@ -48,7 +48,7 @@ describe("resolveCleanupPeriodDays", () => {
     const missing = join(tempDir("cueloop-retention-"), "config.toml");
 
     // Act
-    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: missing } as NodeJS.ProcessEnv);
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: missing });
 
     // Assert
     expect(days).toBe(DEFAULT_CLEANUP_PERIOD_DAYS);
@@ -61,7 +61,7 @@ describe("resolveCleanupPeriodDays", () => {
     writeFileSync(path, "[cleanup]\nperiod_days = 7\n");
 
     // Act
-    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path } as NodeJS.ProcessEnv);
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path });
 
     // Assert
     expect(days).toBe(7);
@@ -74,7 +74,7 @@ describe("resolveCleanupPeriodDays", () => {
     writeFileSync(path, '[cleanup]\nperiod_days = "soon"\n');
 
     // Act
-    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path } as NodeJS.ProcessEnv);
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path });
 
     // Assert
     expect(days).toBe(DEFAULT_CLEANUP_PERIOD_DAYS);

package/src/retention.ts

@@ -20,7 +20,7 @@ const RefineStateSchema = v.object({
 
 export type RefineState = v.InferOutput<typeof RefineStateSchema>;
 
-export function parseRefineState(raw: unknown): Map<string, string> {
+export function parseRefineState(raw: Parameters<typeof v.safeParse>[1]): Map<string, string> {
   const parsed = v.safeParse(RefineStateSchema, raw);
 
   if (!parsed.success) return new Map();

package/src/review.test.ts

@@ -159,6 +159,30 @@ describe("openReview", () => {
     expect(other.id).not.toBe(first.id);
   });
 
+  test("the same agentSessionId with a different type opens a new session, never a type mismatch", async () => {
+    // Arrange - the agent session's plan review is open
+    const plan = await openReview(client, {
+      type: "plan",
+      content: PLAN,
+      cwd: home,
+      agentSessionId: "agent-cross",
+    });
+
+    // Act - the same agent session now submits a reply for review
+    const reply = await openReview(client, {
+      type: "reply",
+      content: "# Findings\n\nThe cache is fine.\n",
+      cwd: home,
+      agentSessionId: "agent-cross",
+    });
+
+    // Assert - a fresh reply session; the plan session keeps its type and history
+    expect(reply.id).not.toBe(plan.id);
+    expect(reply.session.artifact.type).toBe("reply");
+    expect(reply.session.revisions.length).toBe(1);
+    expect((await client.sessionGet(plan.id)).artifact.type).toBe("plan");
+  });
+
   test("per-file notes land as note annotations anchored at the file path", async () => {
     // Act
     const review = await openReview(client, {

package/src/review.ts

@@ -245,10 +245,14 @@ export async function openReview(
   const cwd = options.cwd ?? process.cwd();
   const workspace = options.workspace ?? (await resolveWorkspace(cwd));
 
-  // Resubmits from the same agent session become revisions, not new sessions.
+  // Resubmits from the same agent session become revisions, not new sessions -
+  // but only within the same primitive: a different artifact type is a new
+  // review, never a silent type mismatch on the old session.
   if (options.agentSessionId !== undefined) {
     const existing = (await client.sessionList()).find(
-      (candidate) => candidate.artifact.meta.agentSessionId === options.agentSessionId,
+      (candidate) =>
+        candidate.artifact.meta.agentSessionId === options.agentSessionId &&
+        candidate.artifact.type === options.type,
     );
 
     if (existing !== undefined) {

package/src/server.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import * as v from "valibot";
 import { DaemonServer } from "./server";
 import { DaemonClient, DaemonClientError } from "./client";
 import type { Artifact, WorkspaceKey } from "@cueloop/schema";
@@ -54,12 +55,8 @@ describe("socket round-trip", () => {
   });
 
   test("errors carry codes across the wire", async () => {
-    expect(client.sessionGet("nope")).rejects.toBeInstanceOf(DaemonClientError);
-    try {
-      await client.sessionGet("nope");
-    } catch (error) {
-      expect((error as DaemonClientError).code).toBe("not_found");
-    }
+    await expect(client.sessionGet("nope")).rejects.toBeInstanceOf(DaemonClientError);
+    await expect(client.sessionGet("nope")).rejects.toHaveProperty("code", "not_found");
   });
 
   test("events push to subscribed connections only", async () => {
@@ -85,38 +82,27 @@ describe("socket round-trip", () => {
 
   test("malformed requests get structured errors and never wedge the daemon", async () => {
     // missing required params
-    try {
-      await client.request("session.create", { artifact: { type: "plan", content: "x" } });
-      throw new Error("should have thrown");
-    } catch (error) {
-      expect((error as DaemonClientError).code).toBe("invalid_params");
-    }
+    await expect(
+      client.request("session.create", { artifact: { type: "plan", content: "x" } }, v.object({})),
+    ).rejects.toHaveProperty("code", "invalid_params");
     // wrong types
-    try {
-      await client.request("session.wait", { id: 42 });
-      throw new Error("should have thrown");
-    } catch (error) {
-      expect((error as DaemonClientError).code).toBe("invalid_params");
-    }
+    await expect(client.request("session.wait", { id: 42 }, v.object({}))).rejects.toHaveProperty(
+      "code",
+      "invalid_params",
+    );
     // unknown method
-    try {
-      await client.request("session.nuke", {});
-      throw new Error("should have thrown");
-    } catch (error) {
-      expect((error as DaemonClientError).code).toBe("unknown_method");
-    }
-    const prototypeMethods = await Promise.allSettled([
-      client.request("__proto__", {}),
-      client.request("toString", {}),
-      client.request("constructor", {}),
-    ]);
-
-    for (const result of prototypeMethods) {
-      expect(result.status).toBe("rejected");
-      expect(((result as PromiseRejectedResult).reason as DaemonClientError).code).toBe(
-        "unknown_method",
-      );
-    }
+    await expect(client.request("session.nuke", {}, v.object({}))).rejects.toHaveProperty(
+      "code",
+      "unknown_method",
+    );
+    await Promise.all(
+      ["__proto__", "toString", "constructor"].map((method) =>
+        expect(client.request(method, {}, v.object({}))).rejects.toHaveProperty(
+          "code",
+          "unknown_method",
+        ),
+      ),
+    );
     // the daemon is still fully alive afterwards
     const session = await client.sessionCreate(WS, PLAN);
 
@@ -181,15 +167,11 @@ describe("socket round-trip", () => {
     // Given a session
     const session = await client.sessionCreate(WS, PLAN);
 
-    try {
-      // When a malformed annotation is merged
-      // @ts-expect-error intentionally malformed annotation (empty id, missing fields)
-      await client.sessionMergeShared(session.id, { annotations: [{ id: "" }] });
-      throw new Error("should have thrown");
-    } catch (error) {
-      // Then it is rejected at the wire boundary
-      expect((error as DaemonClientError).code).toBe("invalid_params");
-    }
+    // When a malformed annotation is merged, it is rejected at the wire boundary
+    // @ts-expect-error intentionally malformed annotation (empty id, missing fields)
+    const merge = client.sessionMergeShared(session.id, { annotations: [{ id: "" }] });
+
+    await expect(merge).rejects.toHaveProperty("code", "invalid_params");
   });
 
   test("session.delete removes a session over the wire", async () => {
@@ -200,13 +182,8 @@ describe("socket round-trip", () => {
     await client.sessionDelete(session.id);
 
     // Then it is gone, and deleting an unknown id is a not_found error
-    expect(client.sessionGet(session.id)).rejects.toBeInstanceOf(DaemonClientError);
-    try {
-      await client.sessionDelete("ses_missing");
-      throw new Error("should have thrown");
-    } catch (error) {
-      expect((error as DaemonClientError).code).toBe("not_found");
-    }
+    await expect(client.sessionGet(session.id)).rejects.toBeInstanceOf(DaemonClientError);
+    await expect(client.sessionDelete("ses_missing")).rejects.toHaveProperty("code", "not_found");
   });
 
   test("two clients see the same state (thin-renderer model)", async () => {

package/src/server.ts

@@ -18,7 +18,13 @@ import { DaemonCore, type DaemonEvent } from "./api";
 import { DaemonError } from "./errors";
 import { roleAllowsMethod, type DaemonRole } from "./capabilities";
 import { isKnownMethod, parseParams, type MethodName } from "./validate";
-import { BackpressureWriter, LineBuffer, type Request } from "./protocol";
+import {
+  BackpressureWriter,
+  LineBuffer,
+  parseRequestFrame,
+  type Request,
+  type Response,
+} from "./protocol";
 import { cueloopHome, lockPath, pidPath, socketPath } from "./paths";
 
 interface Connection {
@@ -28,7 +34,7 @@ interface Connection {
   role: DaemonRole;
 }
 
-type MethodHandler = (connection: Connection, request: Request) => unknown;
+type MethodHandler = (connection: Connection, request: Request) => Response["result"];
 
 export interface DaemonOptions {
   home?: string;
@@ -217,7 +223,7 @@ export class DaemonServer {
     let request: Request;
 
     try {
-      request = JSON.parse(line) as Request;
+      request = parseRequestFrame(line);
     } catch {
       connection.write(
         JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) +
@@ -340,10 +346,10 @@ export class DaemonServer {
     },
   };
 
-  private async dispatch(connection: Connection, request: Request): Promise<unknown> {
+  private async dispatch(connection: Connection, request: Request): Promise<Response["result"]> {
     // The wire is untrusted JSON: validate before DaemonCore sees anything.
-    if (typeof request.method !== "string" || !isKnownMethod(request.method)) {
-      throw new DaemonError("unknown_method", `unknown method ${String(request.method)}`);
+    if (!isKnownMethod(request.method)) {
+      throw new DaemonError("unknown_method", `unknown method ${request.method}`);
     }
     // Capability gate: a capped role (a review-side agent) cannot escalate past
     // read + annotate, whatever verb it sends.

package/src/share-blob.ts

@@ -51,5 +51,5 @@ export function unpackSessionBlob(bytes: Uint8Array): ReviewSession {
 
   if (!parsed.ok) throw new Error(`blob is not a valid session: ${parsed.error}`);
 
-  return parsed.value as ReviewSession;
+  return parsed.value;
 }

package/src/store.ts

@@ -36,7 +36,7 @@ export class SessionStore {
         const parsed = validateSessionRecord(JSON.parse(raw));
 
         if (!parsed.ok) throw new Error(`invalid record - ${parsed.error}`);
-        const session = parsed.value as ReviewSession;
+        const session: ReviewSession = parsed.value;
 
         this.sessions.set(session.id, session);
         report.recovered.push(session.id);

package/src/validate.test.ts

@@ -19,6 +19,7 @@ import {
   validateSessionRecord,
 } from "./validate";
 import {
+  ARTIFACT_TYPES,
   SCHEMA_VERSION,
   type Anchor,
   type Annotation,
@@ -56,18 +57,22 @@ describe("parseParams", () => {
       throw new Error("should have thrown");
     } catch (err) {
       expect(err).toBeInstanceOf(DaemonError);
-      expect((err as DaemonError).code).toBe("invalid_params");
-      expect((err as DaemonError).message).toContain("session.create: workspace");
+      if (err instanceof DaemonError) {
+        expect(err.code).toBe("invalid_params");
+        expect(err.message).toContain("session.create: workspace");
+      }
     }
   });
 
-  test("accepts the reply artifact type", () => {
-    const params = parseParams("session.create", {
-      workspace: { repoRoot: "/repo", branch: "main" },
-      artifact: { type: "reply", content: "# R" },
-    });
+  test("accepts every artifact type in the schema union", () => {
+    for (const type of ARTIFACT_TYPES) {
+      const params = parseParams("session.create", {
+        workspace: { repoRoot: "/repo", branch: "main" },
+        artifact: { type, content: "body" },
+      });
 
-    expect(params.artifact.type).toBe("reply");
+      expect(params.artifact.type).toBe(type);
+    }
   });
 
   test("rejects an unknown artifact type", () => {
@@ -169,7 +174,7 @@ describe("validateSessionRecord", () => {
  * @cueloop/schema shows up here too.
  */
 describe("wire pins", () => {
-  const keys = (subject: object) => Object.keys(subject).sort();
+  const keys = <Subject extends object>(subject: Subject) => Object.keys(subject).sort();
   const entryKeys = (schema: { entries: object }) => Object.keys(schema.entries).sort();
 
   const fullMeta: Required<ArtifactMeta> = {

package/src/validate.ts

@@ -11,6 +11,7 @@
 
 import * as v from "valibot";
 import {
+  ARTIFACT_TYPES,
   SCHEMA_VERSION,
   type Anchor,
   type Annotation,
@@ -24,6 +25,7 @@ import {
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { DaemonError } from "./errors";
+import type { Request } from "./protocol";
 
 /**
  * Drift guard for every hand-mirrored shape below. v.object strips keys it
@@ -60,7 +62,9 @@ export const DiffFileContentsSchema = v.object({
 } satisfies EntriesOf<DiffFileContents>);
 
 export const ArtifactSchema = v.object({
-  type: v.picklist(["plan", "diff", "prototype", "reply"]),
+  // Derived from the schema's runtime union: a new primitive extends the wire
+  // contract without touching this file.
+  type: v.picklist(ARTIFACT_TYPES),
   content: v.string(),
   meta: v.optional(ArtifactMetaSchema, {}),
   files: v.optional(v.array(DiffFileContentsSchema)),
@@ -172,7 +176,7 @@ export function isKnownMethod(method: string): method is MethodName {
 /** Validate params for a method, or throw a DaemonError the client can read. */
 export function parseParams<M extends MethodName>(
   method: M,
-  params: unknown,
+  params: Request["params"],
 ): v.InferOutput<(typeof Params)[M]> {
   const result = v.safeParse(Params[method], params ?? {});
 
@@ -221,7 +225,7 @@ export const SessionRecordSchema = v.object({
 } satisfies EntriesOf<ReviewSession>);
 
 export function validateSessionRecord(
-  raw: unknown,
+  raw: Parameters<typeof v.safeParse>[1],
 ): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {
   const result = v.safeParse(SessionRecordSchema, raw);