agent-canvas 0.1.26 → 0.1.28

package/daemon/src/handlers/api.ts

@@ -3,6 +3,7 @@ import type { SessionManager } from "../session";
 import { compilePlan } from "../compiler";
 import { watchSession } from "../watcher";
 import { jsonResponse } from "./utils";
+import { loadShareConfig, shareRevision, revokeShare } from "../share";
 import type { Route } from "../router";
 
 export interface ApiContext {
@@ -154,9 +155,67 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
       canvasFiles: session.canvasFiles,
       createdAt: session.createdAt,
       updatedAt: session.updatedAt,
+      shares: session.shares ?? [],
+      shareEnabled: !!process.env.CANVAS_SHARE_ENDPOINT,
     });
   }
 
+  async function handleShareRevision(_req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
+    const sessionId = match.pathname.groups.id!;
+    const rev = parseInt(match.pathname.groups.rev!, 10);
+
+    const session = sessionManager.get(sessionId);
+    if (!session) return jsonResponse({ error: "Session not found" }, 404);
+    if (!session.revisions.find((r) => r.revision === rev)) {
+      return jsonResponse({ error: `Revision ${rev} not found` }, 404);
+    }
+
+    const config = loadShareConfig(ctx.version);
+    if (!config) {
+      return jsonResponse({
+        error: "Sharing disabled. Set CANVAS_SHARE_ENDPOINT to the deployed canvas-share worker URL.",
+      }, 501);
+    }
+
+    try {
+      const entry = await shareRevision(sessionManager, sessionId, rev, config);
+      broadcastRevisionUpdate(sessionId);
+      return jsonResponse({ ok: true, share: entry });
+    } catch (e: any) {
+      return jsonResponse({ error: e.message || String(e) }, 502);
+    }
+  }
+
+  async function handleShareRevoke(_req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
+    const sessionId = match.pathname.groups.id!;
+    const shareId = match.pathname.groups.shareId!;
+    if (!sessionManager.get(sessionId)) return jsonResponse({ error: "Session not found" }, 404);
+    const config = loadShareConfig(ctx.version);
+    if (!config) return jsonResponse({ error: "Sharing disabled" }, 501);
+    try {
+      await revokeShare(sessionManager, sessionId, shareId, config);
+      broadcastRevisionUpdate(sessionId);
+      return jsonResponse({ ok: true });
+    } catch (e: any) {
+      return jsonResponse({ error: e.message || String(e) }, 502);
+    }
+  }
+
+  function handleSharesList(_req: Request, _url: URL, match: URLPatternResult): Response {
+    const sessionId = match.pathname.groups.id!;
+    const session = sessionManager.get(sessionId);
+    if (!session) return jsonResponse({ error: "Session not found" }, 404);
+    return jsonResponse({ shares: session.shares ?? [] });
+  }
+
+  function handleRemoteFeedbackGet(_req: Request, _url: URL, match: URLPatternResult): Response {
+    const sessionId = match.pathname.groups.id!;
+    const rev = parseInt(match.pathname.groups.rev!, 10);
+    if (!sessionManager.get(sessionId)) return jsonResponse({ error: "Session not found" }, 404);
+    const entries = sessionManager.getRemoteFeedback(sessionId, rev);
+    return jsonResponse({ entries });
+  }
+
   function handleSessions(): Response {
     return jsonResponse(sessionManager.list().map((s) => ({
       id: s.id,
@@ -190,6 +249,10 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
     { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/meta" }), handler: handleMeta },
     { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/revision/:rev/feedback" }), handler: handleFeedbackGet },
     { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/feedback/consume" }), handler: handleFeedbackConsume },
+    { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/revision/:rev/share" }), handler: handleShareRevision },
+    { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/shares/:shareId/revoke" }), handler: handleShareRevoke },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/shares" }), handler: handleSharesList },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/revision/:rev/remote-feedback" }), handler: handleRemoteFeedbackGet },
     { method: "GET", pattern: new URLPattern({ pathname: "/api/sessions" }), handler: handleSessions },
   ];
 }

package/daemon/src/remote-feedback.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Tests for the remote feedback poller. Uses a real SessionManager with
+ * a real share recorded on a session, and mocks `fetch` to simulate
+ * worker responses. Verifies persistence, broadcast, dedup, and backoff.
+ */
+
+import { describe, expect, test, afterEach, beforeEach } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { SessionManager } from "./session";
+import { startRemoteFeedbackPoller } from "./remote-feedback";
+
+let testDir: string;
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), "canvas-rf-test-"));
+});
+afterEach(() => {
+  try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+});
+
+function newSessionManager(): SessionManager {
+  return new SessionManager(testDir);
+}
+
+const originalFetch = globalThis.fetch;
+const originalEndpoint = process.env.CANVAS_SHARE_ENDPOINT;
+
+beforeEach(() => {
+  process.env.CANVAS_SHARE_ENDPOINT = "https://mock.example.com";
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  if (originalEndpoint !== undefined) process.env.CANVAS_SHARE_ENDPOINT = originalEndpoint;
+  else delete process.env.CANVAS_SHARE_ENDPOINT;
+});
+
+function setupSession(sm: SessionManager): { sessionId: string; shareId: string } {
+  const sessionId = `test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const shareId = "abc123def456";
+  sm.upsert(sessionId, new Map([["plan.jsx", "x"]]), "/tmp");
+  sm.saveCompiled(sessionId, "plan.jsx", "x");
+  sm.addShare(sessionId, {
+    shareId,
+    url: "https://mock.example.com/s/" + shareId,
+    revision: 1,
+    createdAt: new Date().toISOString(),
+  });
+  return { sessionId, shareId };
+}
+
+describe("startRemoteFeedbackPoller", () => {
+  test("persists fetched entries and updates lastFeedbackAt", async () => {
+    const sm = newSessionManager();
+    const { sessionId, shareId } = setupSession(sm);
+
+    let calls = 0;
+    (globalThis as any).fetch = async (url: any) => {
+      calls++;
+      expect(String(url)).toContain(`/shares/${shareId}/feedback`);
+      return new Response(JSON.stringify({
+        entries: [{
+          id: "fb1",
+          shareId,
+          revision: 1,
+          submittedAt: "2026-04-09T10:00:00.000Z",
+          author: { id: "u1", name: "Alice" },
+          annotations: [{
+            id: "a1",
+            snippet: "x",
+            note: "good",
+            createdAt: "2026-04-09T10:00:00.000Z",
+          }],
+        }],
+        latestAt: "2026-04-09T10:00:00.000Z",
+      }), { status: 200 });
+    };
+
+    let broadcasted: { sessionId: string; revision: number; count: number }[] = [];
+    const broadcast = (sid: string, rev: number, entries: any[]) => {
+      broadcasted.push({ sessionId: sid, revision: rev, count: entries.length });
+    };
+
+    const poller = startRemoteFeedbackPoller(sm, broadcast, "0.0.0");
+    // Wait for at least one poll cycle
+    await new Promise((r) => setTimeout(r, 100));
+    poller.stop();
+
+    expect(calls).toBeGreaterThanOrEqual(1);
+    expect(broadcasted.length).toBeGreaterThanOrEqual(1);
+    expect(broadcasted[0].sessionId).toBe(sessionId);
+    expect(broadcasted[0].revision).toBe(1);
+    expect(broadcasted[0].count).toBe(1);
+
+    const persisted = sm.getRemoteFeedback(sessionId, 1);
+    expect(persisted).toHaveLength(1);
+    expect(persisted[0].id).toBe("fb1");
+    expect(persisted[0].author.name).toBe("Alice");
+
+    const updatedShare = sm.getShares(sessionId).find((s) => s.shareId === shareId);
+    expect(updatedShare?.lastFeedbackAt).toBe("2026-04-09T10:00:00.000Z");
+
+    sm.remove(sessionId);
+  });
+
+  test("dedupes entries by id across polls", async () => {
+    const sm = newSessionManager();
+    const { sessionId } = setupSession(sm);
+
+    const sameEntry = {
+      id: "fb-same",
+      shareId: "abc123def456",
+      revision: 1,
+      submittedAt: "2026-04-09T10:00:00.000Z",
+      author: { id: "u1", name: "Bob" },
+      annotations: [],
+    };
+
+    (globalThis as any).fetch = async () => new Response(JSON.stringify({ entries: [sameEntry] }), { status: 200 });
+
+    const poller = startRemoteFeedbackPoller(sm, () => {}, "0.0.0");
+    await new Promise((r) => setTimeout(r, 200));
+    poller.stop();
+
+    // Even after multiple polls returning the same entry, only one should be persisted.
+    const persisted = sm.getRemoteFeedback(sessionId, 1);
+    expect(persisted).toHaveLength(1);
+
+    sm.remove(sessionId);
+  });
+
+  test("404 stops further polls (revoked share)", async () => {
+    const sm = newSessionManager();
+    const { sessionId, shareId } = setupSession(sm);
+
+    let calls = 0;
+    (globalThis as any).fetch = async () => {
+      calls++;
+      return new Response("not found", { status: 404 });
+    };
+
+    const poller = startRemoteFeedbackPoller(sm, () => {}, "0.0.0");
+    await new Promise((r) => setTimeout(r, 200));
+    poller.stop();
+
+    // After the first 404 the share is marked dead — calls should stay at 1.
+    expect(calls).toBe(1);
+    void shareId;
+    sm.remove(sessionId);
+  });
+
+  test("does nothing when no shares exist", async () => {
+    const sm = newSessionManager();
+    let calls = 0;
+    (globalThis as any).fetch = async () => { calls++; return new Response("", { status: 200 }); };
+
+    const poller = startRemoteFeedbackPoller(sm, () => {}, "0.0.0");
+    await new Promise((r) => setTimeout(r, 100));
+    poller.stop();
+
+    expect(calls).toBe(0);
+  });
+
+  test("does nothing when CANVAS_SHARE_ENDPOINT not set", async () => {
+    delete process.env.CANVAS_SHARE_ENDPOINT;
+
+    const sm = newSessionManager();
+    setupSession(sm);
+    let calls = 0;
+    (globalThis as any).fetch = async () => { calls++; return new Response("", { status: 200 }); };
+
+    const poller = startRemoteFeedbackPoller(sm, () => {}, "0.0.0");
+    await new Promise((r) => setTimeout(r, 100));
+    poller.stop();
+
+    expect(calls).toBe(0);
+  });
+});

package/daemon/src/remote-feedback.ts

@@ -0,0 +1,128 @@
+import type { SessionManager, RemoteFeedbackEntry } from "./session";
+import { loadShareConfig } from "./share";
+
+/**
+ * Background polling loop for remote feedback.
+ *
+ * For every session that has at least one share, periodically asks the
+ * CF Worker for feedback submitted since we last checked. New entries are
+ * persisted locally (as `remote_feedback.json` per revision) and broadcast
+ * to any connected browser WebSockets so the UI can merge them into the
+ * annotation layer in real time.
+ *
+ * The polling loop is cheap: one HTTP call per share per 5 seconds. If no
+ * shares exist anywhere, the loop sleeps. If the worker is unreachable,
+ * errors are logged but the loop keeps running so feedback is picked up
+ * as soon as the worker comes back.
+ */
+
+const POLL_INTERVAL_MS = 5_000;
+const MAX_BACKOFF_MS = 60_000;
+
+interface WorkerFeedbackResponse {
+  entries: RemoteFeedbackEntry[];
+  /** Server-reported high water mark — echo back in the next `since` param */
+  latestAt?: string;
+}
+
+export function startRemoteFeedbackPoller(
+  sessionManager: SessionManager,
+  broadcastRemoteFeedback: (sessionId: string, revision: number, entries: RemoteFeedbackEntry[]) => void,
+  version: string,
+): { stop: () => void } {
+  let stopped = false;
+
+  // Per-share consecutive error count → exponential backoff so a dead
+  // worker doesn't generate a fire-hose of failed requests.
+  const errorCounts = new Map<string, number>();
+  function backoffFor(shareId: string): number {
+    const errors = errorCounts.get(shareId) || 0;
+    if (errors === 0) return 0;
+    return Math.min(MAX_BACKOFF_MS, POLL_INTERVAL_MS * Math.pow(2, errors - 1));
+  }
+
+  async function pollShare(sessionId: string, share: { shareId: string; lastFeedbackAt?: string }, endpoint: string) {
+    try {
+      const since = share.lastFeedbackAt ?? "";
+      const url = `${endpoint}/shares/${share.shareId}/feedback${since ? `?since=${encodeURIComponent(since)}` : ""}`;
+      const res = await fetch(url);
+      if (!res.ok) {
+        if (res.status === 404) {
+          // Share no longer exists on the worker — likely revoked or expired.
+          // Stop trying so we don't hammer it forever.
+          errorCounts.set(share.shareId, 99);
+          return;
+        }
+        throw new Error(`HTTP ${res.status}`);
+      }
+      const data = (await res.json()) as WorkerFeedbackResponse;
+      errorCounts.delete(share.shareId);
+
+      if (!data.entries || data.entries.length === 0) return;
+
+      const byRev = new Map<number, RemoteFeedbackEntry[]>();
+      for (const e of data.entries) {
+        if (!byRev.has(e.revision)) byRev.set(e.revision, []);
+        byRev.get(e.revision)!.push(e);
+      }
+
+      for (const [rev, entries] of byRev) {
+        sessionManager.appendRemoteFeedback(sessionId, rev, entries);
+        broadcastRemoteFeedback(sessionId, rev, entries);
+      }
+
+      const latest = data.latestAt
+        ?? data.entries.reduce((acc, e) => (e.submittedAt > acc ? e.submittedAt : acc), share.lastFeedbackAt ?? "");
+      if (latest) {
+        sessionManager.updateShareLastFeedback(sessionId, share.shareId, latest);
+      }
+    } catch (e: any) {
+      errorCounts.set(share.shareId, (errorCounts.get(share.shareId) || 0) + 1);
+      console.warn(`[remote-feedback] ${share.shareId}: ${e.message || e} (will retry with backoff)`);
+    }
+  }
+
+  // Per-share next-poll timestamps so backoffs are independent.
+  const nextPollAt = new Map<string, number>();
+
+  async function pollOnce() {
+    const config = loadShareConfig(version);
+    if (!config) return;
+
+    const sessions = sessionManager.listSessionsWithShares();
+    if (sessions.length === 0) return;
+
+    const now = Date.now();
+    const tasks: Promise<void>[] = [];
+    for (const session of sessions) {
+      for (const share of session.shares ?? []) {
+        const next = nextPollAt.get(share.shareId) || 0;
+        if (now < next) continue;
+        // Skip "permanently dead" shares (after a 404).
+        if ((errorCounts.get(share.shareId) || 0) >= 99) continue;
+        nextPollAt.set(share.shareId, now + Math.max(POLL_INTERVAL_MS, backoffFor(share.shareId)));
+        tasks.push(pollShare(session.id, share, config.endpoint));
+      }
+    }
+    await Promise.all(tasks);
+  }
+
+  async function loop() {
+    while (!stopped) {
+      try {
+        await pollOnce();
+      } catch (e: any) {
+        console.warn(`[remote-feedback] loop error: ${e.message || e}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+  }
+
+  loop();
+
+  return {
+    stop: () => {
+      stopped = true;
+    },
+  };
+}

package/daemon/src/server.ts

@@ -9,6 +9,7 @@ import { createApiHandlers } from "./handlers/api";
 import { createFileHandlers } from "./handlers/files";
 import { createStaticHandlers } from "./handlers/static";
 import { createUploadHandlers } from "./handlers/uploads";
+import { startRemoteFeedbackPoller } from "./remote-feedback";
 
 const PORT = parseInt(process.env.CANVAS_PORT || "19400", 10);
 const VERSION = JSON.parse(readFileSync(join(dirname(import.meta.dir), "..", "package.json"), "utf-8")).version as string;
@@ -82,4 +83,8 @@ export const broadcastPlanUpdate = wsManager.broadcastPlanUpdate;
 
 setInterval(() => sessionManager.cleanupStale(), 60 * 60 * 1000);
 
+// Start polling for remote feedback from shared canvases.
+// No-ops if CANVAS_SHARE_ENDPOINT is not set.
+startRemoteFeedbackPoller(sessionManager, wsManager.broadcastRemoteFeedback, VERSION);
+
 console.log(`Planner daemon listening on http://localhost:${PORT}`);

package/daemon/src/session.ts

@@ -22,6 +22,64 @@ export interface RevisionInfo {
   response?: string;
 }
 
+/**
+ * A single piece of feedback received from a remote (shared) reviewer.
+ * Structured so it can be merged into the local annotation system alongside
+ * the author's own annotations. `annotations` is the structured list of
+ * highlighted-text comments; `generalNote` is the free-form markdown.
+ */
+export interface RemoteFeedbackEntry {
+  /** Stable unique id assigned by the worker; used to dedupe on re-poll */
+  id: string;
+  shareId: string;
+  revision: number;
+  /** ISO timestamp when the reviewer submitted */
+  submittedAt: string;
+  author: { id: string; name: string };
+  annotations: RemoteAnnotation[];
+  generalNote?: string;
+}
+
+/**
+ * Mirror of the client-side Annotation shape, minus fields that only make
+ * sense locally. Kept intentionally narrow so the wire format is stable.
+ */
+export interface RemoteAnnotation {
+  id: string;
+  snippet: string;
+  note: string;
+  createdAt: string;
+  filePath?: string;
+  canvasFile?: string;
+  context?: {
+    before: string;
+    after: string;
+    hierarchy: string[];
+    lineStart?: number;
+    lineEnd?: number;
+  };
+  attachments?: { url: string; mime?: string }[];
+}
+
+/**
+ * A share is a snapshot of a specific revision that has been pushed to a
+ * remote endpoint (CF Worker) for external review. The `shareId` is the
+ * opaque capability token returned by the worker; the `url` is the full
+ * public URL the user shared with reviewers.
+ */
+export interface ShareEntry {
+  shareId: string;
+  url: string;
+  revision: number;
+  createdAt: string;
+  /** Bearer token returned by the worker — proves ownership for revoke. */
+  ownerToken?: string;
+  /** ISO timestamp when the share will expire on the worker side. */
+  expiresAt?: string;
+  /** ISO timestamp of the most recent remote feedback we've seen */
+  lastFeedbackAt?: string;
+}
+
 export interface SessionData {
   id: string;
   projectRoot: string;
@@ -30,6 +88,7 @@ export interface SessionData {
   revisions: RevisionInfo[];
   createdAt: string;
   updatedAt: string;
+  shares?: ShareEntry[];
 }
 
 interface SessionMeta {
@@ -38,6 +97,7 @@ interface SessionMeta {
   updatedAt: string;
   currentRevision: number;
   revisions: RevisionInfo[];
+  shares?: ShareEntry[];
 }
 
 // Legacy format (flat files, pre-revision)
@@ -85,14 +145,22 @@ function computeLineDiffStats(oldText: string, newText: string): DiffStats {
 
 export class SessionManager {
   private sessions = new Map<string, SessionData>();
+  private readonly sessionsDir: string;
 
-  constructor() {
-    mkdirSync(SESSIONS_DIR, { recursive: true });
+  /**
+   * @param sessionsDir Override the on-disk sessions root. Defaults to
+   *   the global SESSIONS_DIR (`~/.claude/agent-canvas/sessions`).
+   *   Tests pass an isolated temp directory so they don't interfere with
+   *   the user's real sessions.
+   */
+  constructor(sessionsDir?: string) {
+    this.sessionsDir = sessionsDir ?? SESSIONS_DIR;
+    mkdirSync(this.sessionsDir, { recursive: true });
     this.loadFromDisk();
   }
 
   private sessionDir(id: string): string {
-    return join(SESSIONS_DIR, id);
+    return join(this.sessionsDir, id);
   }
 
   private revisionDir(id: string, rev: number): string {
@@ -126,10 +194,10 @@ export class SessionManager {
   }
 
   private loadFromDisk() {
-    if (!existsSync(SESSIONS_DIR)) return;
-    for (const name of readdirSync(SESSIONS_DIR, { withFileTypes: true })) {
+    if (!existsSync(this.sessionsDir)) return;
+    for (const name of readdirSync(this.sessionsDir, { withFileTypes: true })) {
       if (!name.isDirectory()) continue;
-      const dir = join(SESSIONS_DIR, name.name);
+      const dir = join(this.sessionsDir, name.name);
       const metaPath = join(dir, "meta.json");
       if (!existsSync(metaPath)) continue;
 
@@ -186,6 +254,7 @@ export class SessionManager {
           revisions: meta.revisions,
           createdAt: meta.createdAt,
           updatedAt: meta.updatedAt,
+          ...(meta.shares ? { shares: meta.shares } : {}),
         });
       } catch {}
     }
@@ -321,10 +390,46 @@ export class SessionManager {
       updatedAt: session.updatedAt,
       currentRevision: session.currentRevision,
       revisions: session.revisions,
+      ...(session.shares?.length ? { shares: session.shares } : {}),
     };
     writeFileSync(join(this.sessionDir(session.id), "meta.json"), JSON.stringify(meta, null, 2));
   }
 
+  /** Record a new share for a session revision. */
+  addShare(id: string, entry: ShareEntry): void {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.shares = [...(session.shares ?? []), entry];
+    session.updatedAt = new Date().toISOString();
+    this.persistMeta(session);
+  }
+
+  getShares(id: string): ShareEntry[] {
+    return this.sessions.get(id)?.shares ?? [];
+  }
+
+  removeShare(id: string, shareId: string): void {
+    const session = this.sessions.get(id);
+    if (!session?.shares) return;
+    session.shares = session.shares.filter((s) => s.shareId !== shareId);
+    session.updatedAt = new Date().toISOString();
+    this.persistMeta(session);
+  }
+
+  updateShareLastFeedback(id: string, shareId: string, at: string): void {
+    const session = this.sessions.get(id);
+    if (!session?.shares) return;
+    const entry = session.shares.find((s) => s.shareId === shareId);
+    if (!entry) return;
+    entry.lastFeedbackAt = at;
+    this.persistMeta(session);
+  }
+
+  /** List all sessions that have at least one share. Used by the remote feedback poller. */
+  listSessionsWithShares(): SessionData[] {
+    return Array.from(this.sessions.values()).filter((s) => (s.shares?.length ?? 0) > 0);
+  }
+
   private persistToDisk(session: SessionData, canvasFiles: Map<string, string>) {
     const revDir = this.revisionDir(session.id, session.currentRevision);
     mkdirSync(revDir, { recursive: true });
@@ -419,6 +524,34 @@ export class SessionManager {
     return join(this.revisionDir(id, rev), filename);
   }
 
+  /**
+   * Remote feedback from shared views. Stored as one JSON file per revision
+   * at `revisions/{rev}/remote_feedback.json`, containing an array of
+   * RemoteFeedbackEntry. Appended to (not replaced) as new feedback arrives.
+   */
+  appendRemoteFeedback(id: string, rev: number, entries: RemoteFeedbackEntry[]): void {
+    if (entries.length === 0) return;
+    const revDir = this.revisionDir(id, rev);
+    mkdirSync(revDir, { recursive: true });
+    const file = join(revDir, "remote_feedback.json");
+    let existing: RemoteFeedbackEntry[] = [];
+    try {
+      existing = JSON.parse(readFileSync(file, "utf-8"));
+    } catch {}
+    const seen = new Set(existing.map((e) => e.id));
+    const merged = [...existing];
+    for (const e of entries) if (!seen.has(e.id)) merged.push(e);
+    writeFileSync(file, JSON.stringify(merged, null, 2));
+  }
+
+  getRemoteFeedback(id: string, rev: number): RemoteFeedbackEntry[] {
+    try {
+      return JSON.parse(readFileSync(join(this.revisionDir(id, rev), "remote_feedback.json"), "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+
   cleanupStale(maxAge = STALE_TIMEOUT_MS) {
     const now = Date.now();
     for (const [id, session] of this.sessions) {