@1agh/maude 1.2.0 → 1.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Maude
 
-A personal marketplace of Claude Code plugins. Two plugins today, plus a `maude` CLI for scaffolding and running the bundled dev tooling.
+A personal marketplace of Claude Code and Codex plugins. Two plugins today, plus a `maude` CLI for scaffolding and running the bundled dev tooling.
 
 <!-- Demo video lives at https://github.com/1aGh/maude/releases/download/v0.16.0/demo.mp4 once uploaded.
      Until then the inline tag below stays a soft 404; landing page at https://maude.sh autoplays the same file. -->
@@ -18,6 +18,8 @@ Plus the **`maude`** CLI — `maude init` scaffolds a fresh `.ai/` workspace fro
 
 ## Quick start
 
+**Codex CLI:** use the [native plugin installation guide](docs/native-plugins.md). It uses the same workflow procedures; Studio ACP support is a separate follow-up.
+
 > **Using Maude Desktop?** With only **Claude Code installed**, the desktop app's built-in chat panel auto-loads the `design` + `flow` plugins for its session — `/design:*` and `/flow:*` just work, nothing to install (power users who already installed the plugins see a no-op, no double-load). The steps below are the **manual / power-user path** — for the `maude` CLI, the web `maude design serve` flow, or driving `/design:*` from your own terminal Claude Code. Full detail: [maude.sh/desktop](https://maude.sh/desktop).
 
 ### 1. Add the marketplace inside Claude Code

package/apps/studio/acp/index.ts

@@ -101,14 +101,28 @@ const BEAT_MS = 4000;
 
 interface AgentActivityTracker {
   onUpdate(update: SessionUpdate): void;
-  /** Turn finished (normal, cancel, error) or socket closed — clear banners. */
-  endTurn(): void;
+  /**
+   * Turn finished (normal, cancel, error) or socket closed — clear banners.
+   * T16: `done` publishes what the turn wrote as ONE project action; anything
+   * else (cancel, error, token limit, reap) keeps it unpublished for the
+   * person's decision. Default `failed` — only a clean end publishes.
+   */
+  endTurn(outcome?: 'done' | 'failed'): void;
+  /** The prompt this turn answers — the action's history label. */
+  beginTurn?(prompt: string): void;
 }
 
 /** Exported for tests (acp-ai-activity.test.ts); not part of the Acp surface. */
-export function createAgentActivityTracker(ctx: Context, ai: AiActivity): AgentActivityTracker {
+export function createAgentActivityTracker(
+  ctx: Context,
+  ai: AiActivity,
+  chatId = 'default'
+): AgentActivityTracker {
   const kindByToolCall = new Map<string, string>(); // toolCallId → kind
   const lastBeat = new Map<string, number>(); // ai-activity key → last beat ms
+  const actionKey = `acp:${chatId}`;
+  let turnLabel = 'Claude edit';
+  let actionOpen = false;
 
   function keyFor(p: unknown): string | null {
     if (typeof p !== 'string' || !p) return null;
@@ -145,6 +159,11 @@ export function createAgentActivityTracker(ctx: Context, ai: AiActivity): AgentA
     for (const p of candidates) {
       const key = keyFor(p);
       if (!key) continue;
+      if (!actionOpen) {
+        // T16 — the turn's first canvas edit opens its project action.
+        actionOpen = true;
+        ctx.syncControl?.current?.()?.beginAiAction?.(actionKey, turnLabel);
+      }
       const last = lastBeat.get(key);
       if (last == null) {
         ai.start(key, AGENT_AUTHOR);
@@ -156,13 +175,25 @@ export function createAgentActivityTracker(ctx: Context, ai: AiActivity): AgentA
     }
   }
 
-  function endTurn(): void {
+  function endTurn(outcome: 'done' | 'failed' = 'failed'): void {
     for (const key of lastBeat.keys()) ai.end(key);
     lastBeat.clear();
     kindByToolCall.clear();
+    if (actionOpen) {
+      actionOpen = false;
+      void ctx.syncControl
+        ?.current?.()
+        ?.endAiAction?.(actionKey, outcome)
+        ?.catch(() => {});
+    }
+  }
+
+  function beginTurn(prompt: string): void {
+    const words = prompt.replace(/\s+/g, ' ').trim().slice(0, 80);
+    turnLabel = words ? `Claude: ${words}` : 'Claude edit';
   }
 
-  return { onUpdate, endTurn };
+  return { onUpdate, endTurn, beginTurn };
 }
 
 // ── Detached bridge lifetime (feature-acp-write-path-scope Addendum, Task 8) ──
@@ -328,7 +359,7 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
         return null;
       }
     }
-    const tracker = aiActivity ? createAgentActivityTracker(ctx, aiActivity) : null;
+    const tracker = aiActivity ? createAgentActivityTracker(ctx, aiActivity, chatId) : null;
     // Declared before the bridge so the callbacks below can close over it —
     // they fan out to `entry.sinks`, which changes as sockets come and go,
     // rather than capturing one socket the way the per-socket design did.
@@ -548,9 +579,14 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
     // first await, so a socket that closes during the spawn still counts as a
     // live turn rather than an abandoned bridge.
     entry.turnActive = true;
+    entry.tracker?.beginTurn?.(text);
+    let turnOutcome: 'done' | 'failed' = 'failed';
     try {
       await bridge.ensureStarted();
       const { stopReason } = await bridge.prompt(text, sanitizeChatId(chatId));
+      // Only a turn that ended on its own publishes; a cancel, a refusal or a
+      // token limit leaves its edits for the person (T16).
+      if (stopReason === 'end_turn') turnOutcome = 'done';
       broadcast(entry, { t: 'connected', sessionId: bridge.sessionId });
       broadcast(entry, { t: 'turn-end', stopReason });
     } catch (err) {
@@ -564,7 +600,7 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
       // RC5 — the turn is over (success, error, or cancel-induced stop): clear
       // every "Claude is editing …" banner this turn raised. The 30 s heartbeat
       // grace still covers a crashed dev-server round-trip.
-      entry.tracker?.endTurn();
+      entry.tracker?.endTurn(turnOutcome);
       // The turn was the only reason a detached bridge was being kept alive; now
       // that it's done, let the ordinary TTL run out rather than holding the
       // subprocess indefinitely for a client that never came back.

package/apps/studio/annotations-layer.tsx

@@ -1,3 +1,4 @@
+import { createAnnotationEchoGuard, observeAnnotationSnapshots } from './annotations-sync.ts';
 /**
  * @file       annotations-layer.tsx — FigJam-style annotation overlay
  * @scope      apps/studio/annotations-layer.tsx
@@ -76,6 +77,7 @@ import {
   type EllipseStroke,
   FILL_PALETTE,
   fmtEqual,
+  grownStickyBox,
   HALO_PAD_PX,
   HIGHLIGHTER_PALETTE,
   HIGHLIGHTER_WIDTHS,
@@ -169,7 +171,7 @@ import { buildAnnotationStrokesRecord } from './commands/annotation-strokes-comm
 import { ensureMenuStyles as ensureCtxMenuStyles } from './context-menu.tsx';
 import { crossedDragThreshold, type Tool } from './input-router.tsx';
 import { createMediaCommitChain, type MediaCommitResult } from './media-commit-chain.ts';
-import { mountCaret, placeCaretAt } from './text-caret.ts';
+import { collapseEntrySelectAll, mountCaret, placeCaretAt } from './text-caret.ts';
 import {
   AnnotationResizeOverlay,
   bboxResize,
@@ -414,7 +416,7 @@ function resolveAssetHref(href: string): string {
  * recognize — keeping the `<image>` element, dropping only the attribute —
  * so the server's STORED + broadcast SVG silently diverges from whatever the
  * client just sent. That divergence defeats the collab-echo self-suppression
- * guard (the `recentSelfSvgsRef` history, near `putStrokes` below): the
+ * guard (the `annotationEchoRef` operation history, near `putStrokes` below): the
  * echo's content no longer matches anything we recorded as "already
  * applied", so a real `setStrokesState` fires from the (href-stripped)
  * server copy — which can wipe out a SIBLING stroke's still-in-flight
@@ -467,6 +469,17 @@ export function reconcileCommit(
  * ones that are still purely local, not-yet-synced optimistic previews (an
  * ephemeral blob:/data: href image mid-upload) that a foreign broadcast could
  * never have known about in the first place.
+ *
+ * issue-106 deliberately does NOT carve out the stroke a local editor has open.
+ * That was tried: hold back its `text` so a peer's commit could not overwrite
+ * the editor. But this function's output IS the persisted store — it is
+ * serialized to `*.annotations.svg` and re-broadcast on the next commit of ANY
+ * stroke — so holding a field back doesn't shield a view, it silently reverts
+ * the peer's write and republishes the stale text under the local user's name,
+ * for as long as the editor stays open. The editor never needed it: the clobber
+ * was React rewriting an UNCONTROLLED contentEditable, which `useSessionValue`
+ * fixes at the DOM, and the commit reads `innerText` off the node rather than
+ * off the stroke. Last-write-wins stays the model here.
  */
 export function reconcileForeignEcho(
   prev: readonly Stroke[],
@@ -1101,7 +1114,7 @@ export function AnnotationsLayer() {
   // the resurrection to every collab peer). Tracked explicitly here instead
   // of inferred: `deleteStrokes` records every id it removes; the swap
   // checks (and consumes) this before assuming absence means lag. Bounded
-  // like `recentSelfSvgsRef` below — only ever holds ids a delete has
+  // like the annotation echo history below — only ever holds ids a delete has
   // touched, which is small in practice, but capped for safety.
   const DELETED_STROKE_IDS_CAP = 128;
   const deletedStrokeIdsRef = useRef<Set<string>>(new Set());
@@ -1140,29 +1153,10 @@ export function AnnotationsLayer() {
     if (!ghostCapable || !visible) setGhost(null);
   }, [ghostCapable, visible]);
 
-  // Load existing annotations on mount.
-  // Self-echo suppression (Phase 8 Task 5, hardened — feature-bulk-media-
-  // insert follow-up). A single "last applied" string only catches the MOST
-  // RECENT self-write: when the chain fires several rapid commits (a batch
-  // drop), the server's broadcast of an EARLIER commit can arrive after a
-  // LATER local commit has already moved "last applied" on — so the earlier
-  // echo no longer matches, gets misread as a foreign change, and rolls
-  // local state BACK to that stale snapshot. This is the confirmed cause of
-  // images silently vanishing after a multi-file drop (live-tested: 12
-  // mismatched/misapplied echoes correlated exactly with lost strokes across
-  // a 30-batch stress run). Track a bounded HISTORY of our own recent writes
-  // instead of just the latest one, so an out-of-order echo of any recent
-  // self-write is still recognized and suppressed.
-  const RECENT_SELF_SVG_CAP = 64;
-  const recentSelfSvgsRef = useRef<Set<string>>(new Set());
-  const rememberSelfSvg = useCallback((svg: string) => {
-    const set = recentSelfSvgsRef.current;
-    set.add(svg);
-    if (set.size > RECENT_SELF_SVG_CAP) {
-      const oldest = set.values().next().value;
-      if (oldest !== undefined) set.delete(oldest);
-    }
-  }, []);
+  // Match specific authored operations, including delayed earlier PUTs. A
+  // peer undo/delete can legitimately return to any previously rendered SVG.
+  const annotationEchoRef = useRef(createAnnotationEchoGuard());
+  const annotationsChangedRef = useRef(false);
   useEffect(() => {
     const file = deriveFile();
     fileRef.current = file;
@@ -1173,11 +1167,10 @@ export function AnnotationsLayer() {
     })
       .then((r) => (r.ok ? r.text() : ''))
       .then((text) => {
-        if (cancelled) return;
+        if (cancelled || annotationsChangedRef.current) return;
         const loaded = svgToStrokes(text);
         if (loaded.length) {
           setStrokesState(loaded);
-          rememberSelfSvg(text);
         }
       })
       .catch(() => {
@@ -1186,37 +1179,18 @@ export function AnnotationsLayer() {
     return () => {
       cancelled = true;
     };
-  }, [rememberSelfSvg]);
-
-  // Phase 8 Task 5 — observe the Y.Map.annotations for live updates from
-  // other tabs. Bail when the incoming SVG STRING matches any RECENT
-  // self-write (covers the local echo round-trip, including an
-  // out-of-order one, without missing real foreign changes). The prior
-  // length+first/last-id check was wrong: a resize / move keeps the same id
-  // list, so all three predicates matched even though geometry changed —
-  // foreign edits silently disappeared.
+  }, []);
+
   const collab = useCollab();
   useEffect(() => {
     if (!collab) return;
-    const map = collab.doc.getMap<string>('annotations');
-    const apply = () => {
-      const svg = map.get('svg');
-      if (typeof svg !== 'string' || !svg) return;
-      if (recentSelfSvgsRef.current.has(svg)) return;
-      rememberSelfSvg(svg);
+    return observeAnnotationSnapshots(collab.doc, (svg, writeId) => {
+      annotationsChangedRef.current = true;
+      if (annotationEchoRef.current.isOwn(svg, writeId)) return;
       const incoming = svgToStrokes(svg);
       setStrokesState((prev) => reconcileForeignEcho(prev, incoming));
-    };
-    apply();
-    map.observe(apply);
-    return () => {
-      try {
-        map.unobserve(apply);
-      } catch {
-        /* doc destroyed before unmount */
-      }
-    };
-  }, [collab, rememberSelfSvg]);
+    });
+  }, [collab]);
 
   const undoStack = useUndoStackOptional();
   const undoSinks = useUndoSinks();
@@ -1252,50 +1226,55 @@ export function AnnotationsLayer() {
    * we push a command, so the server only sees one PUT per edit instead
    * of two-step racing.
    */
-  const putStrokes = useCallback(
-    (next: readonly Stroke[], before: readonly Stroke[]) => {
-      // See reconcileCommit — a direct setStrokesState(next) here can
-      // clobber a sibling file's concurrent optimistic insert; folding
-      // blindly against `prev` (no baseline) can just as easily revert this
-      // very mutation's own delete. `before` (this command's own baseline)
-      // disambiguates the two.
-      setStrokesState((prev) => reconcileCommit(prev, before, next));
-      const file = fileRef.current;
-      if (!file) return Promise.resolve();
-      const persistable = next.some(isEphemeralHref)
-        ? next.filter((s) => !isEphemeralHref(s))
-        : next;
-      const svg = strokesToSvg(persistable);
-      // Phase 8 Task 5 — record the SVG we just authored locally so the
-      // server-broadcast echo (PUT → onAnnotationsChanged → syncRoom* →
-      // Y.Map.observe) doesn't trigger a redundant setStrokesState.
-      rememberSelfSvg(svg);
-      const dispatch = () =>
-        fetch('/_api/annotations', {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ file, svg }),
+  const putStrokes = useCallback((next: readonly Stroke[], before: readonly Stroke[]) => {
+    // See reconcileCommit — a direct setStrokesState(next) here can
+    // clobber a sibling file's concurrent optimistic insert; folding
+    // blindly against `prev` (no baseline) can just as easily revert this
+    // very mutation's own delete. `before` (this command's own baseline)
+    // disambiguates the two.
+    annotationsChangedRef.current = true;
+    setStrokesState((prev) => reconcileCommit(prev, before, next));
+    const file = fileRef.current;
+    if (!file) return Promise.resolve();
+    const persistable = next.some(isEphemeralHref) ? next.filter((s) => !isEphemeralHref(s)) : next;
+    const svg = strokesToSvg(persistable);
+    // What this edit was derived from — the project merges a peer's
+    // concurrent strokes from it instead of replacing them (DDR-241).
+    const persistableBefore = before.some(isEphemeralHref)
+      ? before.filter((s) => !isEphemeralHref(s))
+      : before;
+    const base = strokesToSvg(persistableBefore);
+    // Phase 8 Task 5 — record the SVG we just authored locally so the
+    // server-broadcast echo (PUT → onAnnotationsChanged → syncRoom* →
+    // Y.Map.observe) doesn't trigger a redundant setStrokesState.
+    const writeId = crypto.randomUUID();
+    annotationEchoRef.current.remember(writeId, svg);
+    const dispatch = () =>
+      fetch('/_api/annotations', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ file, svg, writeId, base }),
+      })
+        .then((r) => {
+          // A refused save (403 read-only, 405 at a proxy door) previously
+          // dissolved here without a trace — the user kept drawing on state
+          // that never reached disk, a peer, or a reload (the cloud
+          // canvas-writes RCA). Optimistic local state is still the right
+          // UX; a persistence failure being INVISIBLE is not.
+          if (!r.ok) {
+            annotationEchoRef.current.forget(writeId);
+            console.warn(`[annotations] save refused (${r.status}) — strokes are local-only`);
+          }
+          return undefined;
         })
-          .then((r) => {
-            // A refused save (403 read-only, 405 at a proxy door) previously
-            // dissolved here without a trace — the user kept drawing on state
-            // that never reached disk, a peer, or a reload (the cloud
-            // canvas-writes RCA). Optimistic local state is still the right
-            // UX; a persistence failure being INVISIBLE is not.
-            if (!r.ok) {
-              console.warn(`[annotations] save refused (${r.status}) — strokes are local-only`);
-            }
-            return undefined;
-          })
-          .catch(() => {
-            /* swallow — user sees uncommitted state until the next stroke */
-          });
-      const chained = putChainRef.current.then(dispatch, dispatch);
-      putChainRef.current = chained;
-      return chained;
-    },
-    [rememberSelfSvg]
-  );
+        .catch(() => {
+          annotationEchoRef.current.forget(writeId);
+          /* Pending persistence UX is handled by the project outbox work. */
+        });
+    const chained = putChainRef.current.then(dispatch, dispatch);
+    putChainRef.current = chained;
+    return chained;
+  }, []);
 
   // Register the strokes put sink with the undo provider so the rebuilt
   // AnnotationStrokesCommand (after a canvas switch + return) routes through
@@ -1745,14 +1724,14 @@ export function AnnotationsLayer() {
             // chain-driven setStrokesState queued in the same batch.
             setStrokesState((prev) => prev.filter((s) => s.id !== id));
             deletedStrokeIdsRef.current.delete(id); // never reached the chain — nothing to consume there
-            showCanvasToast(`Image upload failed — ${res.error}`);
+            showCanvasToast(`Image upload failed — ${res.error}`, 'error');
           }
           URL.revokeObjectURL(blobUrl);
         });
       };
       probe.onerror = () => {
         URL.revokeObjectURL(blobUrl);
-        showCanvasToast('Could not read that image file');
+        showCanvasToast('Could not read that image file', 'error');
       };
       probe.src = blobUrl;
     },
@@ -1797,7 +1776,7 @@ export function AnnotationsLayer() {
       const h = mediaKind === 'video' ? MEDIAREF_VIDEO_H : MEDIAREF_DEFAULT_H;
       void uploadAsset(file).then((res) => {
         if (!('path' in res)) {
-          showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`);
+          showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`, 'error');
           return;
         }
         const id = rid();
@@ -2884,13 +2863,24 @@ export function AnnotationsLayer() {
   // Phase 21 — sticky body edit. Sticky text is freeform (newlines preserved,
   // no trim) and the card persists even when blank, so this only updates text.
   const commitStickyText = useCallback(
-    (id: string, text: string, fmt?: EditorFmt) => {
+    (id: string, text: string, fmt?: EditorFmt, measuredH?: number) => {
       const prev = strokesRef.current;
       const existing = prev.find((s) => s.id === id && s.tool === 'sticky') as
         | StickyStroke
         | undefined;
-      if (!existing || (existing.text === text && fmtEqual(existing, fmt))) return;
-      const next = prev.map((s) => (s.id === id ? { ...existing, text, ...normFmt(fmt) } : s));
+      if (!existing) return;
+      // issue-106 — grow the card to whatever the editor actually rendered, so
+      // the lines the user just typed survive the return to the clipped read
+      // view. Null when the text already fits (the common case).
+      // The growth rides along with a real edit — it is NOT itself a reason to
+      // write. Otherwise opening a peer's already-overflowing note and clicking
+      // away, having typed nothing, would produce an undo entry, a
+      // full-document PUT and a sync broadcast.
+      if (existing.text === text && fmtEqual(existing, fmt)) return;
+      const grown = measuredH == null ? null : grownStickyBox(existing, measuredH);
+      const next = prev.map((s) =>
+        s.id === id ? { ...existing, text, ...normFmt(fmt), ...(grown ?? {}) } : s
+      );
       commitStrokes(prev, next, 'edit sticky');
     },
     [commitStrokes]
@@ -2970,14 +2960,14 @@ export function AnnotationsLayer() {
   editingTargetRef.current = editingTarget;
 
   const commitEditing = useCallback(
-    (text: string, fmt?: EditorFmt) => {
+    (text: string, fmt?: EditorFmt, measuredH?: number) => {
       const target = editingTargetRef.current;
       setEditingId(null);
       setPendingText(null);
       setEditCaretPoint(null);
       if (!target) return;
       if (target.kind === 'anchored') commitText(target.anchorId, text, fmt);
-      else if (target.kind === 'sticky') commitStickyText(target.sticky.id, text, fmt);
+      else if (target.kind === 'sticky') commitStickyText(target.sticky.id, text, fmt, measuredH);
       else if (target.kind === 'standalone') commitStandaloneText(target.text.id, text, fmt);
       else if (target.kind === 'section') {
         const label = text.trim().replace(/\s*\n+\s*/g, ' ') || 'Section';
@@ -3902,7 +3892,7 @@ function AnnotationsSvg({
   editCaretPoint: { x: number; y: number } | null;
   /** Live default ink (theme-aware) for a not-yet-born pending text caret. */
   inkColor: string;
-  onCommitEdit: (text: string, fmt?: EditorFmt) => void;
+  onCommitEdit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancelEdit: () => void;
 }) {
   const [, force] = useState({});
@@ -4118,7 +4108,7 @@ function AnnotEditors({
   anchoredExisting: TextStroke | undefined;
   caretPoint: { x: number; y: number } | null;
   inkColor: string;
-  onCommitEdit: (text: string, fmt?: EditorFmt) => void;
+  onCommitEdit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancelEdit: () => void;
 }) {
   const target = worldRef?.current ?? null;
@@ -4346,6 +4336,33 @@ function useEditorCaret(
   return { onPointerDown, onPointerUp };
 }
 
+/**
+ * issue-106 — the body an annotation editor hands React as its contentEditable
+ * children, snapshotted for the life of ONE edit session.
+ *
+ * These editors are uncontrolled: the user types straight into the DOM. If the
+ * rendered children value changes while the session is open, React writes the
+ * new string into the live node and everything typed since — line breaks
+ * included — is gone. That is exactly what a peer's commit arriving over
+ * shared-doc sync (DDR-064) used to do, and what the hazard note above
+ * `useEditorFormat` warns about for local mutations. Snapshotting per target id
+ * makes the children a constant for the session, so no store update can reach
+ * the DOM; the commit path reads `innerText` from the node itself, which is the
+ * user's real content either way. Re-keys when the editor is reused for a
+ * different stroke.
+ *
+ * `listType` is snapshotted through the same hook: the body is prefixed with
+ * list markers at OPEN time and stripped again at commit, so if a peer flipped
+ * the stroke's list style mid-session the strip would run a different rule than
+ * the prefix did — turning a bullet into a literal "• " in the stored text, or
+ * eating a leading "1. " the user actually typed.
+ */
+function useSessionValue<T>(id: string, compute: () => T): T {
+  const ref = useRef<{ id: string; value: T } | null>(null);
+  if (ref.current === null || ref.current.id !== id) ref.current = { id, value: compute() };
+  return ref.current.value;
+}
+
 function TextEditor({
   anchorId,
   host,
@@ -4364,9 +4381,10 @@ function TextEditor({
   const ref = useRef<HTMLDivElement | null>(null);
   // Show list markers WHILE editing so the read↔edit swap doesn't flicker
   // (item 4c) — stripped back to raw text on commit.
-  const initial = listPrefixedBody(existing?.text ?? '', existing?.listType);
-  const initialRef = useRef(initial);
-  initialRef.current = initial;
+  const sessionListType = useSessionValue(anchorId, () => existing?.listType);
+  const initial = useSessionValue(anchorId, () =>
+    listPrefixedBody(existing?.text ?? '', sessionListType)
+  );
   // Cmd/Ctrl+B/I/U formatting while editing (item 4d).
   const {
     fmtRef,
@@ -4385,8 +4403,8 @@ function TextEditor({
   // effect below can depend on it directly instead of its own copy of
   // existing?.listType (lint/correctness/useExhaustiveDependencies).
   const toCommittedText = useCallback(
-    (raw: string) => stripEditorMarkers(stripJumpSentinel(raw), existing?.listType),
-    [existing?.listType]
+    (raw: string) => stripEditorMarkers(stripJumpSentinel(raw), sessionListType),
+    [sessionListType]
   );
 
   // Caret-at-click on entry + custom blinking caret + click re-placement
@@ -4471,6 +4489,14 @@ function TextEditor({
             onCancel();
             return;
           }
+          // issue-106 — Shift+Enter ADDS a line. On keyboard entry the whole
+          // body is still select-all'd (the retype convention), so letting the
+          // break replace the selection wiped the text. Collapse that entry
+          // selection to its end first; a user's own partial selection is left
+          // alone. See collapseEntrySelectAll.
+          if (e.key === 'Enter' && e.shiftKey && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified across every text surface: plain Enter commits,
           // Shift+Enter inserts a newline (falls through untouched). ⌘/Ctrl
           // +Enter also commits AND chains a connected sibling (quick-create).
@@ -4504,7 +4530,7 @@ function StickyEditor({
 }: {
   sticky: StickyStroke;
   caretPoint?: { x: number; y: number } | null;
-  onCommit: (text: string, fmt?: EditorFmt) => void;
+  onCommit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancel: () => void;
 }) {
   // A flex-centered contentEditable (NOT a textarea) so the edit view matches
@@ -4513,6 +4539,8 @@ function StickyEditor({
   // Esc cancels; blur commits; Cmd/Ctrl+B/I/U format (unified with the others).
   const ref = useRef<HTMLDivElement | null>(null);
   const doneRef = useRef(false);
+  const sessionListType = useSessionValue(sticky.id, () => sticky.listType);
+  const sessionBody = useSessionValue(sticky.id, () => stickyBodyText(sticky));
   const {
     fmtRef,
     style: fmtStyle,
@@ -4528,7 +4556,16 @@ function StickyEditor({
   const commit = () => {
     if (doneRef.current) return;
     doneRef.current = true;
-    onCommit(stripEditorMarkers(ref.current?.innerText ?? '', sticky.listType), fmtRef.current);
+    const el = ref.current;
+    // issue-106 — the editor IS the measurement: same class, same width, same
+    // font as the committed body, and laid out in world units (the pan/zoom
+    // transform on `.dc-world` doesn't change layout), so its scrollHeight is
+    // the height the card needs. No offscreen measuring rig required.
+    onCommit(
+      stripEditorMarkers(el?.innerText ?? '', sessionListType),
+      fmtRef.current,
+      el?.scrollHeight
+    );
   };
   // FigJam v3 — a toolbar click steals focus for a tick; don't treat it as
   // "done editing" (the button's onMouseDown preventDefault usually stops the
@@ -4544,10 +4581,33 @@ function StickyEditor({
   const y = Math.min(sticky.y, sticky.y + sticky.h);
   const w = Math.abs(sticky.w);
   const h = Math.abs(sticky.h);
+  const r = sticky.cornerRadius ?? STICKY_CORNER_RADIUS;
   return (
     <div
       data-annot-editor="1"
-      style={{ position: 'absolute', left: x, top: y, width: w, height: h, zIndex: 5 }}
+      style={{
+        position: 'absolute',
+        left: x,
+        top: y,
+        width: w,
+        // issue-106 — NOT a fixed `height: h`. The card clips at `overflow:
+        // hidden`, so on a sticky that is already full the line Shift+Enter
+        // inserts landed outside the box: the keystroke worked, nothing moved
+        // on screen, and it read as "shift+enter does nothing". While the
+        // editor is open it grows downward instead, painting its own paper so
+        // the overflow still reads as the note (the SVG card behind is still
+        // the old size until the commit below persists the grown height).
+        minHeight: h,
+        zIndex: 5,
+        // `backgroundColor`, never the `background` shorthand: `color` comes
+        // verbatim from a synced stroke's `fill` (peer-controlled, and the
+        // sanitizer does not touch `fill`), and the shorthand would accept a
+        // `url(...)` — an outbound request from the studio origin the moment a
+        // note is opened. `background-color` cannot take one.
+        backgroundColor: sticky.color,
+        // Mirrors stickyCornerPath: TL/TR/BL rounded, BR sharp.
+        borderRadius: `${r}px ${r}px 0 ${r}px`,
+      }}
     >
       <div
         ref={ref}
@@ -4561,6 +4621,11 @@ function StickyEditor({
           outline: 'none',
           cursor: 'text',
           ...CARET_FIX_STYLE,
+          // Beats `.dc-sticky-body { height: 100%; overflow: hidden }` for the
+          // duration of the edit — see the wrapper note above.
+          height: 'auto',
+          minHeight: h,
+          overflow: 'visible',
         }}
         onBlur={onBlur}
         onPointerDown={caretHandlers.onPointerDown}
@@ -4573,6 +4638,11 @@ function StickyEditor({
             onCancel();
             return;
           }
+          // issue-106 — see the same guard in TextEditor: Shift+Enter must add
+          // a line, never consume the entry select-all and delete the body.
+          if (e.key === 'Enter' && e.shiftKey && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified: plain Enter commits, Shift+Enter inserts a newline.
           // ⌘/Ctrl+Enter also commits AND chains the next sticky beside it.
           if (e.key === 'Enter' && !e.shiftKey) {
@@ -4588,7 +4658,7 @@ function StickyEditor({
       >
         {/* Show the list markers while editing (item 4c) so the read↔edit swap
             doesn't flicker; stripped back to raw text on commit. */}
-        {stickyBodyText(sticky)}
+        {sessionBody}
       </div>
     </div>
   );
@@ -4736,6 +4806,11 @@ function StandaloneTextEditor({
             onCancel();
             return;
           }
+          // issue-106 — same guard as the other two editors, for the multi-line
+          // case only (a singleLine field commits on Shift+Enter anyway).
+          if (e.key === 'Enter' && e.shiftKey && !singleLine && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified: plain Enter commits, Shift+Enter inserts a newline. A
           // singleLine field (section rename) is a title — Shift+Enter commits
           // too rather than adding a newline the one-line chip can't show.