agent-canvas 0.1.43 → 0.1.44

package/daemon/client/AnnotationProvider.tsx

@@ -1,7 +1,7 @@
 import React, { useState, useCallback, useEffect, useRef, useMemo } from "react";
 import { AnnotationCtx } from "#canvas/runtime";
 import type { Annotation, AnnotationContext, PlanResponse, FeedbackEntry, AnnotationContextValue } from "#canvas/runtime";
-import { clearPersistedDraft } from "./annotationDraft";
+import { annotationDraftKey, clearPersistedDraft, type AnnotationDraftPhase } from "./annotationDraft";
 import { generateAnnotationId } from "./utils";
 
 // Re-export types for convenience
@@ -12,6 +12,7 @@ interface AnnotationProviderProps {
   sessionId: string;
   revision: number;
   isReadOnly: boolean;
+  draftPhase: AnnotationDraftPhase;
   /** Remote annotations fetched from shared views. Merged read-only into
    *  the annotation list so they render alongside the author's own. */
   remoteAnnotations?: Annotation[];
@@ -25,13 +26,9 @@ interface PersistedState {
   feedbackEntries?: [string, FeedbackEntry][];
 }
 
-function storageKey(sessionId: string, revision: number): string {
-  return `canvas:${sessionId}:rev:${revision}`;
-}
-
-function loadPersisted(sessionId: string, revision: number): PersistedState | null {
+function loadPersisted(sessionId: string, revision: number, phase: AnnotationDraftPhase): PersistedState | null {
   try {
-    const raw = localStorage.getItem(storageKey(sessionId, revision));
+    const raw = localStorage.getItem(annotationDraftKey(sessionId, revision, phase));
     if (!raw) return null;
     return JSON.parse(raw);
   } catch {
@@ -39,15 +36,15 @@ function loadPersisted(sessionId: string, revision: number): PersistedState | nu
   }
 }
 
-function savePersisted(sessionId: string, revision: number, state: PersistedState) {
+function savePersisted(sessionId: string, revision: number, phase: AnnotationDraftPhase, state: PersistedState) {
   try {
-    localStorage.setItem(storageKey(sessionId, revision), JSON.stringify(state));
+    localStorage.setItem(annotationDraftKey(sessionId, revision, phase), JSON.stringify(state));
   } catch {}
 }
 
-export function AnnotationProvider({ sessionId, revision, isReadOnly, remoteAnnotations, children }: AnnotationProviderProps) {
+export function AnnotationProvider({ sessionId, revision, isReadOnly, draftPhase, remoteAnnotations, children }: AnnotationProviderProps) {
   const [localAnnotations, setAnnotations] = useState<Annotation[]>(() => {
-    const saved = loadPersisted(sessionId, revision);
+    const saved = loadPersisted(sessionId, revision, draftPhase);
     return (saved?.annotations ?? []).map((a) => ({ ...a, source: a.source ?? "local" as const }));
   });
 
@@ -61,35 +58,38 @@ export function AnnotationProvider({ sessionId, revision, isReadOnly, remoteAnno
     return [...localAnnotations, ...filtered.map((a) => ({ ...a, source: "remote" as const }))];
   }, [localAnnotations, remoteAnnotations]);
   const [generalNote, setGeneralNote] = useState(() => {
-    const saved = loadPersisted(sessionId, revision);
+    const saved = loadPersisted(sessionId, revision, draftPhase);
     return saved?.generalNote ?? "";
   });
   const [activeAnnotationId, setActiveAnnotationId] = useState<string | null>(null);
   const [responses, setResponses] = useState<Map<string, PlanResponse>>(() => {
-    const saved = loadPersisted(sessionId, revision);
+    const saved = loadPersisted(sessionId, revision, draftPhase);
     return saved?.responses ? new Map(saved.responses) : new Map();
   });
   const [feedbackEntries, setFeedbackEntries] = useState<Map<string, FeedbackEntry>>(() => {
-    const saved = loadPersisted(sessionId, revision);
+    const saved = loadPersisted(sessionId, revision, draftPhase);
     return saved?.feedbackEntries ? new Map(saved.feedbackEntries) : new Map();
   });
 
-  // Persist to localStorage (debounced)
+  // Post-feedback drafts save immediately so a new revision can carry the latest edit.
   const persistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   useEffect(() => {
-    if (isReadOnly) return;
+    if (isReadOnly && draftPhase !== "next") return;
     if (persistTimerRef.current) clearTimeout(persistTimerRef.current);
-    persistTimerRef.current = setTimeout(() => {
-      savePersisted(sessionId, revision, {
-        // Persist only local annotations — remote ones are re-fetched on load.
-        annotations: localAnnotations,
-        generalNote,
-        responses: Array.from(responses.entries()),
-        feedbackEntries: Array.from(feedbackEntries.entries()),
-      });
-    }, 300);
+    const state = {
+      // Persist only local annotations — remote ones are re-fetched on load.
+      annotations: localAnnotations,
+      generalNote,
+      responses: Array.from(responses.entries()),
+      feedbackEntries: Array.from(feedbackEntries.entries()),
+    };
+    if (draftPhase === "next") {
+      savePersisted(sessionId, revision, draftPhase, state);
+      return;
+    }
+    persistTimerRef.current = setTimeout(() => savePersisted(sessionId, revision, draftPhase, state), 300);
     return () => { if (persistTimerRef.current) clearTimeout(persistTimerRef.current); };
-  }, [localAnnotations, generalNote, responses, feedbackEntries, sessionId, revision, isReadOnly]);
+  }, [localAnnotations, generalNote, responses, feedbackEntries, sessionId, revision, isReadOnly, draftPhase]);
 
   const addAnnotationWithId = useCallback((id: string, snippet: string, note: string, filePath?: string, context?: AnnotationContext, images?: string[], canvasFile?: string) => {
     setAnnotations((prev) => [...prev, { id, snippet, note, createdAt: new Date().toISOString(), filePath, context, ...(images?.length ? { images } : {}), ...(canvasFile ? { canvasFile } : {}) }]);
@@ -159,8 +159,12 @@ export function AnnotationProvider({ sessionId, revision, isReadOnly, remoteAnno
     setActiveAnnotationId(null);
     setResponses(new Map());
     setFeedbackEntries(new Map());
-    clearPersistedDraft(localStorage, sessionId, revision);
-  }, [sessionId, revision]);
+    if (draftPhase === "next") {
+      localStorage.removeItem(annotationDraftKey(sessionId, revision, draftPhase));
+    } else {
+      clearPersistedDraft(localStorage, sessionId, revision);
+    }
+  }, [sessionId, revision, draftPhase]);
 
   return (
     <AnnotationCtx.Provider

package/daemon/client/App.tsx

@@ -21,7 +21,7 @@ import { ShareDialog, ShareButton, type ShareEntry } from "./ShareDialog";
 import { ReviewerIdentityDialog } from "./ReviewerIdentityDialog";
 import type { Annotation } from "#canvas/runtime";
 import { MODE, fetchMeta, FS_AVAILABLE, WS_AVAILABLE, submitSharedFeedback, getReviewerIdentity, setReviewerIdentity } from "./clientApi";
-import { carryUnsubmittedDraft, clearPersistedDraft } from "./annotationDraft";
+import { carryUnsubmittedDraft, clearPersistedDraft, type AnnotationDraftPhase } from "./annotationDraft";
 import { RenderErrorContext, type CanvasRenderError } from "./RenderErrorContext";
 
 export type ActiveView = { type: "overview" } | { type: "canvas"; filename: string } | { type: "file"; path: string };
@@ -297,6 +297,10 @@ function App() {
 
   const selectedRevInfo = revisions.find((r) => r.revision === selectedRevision);
   const isReadOnly = selectedRevision !== currentRevision || !!selectedRevInfo?.hasFeedback || sharedFeedbackSubmitted;
+  // Keep feedback added after submission separate from the already-sent draft.
+  const draftPhase: AnnotationDraftPhase = selectedRevision === currentRevision && (!!selectedRevInfo?.hasFeedback || sharedFeedbackSubmitted)
+    ? "next"
+    : "current";
 
   const setActiveView = useCallback((v: ActiveView) => {
     // Save current scroll position before switching
@@ -519,10 +523,11 @@ function App() {
       <RenderErrorContext.Provider value={reportRenderError}>
         <RevisionContext.Provider value={{ currentRevision, selectedRevision, revisions, setSelectedRevision, isReadOnly, compareRevision, setCompareRevision, agentWatching }}>
           <AnnotationProvider
-            key={`${sessionId}:${selectedRevision}`}
+            key={`${sessionId}:${selectedRevision}:${draftPhase}`}
             sessionId={sessionId}
             revision={selectedRevision}
             isReadOnly={isReadOnly}
+            draftPhase={draftPhase}
             remoteAnnotations={remoteAnnotationsByRev.get(selectedRevision)}
           >
           <ActiveViewContext.Provider value={{ activeView, setActiveView, openFiles, closeFile, canvasFiles }}>

package/daemon/client/annotationDraft.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { carryUnsubmittedDraft, clearPersistedDraft } from "./annotationDraft";
+import { annotationDraftKey, carryUnsubmittedDraft, clearPersistedDraft } from "./annotationDraft";
 
 class MemoryStorage {
   private readonly values = new Map<string, string>();
@@ -18,7 +18,8 @@ class MemoryStorage {
 }
 
 const sessionId = "session";
-const key = (revision: number) => `canvas:${sessionId}:rev:${revision}`;
+const key = (revision: number) => annotationDraftKey(sessionId, revision);
+const nextKey = (revision: number) => annotationDraftKey(sessionId, revision, "next");
 
 describe("carryUnsubmittedDraft", () => {
   test("clears a submitted draft and its carry marker", () => {
@@ -78,6 +79,44 @@ describe("carryUnsubmittedDraft", () => {
     expect(storage.getItem(key(3))).toBeNull();
   });
 
+  test("carries a post-feedback draft into the next revision", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({
+      annotations: [{ id: "submitted-annotation" }],
+      generalNote: "Submitted feedback",
+      responses: [],
+    }));
+    storage.setItem(nextKey(2), JSON.stringify({
+      annotations: [{ id: "next-annotation" }],
+      generalNote: "",
+      responses: [],
+      feedbackEntries: [["generated", { markdown: "stale generated content" }]],
+    }));
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 3, [
+      { revision: 2, hasFeedback: true },
+      { revision: 3, hasFeedback: false },
+    ])).toBe(2);
+    expect(JSON.parse(storage.getItem(key(3)) ?? "")).toEqual({
+      annotations: [{ id: "next-annotation" }],
+      generalNote: "",
+      responses: [],
+      feedbackEntries: [],
+    });
+    expect(storage.getItem(nextKey(2))).toBeNull();
+  });
+
+  test("clearing submitted feedback preserves its next-revision draft", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({ annotations: [{ id: "submitted" }] }));
+    storage.setItem(nextKey(2), JSON.stringify({ annotations: [{ id: "next" }] }));
+
+    clearPersistedDraft(storage, sessionId, 2);
+
+    expect(storage.getItem(key(2))).toBeNull();
+    expect(storage.getItem(nextKey(2))).not.toBeNull();
+  });
+
   test("does not overwrite meaningful target data", () => {
     const storage = new MemoryStorage();
     storage.setItem(key(2), JSON.stringify({

package/daemon/client/annotationDraft.ts

@@ -6,18 +6,26 @@ interface RevisionState {
 interface AnnotationStorage {
   getItem(key: string): string | null;
   setItem(key: string, value: string): void;
+  removeItem(key: string): void;
 }
 
 interface RemovableAnnotationStorage {
   removeItem(key: string): void;
 }
 
-function storageKey(sessionId: string, revision: number): string {
-  return `canvas:${sessionId}:rev:${revision}`;
+export type AnnotationDraftPhase = "current" | "next";
+
+export function annotationDraftKey(
+  sessionId: string,
+  revision: number,
+  phase: AnnotationDraftPhase = "current",
+): string {
+  const base = `canvas:${sessionId}:rev:${revision}`;
+  return phase === "next" ? `${base}:next-draft` : base;
 }
 
 function handledKey(sessionId: string, revision: number): string {
-  return `${storageKey(sessionId, revision)}:draft-handled`;
+  return `${annotationDraftKey(sessionId, revision)}:draft-handled`;
 }
 
 export function clearPersistedDraft(
@@ -26,7 +34,7 @@ export function clearPersistedDraft(
   revision: number,
 ): void {
   try {
-    storage.removeItem(storageKey(sessionId, revision));
+    storage.removeItem(annotationDraftKey(sessionId, revision));
     storage.removeItem(handledKey(sessionId, revision));
   } catch {}
 }
@@ -77,7 +85,7 @@ export function carryUnsubmittedDraft(
   revisions: RevisionState[],
 ): number | null {
   try {
-    const targetKey = storageKey(sessionId, targetRevision);
+    const targetKey = annotationDraftKey(sessionId, targetRevision);
     if (hasDraftContent(parseState(storage.getItem(targetKey)))) {
       storage.setItem(handledKey(sessionId, targetRevision), "1");
       return null;
@@ -89,9 +97,21 @@ export function carryUnsubmittedDraft(
       .sort((left, right) => right.revision - left.revision);
 
     for (const revision of previous) {
-      if (revision.hasFeedback) return null;
+      if (revision.hasFeedback) {
+        const sourceKey = annotationDraftKey(sessionId, revision.revision, "next");
+        const source = parseState(storage.getItem(sourceKey));
+        if (!hasDraftContent(source)) return null;
+
+        storage.setItem(targetKey, JSON.stringify({
+          ...source,
+          feedbackEntries: [],
+        }));
+        storage.setItem(handledKey(sessionId, targetRevision), "1");
+        storage.removeItem(sourceKey);
+        return revision.revision;
+      }
 
-      const source = parseState(storage.getItem(storageKey(sessionId, revision.revision)));
+      const source = parseState(storage.getItem(annotationDraftKey(sessionId, revision.revision)));
       if (!hasDraftContent(source)) {
         if (storage.getItem(handledKey(sessionId, revision.revision)) !== null) return null;
         continue;