@cueloop/daemon 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/capabilities.test.ts

@@ -1,28 +1,47 @@
 import { describe, expect, test } from "bun:test";
-import { asDaemonRole, roleAllowsMethod } from "./capabilities";
+import { asDaemonRole, DEFAULT_ROLE, roleAllowsMethod } from "./capabilities";
+import type { MethodName } from "./validate";
 
 describe("roleAllowsMethod", () => {
-  test("the owner may call every verb", () => {
+  test("the owner may call every primitive", () => {
     // Assert
-    for (const method of ["session.resolve", "session.submitRevision", "session.delete"])
-      expect(roleAllowsMethod("owner", method)).toBe(true);
+    const owned: MethodName[] = ["session.resolve", "session.submitRevision", "session.delete"];
+
+    for (const method of owned) expect(roleAllowsMethod("owner", method)).toBe(true);
   });
 
   test("a capped role may read and annotate but not escalate", () => {
     // Assert - allowed
-    for (const method of ["session.get", "session.list", "session.wait", "session.annotate"])
-      expect(roleAllowsMethod("agent", method)).toBe(true);
+    const open: MethodName[] = ["session.get", "session.list", "session.wait", "session.annotate"];
+
+    for (const method of open) expect(roleAllowsMethod("agent", method)).toBe(true);
     // Assert - denied
-    for (const method of [
+    const owned: MethodName[] = [
       "session.resolve",
       "session.submitRevision",
       "session.setWorkingCopy",
       "session.delete",
       "session.setShareId",
       "session.refreshDiff",
-    ])
-      expect(roleAllowsMethod("agent", method)).toBe(false);
+      "session.create",
+      "session.navigate",
+      "session.branch",
+      "session.switch",
+      "session.label",
+      "session.fork",
+    ];
+
+    for (const method of owned) expect(roleAllowsMethod("agent", method)).toBe(false);
     expect(roleAllowsMethod("collaborator", "session.resolve")).toBe(false);
+    // removal and naming are open to every role; the primitive itself scopes a
+    // non-owner to the author it acts as
+    expect(roleAllowsMethod("agent", "session.removeAnnotation")).toBe(true);
+    expect(roleAllowsMethod("agent", "session.setParticipantName")).toBe(true);
+  });
+
+  test("a connection starts as a collaborator, never as the owner", () => {
+    // Assert
+    expect(DEFAULT_ROLE).toBe("collaborator");
   });
 });
 

package/src/capabilities.ts

@@ -1,30 +1,66 @@
 /**
- * Daemon role capabilities: which socket methods a connection may call. The
- * owner (the local planner) may call everything; a collaborator or a review-side
- * agent is capped to reading the session and adding annotations, so a bring-your-
- * own agent literally cannot resolve, rewrite, cut, share, or delete (ADR 0009).
- * This is the single source of truth the server dispatch enforces.
+ * Daemon roles: which primitives a connection may call. A connection is a
+ * collaborator until it proves ownership with the owner token in daemon.hello
+ * - never an owner by default. The owner (the local planner) may call every
+ * primitive; a collaborator or a review-side agent is capped to reading the
+ * session and adding comments, so a bring-your-own agent cannot resolve,
+ * rewrite, cut, share, or delete (ADR 0009). The table below is exhaustive
+ * over the primitive schemas: adding a primitive without naming its roles
+ * does not compile.
  */
 
+import * as v from "valibot";
+import type { MethodName } from "./validate";
+
 export type DaemonRole = "owner" | "collaborator" | "agent";
 
-/** Methods a non-owner role may call: read the session and annotate, plus connection plumbing. */
-const NON_OWNER_METHODS = new Set<string>([
-  "daemon.ping",
-  "daemon.hello",
-  "events.subscribe",
-  "session.get",
-  "session.list",
-  "session.wait",
-  "session.annotate",
-]);
-
-/** Whether `role` may call `method`. The owner may call anything; others are capped to read + annotate. */
-export function roleAllowsMethod(role: DaemonRole, method: string): boolean {
-  return role === "owner" || NON_OWNER_METHODS.has(method);
+/** Who may call a primitive: everyone, or the owner only. */
+type Audience = "any" | "owner";
+
+const PRIMITIVE_ROLES = {
+  "daemon.ping": "any",
+  "daemon.hello": "any",
+  "daemon.shutdown": "owner",
+  "events.subscribe": "any",
+  "session.create": "owner",
+  "session.get": "any",
+  "session.list": "any",
+  "session.wait": "any",
+  "session.annotate": "any",
+  // any role may call it; a non-owner must act on behalf of an author and stays scoped to it
+  "session.removeAnnotation": "any",
+  "session.setParticipantName": "any",
+  "session.setWorkingCopy": "owner",
+  "session.cutBlock": "owner",
+  "session.restoreBlock": "owner",
+  "session.curate": "owner",
+  "session.setViewed": "owner",
+  // the tree is the owner's: collaborators comment on the branch a share follows
+  "session.navigate": "owner",
+  "session.branch": "owner",
+  "session.switch": "owner",
+  "session.label": "owner",
+  "session.fork": "owner",
+  "session.refreshDiff": "owner",
+  "session.setShareId": "owner",
+  "session.delete": "owner",
+  "session.mergeShared": "owner",
+  "session.resolve": "owner",
+  "session.submitRevision": "owner",
+  "herdr.getTab": "owner",
+  "herdr.setTab": "owner",
+} as const satisfies Record<MethodName, Audience>;
+
+/** Whether `role` may call `method`. */
+export function roleAllowsMethod(role: DaemonRole, method: MethodName): boolean {
+  return role === "owner" || PRIMITIVE_ROLES[method] === "any";
 }
 
-/** 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";
+/** The role a connection starts with, before any proof. */
+export const DEFAULT_ROLE: DaemonRole = "collaborator";
+
+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

@@ -1,22 +1,34 @@
 /**
- * Daemon client: the one library every consumer shares - CLI verbs, the TUI,
+ * Daemon client: the one library every consumer shares - CLI primitives, the TUI,
  * adapters, and tests. Also owns the lazy-launch story: connect() with
  * autostart spawns a detached daemon when the socket is dead, then attaches.
  */
 
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import * as v from "valibot";
 import type {
   Annotation,
   Artifact,
-  Identity,
+  HunkRejection,
   ReviewSession,
   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 type { SharedMerge } from "./api";
+
+export type { SharedMerge } from "./api";
+import { cueloopHome, ownerTokenPath, socketPath } from "./paths";
+import { Params, SessionRecordSchema } from "./validate";
 
 export type { EventFrame } from "./protocol";
 
@@ -26,12 +38,22 @@ export interface ConnectOptions {
   autostart?: boolean;
   /** Capability role for this connection; a review-side agent connects capped. Defaults to owner. */
   role?: DaemonRole;
+  /** The author a non-owner connection acts as; its comments, removals, and name are bound to it. */
+  author?: string;
 }
 
-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
+ * The session primitives the review controller drives. DaemonClient is the local
  * implementation (unix socket); the sharing gateway supplies an in-memory,
  * blob-backed one. Depending on this interface - not DaemonClient - is what
  * lets the same <App> render a local session or a decrypted share unchanged.
@@ -46,14 +68,32 @@ export interface SessionClient {
     annotation: Omit<Annotation, "createdAt">,
     authorName?: string,
   ): Promise<ReviewSession>;
+  /** Remove a comment; a non-owner connection removes only the comments of the author it is bound to. */
   sessionRemoveAnnotation(id: string, annotationId: string): Promise<ReviewSession>;
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession>;
+  /** Cut the `blockIndex`-th block of the working copy. */
+  sessionCutBlock(id: string, blockIndex: number): Promise<ReviewSession>;
+  /** Re-insert the `baseBlockIndex`-th block of the submitted revision before `line` (default: the end). */
+  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<ReviewSession>;
+  /** Replace a diff review's reject decisions; the working copy follows. */
+  sessionCurate(id: string, rejections: HunkRejection[]): Promise<ReviewSession>;
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession>;
-  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession>;
-  sessionMergeShared(
+  /** Move a branch's tip (the current one, or `branch` after switching to it) back to an entry on its path; a summary records the abandoned segment. */
+  sessionNavigate(
     id: string,
-    incoming: { annotations: Annotation[]; participants?: Identity[] },
+    entryId: string,
+    summary?: string,
+    branch?: string,
   ): Promise<ReviewSession>;
+  /** Start a branch at the current tip and switch to it. */
+  sessionBranch(id: string, name: string): Promise<ReviewSession>;
+  sessionSwitch(id: string, branch: string): Promise<ReviewSession>;
+  /** Name the current tip as a checkpoint. */
+  sessionLabel(id: string, label: string): Promise<ReviewSession>;
+  /** Copy the current path into a new session; returns the fork. */
+  sessionFork(id: string): Promise<ReviewSession>;
+  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession>;
+  sessionMergeShared(id: string, incoming: SharedMerge): Promise<ReviewSession>;
   sessionDelete(id: string): Promise<void>;
   /** Record the caller's own identity name (collaborator self-naming on a share). */
   sessionSetSelfName(id: string, name: string): Promise<ReviewSession>;
@@ -61,6 +101,33 @@ export interface SessionClient {
   close(): void;
 }
 
+/** What a connection says about itself: its role, the owner token when it claims ownership, the author it acts as otherwise. */
+interface HelloParams {
+  role: DaemonRole;
+  token?: string;
+  author?: string;
+}
+
+/** The token as the daemon writes it: 32 random bytes in hex. */
+const OwnerTokenSchema = v.pipe(v.string(), v.trim(), v.regex(/^[0-9a-f]{64}$/));
+
+/** The owner token in `home`, or undefined when the daemon there never wrote one. */
+function readOwnerToken(home: string): string | undefined {
+  const path = ownerTokenPath(home);
+
+  if (!existsSync(path)) return undefined;
+  const parsed = v.safeParse(OwnerTokenSchema, readFileSync(path, "utf8"));
+
+  if (!parsed.success) {
+    throw new DaemonClientError(
+      "invalid_owner_token",
+      `${path} is not an owner token; restart the daemon to mint a fresh one`,
+    );
+  }
+
+  return parsed.output;
+}
+
 export class DaemonClient implements SessionClient {
   private socket: Awaited<ReturnType<typeof Bun.connect>> | null = null;
   private writer: BackpressureWriter | null = null;
@@ -69,6 +136,8 @@ export class DaemonClient implements SessionClient {
   private eventListeners = new Set<(event: EventFrame) => void>();
   private closed = false;
   private role: DaemonRole = "owner";
+  private author: string | undefined;
+  private home = cueloopHome();
 
   static async connect(options: ConnectOptions = {}): Promise<DaemonClient> {
     const home = options.home ?? cueloopHome();
@@ -76,12 +145,16 @@ export class DaemonClient implements SessionClient {
     const client = new DaemonClient();
 
     client.role = options.role ?? "owner";
+    client.author = options.author;
+    client.home = home;
     try {
       await client.dial(path);
 
       return client;
     } catch (err) {
-      if (!options.autostart) throw err;
+      // a live daemon that refused the handshake is not a dead socket: the
+      // caller hears why instead of the client replacing a running daemon
+      if (!options.autostart || err instanceof DaemonClientError) throw err;
     }
     // Socket dead or absent: clean a stale file and spawn the daemon detached.
     if (existsSync(path)) rmSync(path, { force: true });
@@ -128,9 +201,23 @@ 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);
-    // 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);
+    await this.request("daemon.ping", {}, PingResultSchema, 2_000);
+    // Every connection starts as a collaborator; the owner proves itself with
+    // the token the daemon wrote into the home it serves, which only the home's
+    // user can read. A capped role just names itself.
+    await this.request("daemon.hello", this.helloParams(), EmptyResultSchema, 2_000);
+  }
+
+  private helloParams(): HelloParams {
+    if (this.role !== "owner") {
+      return this.author === undefined
+        ? { role: this.role }
+        : { role: this.role, author: this.author };
+    }
+    const token = readOwnerToken(this.home);
+
+    // a daemon from before owner tokens has no file; it still knows the bare hello
+    return token === undefined ? { role: "owner" } : { role: "owner", token };
   }
 
   onEvent(listener: (event: EventFrame) => void): () => void {
@@ -140,10 +227,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 +248,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 +266,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);
@@ -190,81 +282,129 @@ export class DaemonClient implements SessionClient {
     this.socket?.end();
   }
 
-  // ── typed verbs ─────────────────────────────
+  // ── typed primitives ─────────────────────────────
   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);
+  }
+  /** Register a display name for a participant - a collaborator's or an agent's own, on a share or locally. */
+  sessionSetParticipantName(id: string, author: string, name: string): Promise<ReviewSession> {
+    return this.request("session.setParticipantName", { id, author, name }, SessionRecordSchema);
   }
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession> {
-    return this.request("session.setWorkingCopy", { id, workingCopy });
+    return this.request("session.setWorkingCopy", { id, workingCopy }, SessionRecordSchema);
+  }
+  sessionCutBlock(id: string, blockIndex: number): Promise<ReviewSession> {
+    return this.request("session.cutBlock", { id, blockIndex }, SessionRecordSchema);
+  }
+  sessionNavigate(
+    id: string,
+    entryId: string,
+    summary?: string,
+    branch?: string,
+  ): Promise<ReviewSession> {
+    const params: v.InferInput<(typeof Params)["session.navigate"]> = { id, entryId };
+
+    if (summary !== undefined) params.summary = summary;
+    if (branch !== undefined) params.branch = branch;
+
+    return this.request("session.navigate", params, SessionRecordSchema);
+  }
+  sessionBranch(id: string, name: string): Promise<ReviewSession> {
+    return this.request("session.branch", { id, name }, SessionRecordSchema);
+  }
+  sessionSwitch(id: string, branch: string): Promise<ReviewSession> {
+    return this.request("session.switch", { id, branch }, SessionRecordSchema);
+  }
+  sessionLabel(id: string, label: string): Promise<ReviewSession> {
+    return this.request("session.label", { id, label }, SessionRecordSchema);
+  }
+  sessionFork(id: string): Promise<ReviewSession> {
+    return this.request("session.fork", { id }, SessionRecordSchema);
+  }
+  sessionRestoreBlock(id: string, baseBlockIndex: number, line?: number): Promise<ReviewSession> {
+    return this.request(
+      "session.restoreBlock",
+      line === undefined ? { id, baseBlockIndex } : { id, baseBlockIndex, line },
+      SessionRecordSchema,
+    );
+  }
+  sessionCurate(id: string, rejections: HunkRejection[]): Promise<ReviewSession> {
+    return this.request("session.curate", { id, rejections }, 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 });
+  sessionMergeShared(id: string, incoming: SharedMerge): Promise<ReviewSession> {
+    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/curate.ts

@@ -0,0 +1,109 @@
+/**
+ * The curated patch of a diff review: the submitted changes minus the hunks and
+ * change blocks the reviewer rejected. The daemon computes it from the
+ * session's reject decisions so the working copy every client sees is one and
+ * the same; the client only maps rows to decisions.
+ */
+
+import { diffAcceptRejectHunk, parseDiffFromFile, type FileDiffMetadata } from "@pierre/diffs";
+import {
+  unifiedDiffText,
+  type DiffFileContents,
+  type DiffFileStatus,
+  type HunkRejection,
+} from "@cueloop/schema";
+
+/**
+ * Context lines around each change. Matching git's default (3) makes the model
+ * split hunks like the rendered working-tree patch does; a row is mapped by
+ * absolute line number, never by counting hunks, so a whole-hunk reject can
+ * only ever span the model hunk it lands in.
+ */
+export const DIFF_CONTEXT = 3;
+
+/** Parse one file's full contents into a non-partial diff model. */
+export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
+  return parseDiffFromFile(
+    { name: file.path, contents: file.oldContents },
+    { name: file.path, contents: file.newContents },
+    { context: DIFF_CONTEXT },
+  );
+}
+
+/**
+ * Apply one file's rejections and return its curated patch, or null when the
+ * curated content equals the old content (every change rejected - no patch).
+ * Whole-hunk rejections supersede change-level ones for the same hunk. Because
+ * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
+ * indices stay valid across calls; they are applied high-to-low regardless, so
+ * the order is deterministic.
+ */
+function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
+  let model = parseFileDiff(file);
+  const wholeHunks = new Set(
+    rejections
+      .filter((rejection) => rejection.changeIndex === undefined)
+      .map((rejection) => rejection.hunkIndex),
+  );
+
+  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
+    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
+  }
+  const changeRejections = rejections
+    .filter(
+      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
+    )
+    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
+
+  for (const rejection of changeRejections) {
+    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
+      type: "reject",
+      changeIndex: rejection.changeIndex!,
+    });
+  }
+  const curatedNew = model.additionLines.join("");
+
+  if (curatedNew === file.oldContents) return null;
+  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
+
+  if (patch === null) return null;
+
+  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
+}
+
+/**
+ * Point the diff headers at /dev/null for a created or fully-deleted file so the
+ * curated patch applies. git's status - not empty contents - decides existence,
+ * so editing an existing empty file stays a modify; a deletion whose removals
+ * were partly restored also falls back to a modify.
+ */
+function withFileStateHeaders(
+  patch: string,
+  path: string,
+  status: DiffFileStatus,
+  curatedNew: string,
+): string {
+  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
+  if (status === "deleted" && curatedNew === "") {
+    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
+  }
+
+  return patch;
+}
+
+/**
+ * The curated unified-diff patch of the accepted changes across every file.
+ * Files with no net change (unchanged, or with all changes rejected) drop out.
+ */
+export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
+  const parts: string[] = [];
+
+  for (const file of files) {
+    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
+    const patch = curateFilePatch(file, fileRejections);
+
+    if (patch) parts.push(patch);
+  }
+
+  return parts.join("\n");
+}

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

@@ -100,6 +100,22 @@ describe("session.refreshDiff", () => {
     expect(events).toContain("session.updated");
   });
 
+  test("a tree move after a refresh keeps the fresh patch", async () => {
+    // Given a refreshed diff session
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 4;\n");
+    await core.sessionRefreshDiff(session.id);
+
+    // When the owner branches off and switches back
+    core.sessionBranch(session.id, "alt");
+    const shown = core.sessionSwitch(session.id, "main");
+
+    // Then the artifact still shows the re-captured working tree, and the history has one revision
+    expect(shown.artifact.content).toContain("+export const a = 4;");
+    expect(shown.history!.entries.filter((entry) => entry.type === "revision")).toHaveLength(1);
+  });
+
   test("is a no-op for a non-diff (plan) session", async () => {
     // Given a plan session in the same workspace
     const workspace = await resolveWorkspace(repo);