@cueloop/daemon 0.1.0-alpha.59 → 0.1.0-alpha.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.59",
+  "version": "0.1.0-alpha.60",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.59",
+    "@cueloop/schema": "0.1.0-alpha.60",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/api.test.ts

@@ -82,6 +82,7 @@ describe("session lifecycle", () => {
 
     // Assert
     const stored = core.sessionGet(session.id);
+
     expect(stored.annotations[0]!.author).toBe("SHA256:ana");
     expect(stored.participants).toEqual([{ id: "SHA256:ana", provider: "ssh", name: "Ana" }]);
   });
@@ -89,6 +90,7 @@ describe("session lifecycle", () => {
   test("resolve produces feedback.md and maps to the agent contract", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
@@ -120,6 +122,7 @@ describe("session lifecycle", () => {
   test("mutating a resolved session throws", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     core.sessionResolve(session.id, "approve", "");
 
     // Assert
@@ -168,6 +171,7 @@ describe("session lifecycle", () => {
     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"]);
 
     // Act
@@ -180,6 +184,7 @@ describe("session lifecycle", () => {
   test("revision reopens the session and resets working copy + verdict", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     core.sessionSetWorkingCopy(session.id, PLAN.content + "\nedit");
     core.sessionResolve(session.id, "request_changes", "redo");
 
@@ -207,6 +212,7 @@ describe("revision marks addressed annotations", () => {
   test("ids the agent reports are marked addressed by that revision", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     annotate(session.id, "a1", "carefully");
     annotate(session.id, "a2", "Context");
 
@@ -215,6 +221,7 @@ describe("revision marks addressed annotations", () => {
 
     // Assert
     const [first, second] = revised.annotations;
+
     expect(first!.resolution).toEqual({ revision: 2, source: "agent" });
     expect(second!.resolution).toBeUndefined();
   });
@@ -222,6 +229,7 @@ describe("revision marks addressed annotations", () => {
   test("a plan annotation whose quoted text vanished is drift-addressed; a surviving quote stays open", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     annotate(session.id, "gone", "carefully");
     annotate(session.id, "kept", "Context");
 
@@ -242,6 +250,7 @@ describe("revision marks addressed annotations", () => {
   test("an unknown reported id is ignored, and an already-addressed annotation keeps its first resolution", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     annotate(session.id, "a1", "carefully");
     core.sessionSubmitRevision(session.id, PLAN.content, ["a1"]);
 
@@ -257,6 +266,7 @@ describe("revision marks addressed annotations", () => {
     // Arrange
     const diffArtifact: Artifact = { type: "diff", content: "+++ b/a.ts\n+new line\n", meta: {} };
     const session = core.sessionCreate({ workspace: WS, artifact: diffArtifact });
+
     annotate(session.id, "d1", "new line");
 
     // Act: the revised patch no longer contains the quoted text
@@ -269,6 +279,7 @@ describe("revision marks addressed annotations", () => {
   test("the next feedback document omits addressed annotations and teaches the addressed-ids call", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     annotate(session.id, "settled", "carefully");
     annotate(session.id, "open", "Context", "needs a diagram");
     core.sessionSubmitRevision(session.id, PLAN.content, ["settled"]);
@@ -334,6 +345,7 @@ describe("persistence and recovery", () => {
   test("sessions survive a daemon restart", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     core.sessionResolve(session.id, "approve", "done");
 
     // Act
@@ -364,10 +376,12 @@ describe("events", () => {
   test("lifecycle events fire in order", () => {
     // Arrange
     const seen: string[] = [];
+
     core.onEvent((event) => seen.push(event.event));
 
     // Act
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",

package/src/api.ts

@@ -10,6 +10,7 @@ import {
   feedbackForSession,
   isAddressed,
   isAgentNote,
+  isMarkdownArtifact,
   parseBlocks,
   registerParticipant,
   resolveAnchor,
@@ -84,6 +85,7 @@ export class DaemonCore {
 
   onEvent(listener: EventListener): () => void {
     this.listeners.add(listener);
+
     return () => this.listeners.delete(listener);
   }
 
@@ -109,16 +111,20 @@ export class DaemonCore {
       status: "pending",
       createdAt: now,
     };
+
     this.store.upsert(session);
     this.watchIfDiffSession(session);
     this.emit("session.created", session.id);
     this.emit("inbox.changed", session.id);
+
     return session;
   }
 
   sessionGet(id: string): ReviewSession {
     const session = this.store.get(id);
+
     if (!session) throw new DaemonError("not_found", `no session ${id}`);
+
     return session;
   }
 
@@ -132,6 +138,7 @@ export class DaemonCore {
         return false;
       if (filter?.workspace?.branch && session.workspace.branch !== filter.workspace.branch)
         return false;
+
       return true;
     });
   }
@@ -143,7 +150,9 @@ export class DaemonCore {
    */
   sessionWait(id: string, timeoutMs: number): Promise<ReviewSession | null> {
     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;
@@ -151,6 +160,7 @@ export class DaemonCore {
         if (done) return;
         done = true;
         const waiterIndex = list.indexOf(waiter);
+
         if (waiterIndex !== -1) list.splice(waiterIndex, 1);
         resolve(null);
       }, timeoutMs);
@@ -160,6 +170,7 @@ export class DaemonCore {
         clearTimeout(timer);
         resolve(session);
       };
+
       list.push(waiter);
       this.waiters.set(id, list);
     });
@@ -177,6 +188,7 @@ export class DaemonCore {
     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) session.annotations.push(full);
     else
       session.annotations[existing] = {
@@ -191,25 +203,30 @@ export class DaemonCore {
       ).participants;
     this.store.upsert(session);
     this.emit("session.updated", id);
+
     return session;
   }
 
   sessionRemoveAnnotation(id: string, annotationId: string): ReviewSession {
     const session = this.mutable(id);
+
     session.annotations = session.annotations.filter((candidate) => candidate.id !== annotationId);
     this.store.upsert(session);
     this.emit("session.updated", id);
+
     return session;
   }
 
   /** The reviewer's working copy; undefined clears it (revert all edits). */
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): ReviewSession {
     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 session;
   }
 
@@ -220,24 +237,29 @@ export class DaemonCore {
    */
   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;
   }
 
   sessionSetShareId(id: string, shareId: string): ReviewSession {
     const session = this.mutable(id);
+
     session.shareId = shareId;
     this.store.upsert(session);
     this.emit("session.updated", id);
+
     return session;
   }
 
   /** Remove a session for good (inbox delete); resolved or pending, both go. */
   sessionDelete(id: string): void {
     const session = this.store.get(id);
+
     if (!this.store.delete(id)) throw new DaemonError("not_found", `no session ${id}`);
     if (session) this.unwatchIfDiffSession(session);
     this.diffRefreshGenerations.delete(id);
@@ -258,17 +280,20 @@ export class DaemonCore {
   ): ReviewSession {
     const session = this.mutable(id);
     const known = new Set(session.annotations.map((annotation) => annotation.id));
+
     for (const annotation of incoming.annotations)
       if (!known.has(annotation.id)) session.annotations.push(annotation);
     if (incoming.participants?.length) {
       const registry = new Map(
         (session.participants ?? []).map((participant) => [participant.id, participant]),
       );
+
       for (const participant of incoming.participants) registry.set(participant.id, participant);
       session.participants = [...registry.values()];
     }
     this.store.upsert(session);
     this.emit("session.updated", id);
+
     return session;
   }
 
@@ -280,16 +305,19 @@ export class DaemonCore {
       feedback: feedbackForSession(session, verdictKind, summary),
       resolvedAt: new Date().toISOString(),
     };
+
     session.verdict = verdict;
     session.status = "resolved";
     this.store.upsert(session);
     // a resolved diff review is frozen; stop hot-reloading its working tree
     this.unwatchIfDiffSession(session);
     const parked = this.waiters.get(id) ?? [];
+
     this.waiters.delete(id);
     for (const parkedWaiter of parked) parkedWaiter(session);
     this.emit("session.resolved", id);
     this.emit("inbox.changed", id);
+
     return session;
   }
 
@@ -311,6 +339,7 @@ export class DaemonCore {
     const session = this.sessionGet(id);
     const now = new Date().toISOString();
     const revisionNumber = session.revisions.length + 1;
+
     session.revisions.push({ revision: revisionNumber, content, submittedAt: now });
     session.artifact = { ...session.artifact, content };
     delete session.workingCopy;
@@ -318,9 +347,11 @@ export class DaemonCore {
     session.status = "pending";
 
     const reportedIds = new Set(addressedAnnotationIds);
-    // drift assist applies to plans only: a diff revision is a whole new
-    // patch, where a vanished quote says nothing about the feedback
-    const revisedBlocks = session.artifact.type === "plan" ? parseBlocks(content) : null;
+    // drift assist applies to markdown artifacts (plan, reply) only: a diff
+    // revision is a whole new patch, where a vanished quote says nothing about
+    // the feedback
+    const revisedBlocks = isMarkdownArtifact(session.artifact.type) ? parseBlocks(content) : null;
+
     for (const annotation of session.annotations) {
       if (isAddressed(annotation) || isAgentNote(annotation)) continue;
       if (reportedIds.has(annotation.id)) {
@@ -336,28 +367,34 @@ export class DaemonCore {
     this.store.upsert(session);
     this.emit("session.revised", id);
     this.emit("inbox.changed", id);
+
     return session;
   }
 
   /** Re-capture a diff session's working tree; broadcasts session.updated only when the patch moved. */
   async sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
     const session = this.mutable(id);
+
     if (session.artifact.type !== "diff") return { changed: false };
     const generation = (this.diffRefreshGenerations.get(id) ?? 0) + 1;
+
     this.diffRefreshGenerations.set(id, generation);
     const diff = await workingTreeDiff(session.workspace.repoRoot);
+
     // The capture yields the event loop: a newer refresh may have started, or a
     // concurrent resolve/delete may have closed the session. Discard a stale
     // capture, and re-read so a resolved review is never mutated and a deleted
     // one is never revived by this upsert.
     if (this.diffRefreshGenerations.get(id) !== generation) return { changed: false };
     const current = this.store.get(id);
+
     if (!current || current.status !== "pending" || current.artifact.type !== "diff")
       return { changed: false };
     if (diff.patch === current.artifact.content) return { changed: false };
     current.artifact = { ...current.artifact, content: diff.patch, files: diff.files };
     this.store.upsert(current);
     this.emit("session.updated", id);
+
     return { changed: true };
   }
 
@@ -366,6 +403,7 @@ export class DaemonCore {
     const live = this.store
       .list()
       .filter((session) => isLiveDiffSession(session) && session.workspace.repoRoot === repoRoot);
+
     for (const session of live) {
       // a session resolved or deleted between the change and this tick just skips
       try {
@@ -388,8 +426,10 @@ export class DaemonCore {
 
   private mutable(id: string): ReviewSession {
     const session = this.sessionGet(id);
+
     if (session.status === "resolved")
       throw new DaemonError("resolved", `session ${id} is already resolved`);
+
     return session;
   }
 }
@@ -404,5 +444,6 @@ 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 } {
   if (!session.verdict) throw new DaemonError("pending", "session has no verdict");
+
   return { allow: verdictAllows(session.verdict.kind), feedback: session.verdict.feedback };
 }

package/src/client.ts

@@ -74,9 +74,11 @@ export class DaemonClient implements SessionClient {
     const home = options.home ?? cueloopHome();
     const path = socketPath(home);
     const client = new DaemonClient();
+
     client.role = options.role ?? "owner";
     try {
       await client.dial(path);
+
       return client;
     } catch (err) {
       if (!options.autostart) throw err;
@@ -88,9 +90,11 @@ export class DaemonClient implements SessionClient {
     // 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 lastError: unknown;
+
     while (Date.now() < deadline) {
       try {
         await client.dial(path);
+
         return client;
       } catch (err) {
         lastError = err;
@@ -102,6 +106,7 @@ export class DaemonClient implements SessionClient {
 
   private async dial(path: string): Promise<void> {
     const buffer = new LineBuffer();
+
     this.socket = await Bun.connect({
       unix: path,
       socket: {
@@ -130,11 +135,13 @@ export class DaemonClient implements SessionClient {
 
   onEvent(listener: (event: EventFrame) => void): () => void {
     this.eventListeners.add(listener);
+
     return () => this.eventListeners.delete(listener);
   }
 
   private routeInboundFrame(line: string): void {
     let frame: Response | EventFrame;
+
     try {
       frame = JSON.parse(line) as Response | EventFrame;
     } catch {
@@ -142,9 +149,11 @@ export class DaemonClient implements SessionClient {
     }
     if ("event" in frame) {
       for (const listener of this.eventListeners) listener(frame);
+
       return;
     }
     const pendingRequest = this.pending.get(frame.id);
+
     if (!pendingRequest) return;
     this.pending.delete(frame.id);
     if (frame.error)
@@ -155,11 +164,13 @@ export class DaemonClient implements SessionClient {
   request<T = unknown>(method: string, params: unknown, timeoutMs = 30_000): Promise<T> {
     if (this.closed || !this.socket) return Promise.reject(new Error("not connected"));
     const id = this.nextId++;
+
     return new Promise<T>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`request ${method} timed out`));
       }, timeoutMs);
+
       this.pending.set(id, {
         resolve: (value) => {
           clearTimeout(timer);
@@ -268,6 +279,7 @@ export class DaemonClientError extends Error {
 
 function spawnDaemon(home: string): void {
   const entry = new URL("./main.ts", import.meta.url).pathname;
+
   Bun.spawn([process.execPath, "run", entry], {
     env: { ...process.env, CUELOOP_HOME: home },
     stdio: ["ignore", "ignore", "ignore"],

package/src/diff-hot-reload.test.ts

@@ -15,6 +15,7 @@ import type { Artifact } from "@cueloop/schema";
 
 function git(args: string[], cwd: string): void {
   const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" });
+
   if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed in ${cwd}`);
 }
 
@@ -45,6 +46,7 @@ async function openDiffSession() {
   const workspace = await resolveWorkspace(repo);
   const diff = await workingTreeDiff(repo);
   const artifact: Artifact = { type: "diff", content: diff.patch, files: diff.files, meta: {} };
+
   return core.sessionCreate({ workspace, artifact });
 }
 
@@ -52,6 +54,7 @@ describe("session.refreshDiff", () => {
   test("re-captures the working tree and updates the artifact when the patch changed", async () => {
     // Given an open diff session whose working tree then gains a new change
     const session = await openDiffSession();
+
     writeFileSync(join(repo, "a.ts"), "export const a = 2;\n");
 
     // When the diff is refreshed
@@ -60,8 +63,10 @@ describe("session.refreshDiff", () => {
     // Then the change is reported and the stored artifact carries the fresh patch and files
     expect(result.changed).toBe(true);
     const refreshed = core.sessionGet(session.id);
+
     expect(refreshed.artifact.content).toContain("+export const a = 2;");
     const modified = refreshed.artifact.files!.find((file) => file.path === "a.ts")!;
+
     expect(modified.newContents).toBe("export const a = 2;\n");
   });
 
@@ -69,6 +74,7 @@ describe("session.refreshDiff", () => {
     // Given an open diff session and a listener for session events
     const session = await openDiffSession();
     const events: string[] = [];
+
     core.onEvent((event) => events.push(event.event));
 
     // When the diff is refreshed without any working-tree change
@@ -83,6 +89,7 @@ describe("session.refreshDiff", () => {
     // Given an open diff session, a listener, and a fresh working-tree change
     const session = await openDiffSession();
     const events: string[] = [];
+
     core.onEvent((event) => events.push(event.event));
     writeFileSync(join(repo, "a.ts"), "export const a = 3;\n");
 
@@ -110,8 +117,10 @@ describe("session.refreshDiff", () => {
   test("refusing a resolved diff session never mutates it (no revive of a closed review)", async () => {
     // Given a diff session that has been resolved
     const session = await openDiffSession();
+
     core.sessionResolve(session.id, "approve", "");
     const resolvedContent = core.sessionGet(session.id).artifact.content;
+
     writeFileSync(join(repo, "a.ts"), "export const a = 99;\n");
 
     // When a refresh is attempted on the resolved session
@@ -123,6 +132,7 @@ describe("session.refreshDiff", () => {
   test("overlapping refreshes settle to one coherent artifact without error", async () => {
     // Given a live diff session with a fresh working-tree change
     const session = await openDiffSession();
+
     writeFileSync(join(repo, "a.ts"), "export const a = 7;\n");
 
     // When two refreshes run concurrently over the same session
@@ -150,6 +160,7 @@ describe("the fs watcher drives hot-reload", () => {
     // Watchers can be slow under CI contention, so poll generously.
     const deadline = Date.now() + 8_000;
     let content = core.sessionGet(session.id).artifact.content;
+
     while (!content.includes("+export const a = 42;") && Date.now() < deadline) {
       await Bun.sleep(100);
       content = core.sessionGet(session.id).artifact.content;

package/src/diff-watcher.ts

@@ -20,6 +20,7 @@ const DIFF_REFRESH_DEBOUNCE_MS = 300;
  */
 function isIgnoredWatchPath(relativePath: string): boolean {
   const segments = relativePath.split(sep);
+
   return segments.includes(".git") || segments.includes("node_modules");
 }
 
@@ -44,11 +45,14 @@ export class DiffWatcher {
   /** Start (or join) watching a repo root for one diff session. Idempotent per (root, session). */
   trackDiffRepo(repoRoot: string, sessionId: string): void {
     const existing = this.repoWatches.get(repoRoot);
+
     if (existing) {
       existing.sessionIds.add(sessionId);
+
       return;
     }
     let handle: FSWatcher;
+
     try {
       handle = watch(repoRoot, { recursive: true }, (_event, filename) => {
         if (filename !== null && isIgnoredWatchPath(filename.toString())) return;
@@ -70,6 +74,7 @@ export class DiffWatcher {
   /** Drop one diff session; close the repo watch once no diff session tracks it. */
   untrackDiffRepo(repoRoot: string, sessionId: string): void {
     const repoWatch = this.repoWatches.get(repoRoot);
+
     if (!repoWatch) return;
     repoWatch.sessionIds.delete(sessionId);
     if (repoWatch.sessionIds.size > 0) return;
@@ -80,6 +85,7 @@ export class DiffWatcher {
 
   private scheduleRepoRefresh(repoRoot: string): void {
     const repoWatch = this.repoWatches.get(repoRoot);
+
     if (!repoWatch) return;
     if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
     repoWatch.debounce = setTimeout(() => {

package/src/herdr-pane.test.ts

@@ -20,6 +20,7 @@ function makeStub(name: string, paneAlive = false): { binPath: string; logPath:
   const logPath = join(dir, `${name}.log`);
   const binPath = join(dir, `${name}.sh`);
   const paneGet = paneAlive ? `printf '{"result":{"pane":{"pane_id":"w1:p2"}}}'` : "exit 1";
+
   writeFileSync(
     binPath,
     `#!/bin/sh
@@ -32,11 +33,13 @@ exit 0
 `,
   );
   chmodSync(binPath, 0o755);
+
   return { binPath, logPath };
 }
 
 function readLines(logPath: string): string[] {
   if (!existsSync(logPath)) return [];
+
   return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
 }
 
@@ -46,6 +49,7 @@ function fakePersistence(initial: HerdrTabHandle | null = null): {
   saved: () => HerdrTabHandle | null;
 } {
   let stored = initial;
+
   return {
     persistence: {
       herdrGetTab: async () => stored,
@@ -109,6 +113,7 @@ describe("openHerdrPane", () => {
     // Arrange
     const logPath = join(dir, "nopane.log");
     const binPath = join(dir, "nopane.sh");
+
     writeFileSync(
       binPath,
       `#!/bin/sh\nprintf '%s\\n' "$*" >> "${logPath}"\nprintf '{"result":{}}'\n`,
@@ -170,6 +175,7 @@ describe("openHerdrPaneForReview", () => {
 
     // Assert
     const lines = readLines(stub.logPath);
+
     expect(lines).toContain("pane get w9:p9");
     expect(lines).toContain("tab focus w9:t9");
     expect(lines.some((line) => line.startsWith("tab create"))).toBeFalse();
@@ -225,6 +231,7 @@ describe("openHerdrPaneForReview", () => {
 
     // Assert
     const lines = readLines(stub.logPath);
+
     expect(lines).toContain("pane get old:p");
     expect(lines).toContain("tab create --cwd /repo/work --label Rollout Plan --focus");
     expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });