@cueloop/client 0.1.0-alpha.100 → 0.1.0-alpha.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.100",
+  "version": "0.1.0-alpha.102",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -27,10 +27,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.100",
-    "@cueloop/extension-api": "0.1.0-alpha.100",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.100",
-    "@cueloop/schema": "0.1.0-alpha.100",
+    "@cueloop/daemon": "0.1.0-alpha.102",
+    "@cueloop/extension-api": "0.1.0-alpha.102",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.102",
+    "@cueloop/schema": "0.1.0-alpha.102",
     "@opentui/core": "^0.5.14",
     "@opentui/keymap": "0.5.14",
     "@opentui/react": "^0.5.14",

package/src/annotations/components/AnnotationCards.tsx

@@ -57,6 +57,7 @@ export function Composer({
   onInput,
   placeholder,
   agentEnabled = false,
+  focusRequest,
 }: {
   seed: string;
   glyph: string | null;
@@ -66,6 +67,7 @@ export function Composer({
   onInput: (text: string, caret: number) => void;
   placeholder?: string;
   agentEnabled?: boolean;
+  focusRequest?: number;
 }): React.ReactNode {
   const editorRef = useRef<TextareaRenderable | null>(null);
   const pastedImageCount = useRef(0);
@@ -105,6 +107,9 @@ export function Composer({
     onReady(() => editorRef.current?.plainText ?? "");
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
+  useLayoutEffect(() => {
+    editorRef.current?.focus();
+  }, [focusRequest]);
 
   return (
     <box style={{ flexDirection: "row" }}>
@@ -312,12 +317,14 @@ export function CommentRow({
   tokens,
   authorLabel,
   action,
+  onFocus,
 }: {
   annotation: Annotation;
   tokens: Theme;
   /** The author's resolved display name, shown as a tooltip when the dot is hovered. */
   authorLabel?: string;
   action?: { label: string; run: () => void };
+  onFocus?: () => void;
 }): React.ReactNode {
   // own comments (no author) wear the filled dot, collaborators the outline
   const own = annotation.author === undefined;
@@ -332,7 +339,14 @@ export function CommentRow({
     : {};
 
   return (
-    <box style={{ flexDirection: "column" }}>
+    <box
+      style={{ flexDirection: "column" }}
+      onMouseDown={(event) => {
+        if (!onFocus) return;
+        event.stopPropagation();
+        onFocus();
+      }}
+    >
       {annotation.body.split("\n").map((line, lineIndex) => (
         <box key={lineIndex} style={{ flexDirection: "row" }}>
           <box style={{ flexShrink: 0 }} {...(lineIndex === 0 ? dotHover : {})}>

package/src/annotations/use-annotation-surface.tsx

@@ -47,7 +47,7 @@ import {
   slashItemsFrom,
 } from "../keyboard/slash-palette";
 import { SlashSkillsContext } from "../keyboard/skills";
-import { discussionsFrom, type Discussion } from "./discussions";
+import { discussionsFrom, spanKey, type Discussion } from "./discussions";
 import {
   CommentRow,
   Composer,
@@ -107,13 +107,13 @@ export interface AnnotationSurfaceOptions {
   ) => boolean;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
   isAnnotationReadOnly?: (id: string) => boolean;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   requestedBlock?: { blockIndex: number };
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   isPromptBlock?: (blockIndex: number) => boolean;
   promptFocusRequest?: PromptFocusRequest;
   promptRestoreRequest?: PromptRestoreRequest;
@@ -277,19 +277,28 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   // app owns it (onFocusAnnotation), the focused discussion is the one holding
   // the focused card and focusing here names the root comment; standalone, it
   // is local state
-  const [localFocus, setLocalFocus] = useState<string | null>(null);
-  const focusedDiscussion =
-    onFocusAnnotation === undefined
-      ? localFocus
-      : (discussions.find((discussion) =>
-          discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
-        )?.key ?? null);
+  const [localFocus, setLocalFocus] = useState<{ key: string; annotationId?: string } | null>(null);
+  const getFocusedDiscussion = (): string | null => {
+    if (onFocusAnnotation === undefined) return localFocus?.key ?? null;
+
+    return (
+      discussions.find((discussion) =>
+        discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
+      )?.key ?? null
+    );
+  };
+  const focusedDiscussion = getFocusedDiscussion();
   const setFocusedDiscussion = (key: string | null): void => {
-    if (onFocusAnnotation === undefined) return setLocalFocus(key);
+    if (onFocusAnnotation === undefined) return setLocalFocus(key === null ? null : { key });
     onFocusAnnotation(discussions.find((discussion) => discussion.key === key)?.rootId);
   };
+  const focusSavedComment = (annotationId: string, key: string): void => {
+    if (onFocusAnnotation) onFocusAnnotation(annotationId);
+    else setLocalFocus({ key, annotationId });
+  };
   const [folded, setFolded] = useState<Set<string>>(new Set());
   const [composeText, setComposeText] = useState("");
+  const [composerFocusRequest, setComposerFocusRequest] = useState(0);
   const composeTextRef = useRef("");
   const setDraft = (text: string): void => {
     composeTextRef.current = text;
@@ -436,6 +445,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     readComposerText.current = null;
     composeRef.current = state;
     setCompose(state);
+    setComposerFocusRequest((request) => request + 1);
     setDraft(state.seed);
     setCaretOffset(state.seed.length);
     setSlashIndex(0);
@@ -471,7 +481,8 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     if (!target || body.trim().length === 0) return;
     if (target.editAnnotationId !== null) {
       onUpdateAnnotation(target.editAnnotationId, body);
-      if (invoke) onInvoke?.();
+      if (target.discussionKey) focusSavedComment(target.editAnnotationId, target.discussionKey);
+      if (invoke) onInvoke?.(target.editAnnotationId);
 
       return;
     }
@@ -479,8 +490,10 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       const discussion = discussions.find((candidate) => candidate.key === target.discussionKey);
 
       if (discussion) {
-        onReply(discussion.rootId, body);
-        if (invoke) onInvoke?.();
+        const commentId = onReply(discussion.rootId, body);
+
+        if (commentId) focusSavedComment(commentId, discussion.key);
+        if (invoke && commentId) onInvoke?.(commentId);
 
         return;
       }
@@ -488,10 +501,22 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const span = target.span ?? caretSpan();
 
     if (span) {
-      onAnnotate(span, body);
-      if (invoke) onInvoke?.();
+      const commentId = onAnnotate(span, body);
+
+      completeSavedComment(span, commentId, prompt, invoke);
     }
   };
+  const completeSavedComment = (
+    span: TextSpan,
+    commentId: string | void,
+    prompt: boolean,
+    invoke: boolean,
+  ): void => {
+    if (!prompt && commentId) {
+      focusSavedComment(commentId, spanKey(span));
+    }
+    if (invoke && (prompt || commentId)) onInvoke?.(commentId || undefined);
+  };
   /** A new discussion on the typing anchor; the card renders under the span's last block. */
   const openNewCompose = (seed: string): void => {
     const span = caretSpan();
@@ -852,6 +877,16 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     openNewCompose(sequence);
   };
 
+  const invokeFocusedComment = (): void => {
+    const discussion = discussions.find((candidate) => candidate.key === focusedDiscussion);
+    const focusedCommentId = focusedAnnotationId ?? localFocus?.annotationId;
+    const commentId =
+      discussion?.annotations.find((annotation) => annotation.id === focusedCommentId)?.id ??
+      discussion?.annotations.at(-1)?.id;
+
+    onInvoke?.(commentId);
+  };
+
   useSharedKeyboard((key) => {
     if (suspended) return;
     if (key.ctrl && key.name === "q") return onExit();
@@ -861,7 +896,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     if (isAgentInvokeKey(key, onInvoke)) {
       key.preventDefault();
 
-      return onInvoke?.();
+      return invokeFocusedComment();
     }
     if (key.name === "escape") {
       // from type mode esc only enters nav, so a held mark survives for `c`
@@ -903,6 +938,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       tokens={tokens}
       onSave={saveComment}
       agentEnabled={Boolean(onInvoke)}
+      focusRequest={composerFocusRequest}
       onReady={(readText) => {
         readComposerText.current = readText;
         composerReady.current = true;
@@ -948,6 +984,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
             tokens={tokens}
             authorLabel={resolveAuthorLabel?.(annotation)}
             action={annotationAction?.(annotation.id)}
+            onFocus={() => {
+              blurSaveCompose();
+              focusSavedComment(annotation.id, discussion.key);
+              setCursor(discussion.blockIndex);
+            }}
           />
         ),
       };
@@ -996,6 +1037,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     return ranges;
   };
 
+  const composeBlockIndex = compose?.kind === "prompt" ? source.count - 1 : compose?.blockIndex;
   const cardsAfterLine = (
     blockIndex: number,
     line: VisualLine,
@@ -1004,7 +1046,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const endsInLine = (end: number): boolean =>
       (end === 0 && line.start === 0) || (end - 1 >= line.start && end - 1 < line.end);
     const nodes: React.ReactNode[] = [];
-    const composeHere = compose && compose.blockIndex === blockIndex;
+    const composeHere = compose && composeBlockIndex === blockIndex;
     const newComposeHere = Boolean(composeHere && compose.discussionKey === null && composerNode);
     const composeAnchoredHere =
       newComposeHere && (compose!.span ? endsInLine(compose!.span.end.char) : isLastLine);
@@ -1151,7 +1193,8 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const geometry = allGeometry();
     const promptLine = geometry.find((entry) => isPromptBlock?.(entry.blockIndex));
     const lastReplyLine = geometry
-      .filter((entry) => entry.blockIndex === blockIndex - 1)
+      // Activity blocks render outside the text geometry, so use the last measured line.
+      .filter((entry) => entry.blockIndex < blockIndex)
       .sort((left, right) => right.y - left.y)[0];
     const promptStart = promptLine ? promptLine.y - 1 : lastReplyLine && lastReplyLine.y + 1;
     const viewport = dragViewport?.();
@@ -1226,7 +1269,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
 function isAgentInvokeKey(
   key: { name: string; ctrl?: boolean; meta?: boolean; super?: boolean },
-  onInvoke?: () => void,
+  onInvoke?: (commentId?: string) => void,
 ): boolean {
   return Boolean(
     onInvoke &&

package/src/app/App.thread-agent.test.ts

@@ -10,3 +10,11 @@ test("experimental agent UI requires a local owner and an enabled flag", () => {
   expect(canRunThreadAgent({ ...local, editing: true })).toBe(false);
   expect(canRunThreadAgent({ ...local, shared: true })).toBe(false);
 });
+
+test("a per-share agent capability enables collaborator chat without a gateway flag", () => {
+  const shared = { enabled: false, owner: false, editing: false, shared: true };
+
+  expect(canRunThreadAgent(shared)).toBe(false);
+  expect(canRunThreadAgent({ ...shared, sharedAgent: true })).toBe(true);
+  expect(canRunThreadAgent({ ...shared, sharedAgent: true, editing: true })).toBe(false);
+});

package/src/app/App.tsx

@@ -119,6 +119,7 @@ export interface AppProps {
   sessionId?: string;
   initialReview?: { session: Thread; diff: { patch: string; files: DiffFileContents[] } };
   initialClient?: ThreadClient;
+  agentClient?: import("../thread/use-thread-agent").ThreadAgentClient;
   cwd?: string;
   readOnly?: boolean;
   onExit?: (code: number) => void;
@@ -531,6 +532,7 @@ export function App({
   sessionId,
   initialReview,
   initialClient,
+  agentClient,
   cwd,
   readOnly = false,
   onExit,
@@ -840,7 +842,7 @@ export function App({
   const agentActions = useRef<(id: string) => { label: string; run: () => void } | undefined>(
     () => undefined,
   );
-  const agentInvoke = useRef<(() => void) | undefined>(undefined);
+  const agentInvoke = useRef<((commentId?: string) => void) | undefined>(undefined);
   const [agentState, setAgentState] = useState<import("@cueloop/schema").ThreadAgentState>();
   const [prototypeComposing, setPrototypeComposing] = useState(false);
   const [welcomeComposing, setWelcomeComposing] = useState(false);
@@ -1315,11 +1317,13 @@ export function App({
                   <box style={{ flexGrow: 1, flexDirection: "row" }}>
                     <AgentThreadPrototype
                       key={activeSession.id}
+                      client={agentClient}
                       enabled={canRunThreadAgent({
                         enabled: threadAgentEnabled,
                         owner: isOwner,
                         editing: bodyEditing.editing,
                         shared: isSharedThreadConnection(openClient, shareTransport),
+                        sharedAgent: sharedAgentAvailable(agentClient, activeSession),
                       })}
                       observer={observer}
                       pixelPrototype={isPixelPrototype}
@@ -1480,7 +1484,7 @@ export function App({
                         // a diff thread's Changes view is the artifact itself; any other thread's is the
                         // live working-tree diff, so its notes carry a file target and anchor there
                         onAnnotate: (span, body) =>
-                          void controller.annotate(
+                          controller.annotate(
                             "comment",
                             span.start.blockIndex,
                             span.start.char,
@@ -1492,11 +1496,11 @@ export function App({
                               : { kind: "file", path: "", rev: "worktree" },
                           ),
                         onReply: (rootAnnotationId, body) =>
-                          void controller.reply(rootAnnotationId, body),
+                          controller.reply(rootAnnotationId, body),
                         onUpdateAnnotation: (id, body) => controller.updateAnnotation(id, body),
                         onInvoke: agentActive
-                          ? () => {
-                              agentInvoke.current?.();
+                          ? (commentId) => {
+                              agentInvoke.current?.(commentId);
                               setFocusedPane("thread");
                             }
                           : undefined,
@@ -1592,6 +1596,12 @@ export function App({
                 threadName={shareThreadName(session)}
                 links={shareLinksFor(session)}
                 isOwner={isOwner}
+                agentAvailable={canRunThreadAgent({
+                  enabled: threadAgentEnabled,
+                  owner: isOwner,
+                  editing: false,
+                  shared: isSharedThreadConnection(openClient, shareTransport),
+                })}
                 onCreateLink={(input) => controller.createShareLink(input)}
                 onUpdateLink={(id, input) => controller.updateShareLink(id, input)}
                 onDeleteLink={(id) => controller.deleteShareLink(id)}
@@ -1618,8 +1628,15 @@ export function canRunThreadAgent(options: {
   owner: boolean;
   editing: boolean;
   shared: boolean;
+  sharedAgent?: boolean;
 }): boolean {
-  return options.enabled && options.owner && !options.editing && !options.shared;
+  if (options.editing) return false;
+
+  return Boolean(options.sharedAgent || (options.enabled && options.owner && !options.shared));
+}
+
+function sharedAgentAvailable(client: AppProps["agentClient"], thread: Thread): boolean {
+  return Boolean(client && thread.shares?.[0]?.agentEnabled);
 }
 
 function isSubmittedComment(

package/src/diff/components/AnnotatableFileView.tsx

@@ -31,9 +31,9 @@ export interface AnnotatableFileViewProps {
   onCursorChange?: (rowIndex: number) => void;
   onObserverBlocked?: (reason: "observer" | "resolved") => void;
   onAddComment: (anchor: Anchor, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   isAnnotationReadOnly?: (id: string) => boolean;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;

package/src/diff/components/DiffContentView.tsx

@@ -86,10 +86,10 @@ export interface DiffContentViewProps {
   onCursorChange?: (rowIndex: number) => void;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   isAnnotationReadOnly?: (id: string) => boolean;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;

package/src/integrations/components/ShareDialog.agent.test.tsx

@@ -0,0 +1,50 @@
+import { expect, test } from "bun:test";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DARK } from "../../appearance/theme";
+import { press, waitForText } from "../../testing/test-support";
+import { ShareDialog } from "./ShareDialog";
+import { newWizardDraft, shareDialogStore } from "./share-dialog-store";
+import type { NewShareLink } from "../../thread/thread-controller";
+
+for (const enabled of [false, true])
+  test(`share agent toggle is ${enabled ? "opt-in" : "hidden"}`, async () => {
+    const created: NewShareLink[] = [];
+
+    shareDialogStore.getState().reset();
+    shareDialogStore.getState().openWizard(newWizardDraft("Review"));
+    const setup = await testRender(
+      <ShareDialog
+        isOpen
+        isOwner
+        agentAvailable={enabled}
+        links={[]}
+        threadName="Review"
+        theme={DARK}
+        onCreateLink={(input) => created.push(input)}
+        onUpdateLink={() => {}}
+        onDeleteLink={() => {}}
+        onCopyLink={() => {}}
+        onClose={() => {}}
+      />,
+      { width: 100, height: 26 },
+    );
+
+    try {
+      await waitForText(setup, "link name");
+      expect(shareDialogStore.getState().wizard?.agentEnabled ?? false).toBe(false);
+      expect(setup.captureCharFrame().includes("Allow agent messages")).toBe(enabled);
+      await press(setup, "down");
+      await press(setup, "down");
+      if (enabled) {
+        await press(setup, " ");
+        await press(setup, "down");
+      }
+      await press(setup, "enter");
+      expect(created).toHaveLength(1);
+      expect(created[0]?.agentEnabled).toBe(enabled ? true : undefined);
+    } finally {
+      setup.renderer.destroy();
+      shareDialogStore.getState().reset();
+    }
+  });

package/src/integrations/components/ShareDialog.tsx

@@ -68,6 +68,7 @@ function draftForLink(link: ShareLink, threadName: string): ShareWizardDraft {
     editingId: link.id,
     name: link.name ?? threadName,
     requireAuth: link.requireAuth,
+    agentEnabled: link.agentEnabled,
     allowlist: link.allowlist,
   };
 }
@@ -259,7 +260,7 @@ function LinksList({
 }
 
 /** The focus ring positions inside the wizard, in vertical order. */
-type WizardFocus = "name" | "auth" | "allowlist" | "actions";
+type WizardFocus = "name" | "auth" | "allowlist" | "agent" | "actions";
 
 function Wizard({
   draft,
@@ -267,6 +268,8 @@ function Wizard({
   saveDisabled,
   onName,
   onToggleAuth,
+  agentAvailable,
+  onToggleAgent,
   onAllowlist,
   onSave,
   onCancel,
@@ -278,6 +281,8 @@ function Wizard({
   saveDisabled: boolean;
   onName: (name: string) => void;
   onToggleAuth: () => void;
+  agentAvailable: boolean;
+  onToggleAgent: () => void;
   onAllowlist: (logins: string[]) => void;
   onSave: () => void;
   onCancel: () => void;
@@ -329,6 +334,13 @@ function Wizard({
           />
         </box>
       ) : null}
+      {agentAvailable ? (
+        <box style={{ flexDirection: "row", alignItems: "center", marginTop: 1 }}>
+          <text fg={focus === "agent" ? tokens.accent : tokens.textDim}>Allow agent messages</text>
+          <box style={{ flexGrow: 1 }} />
+          <Switch on={draft.agentEnabled ?? false} onToggle={onToggleAgent} theme={theme} />
+        </box>
+      ) : null}
       <box style={{ flexGrow: 1 }} />
       <DialogActions
         confirmLabel={draft.editingId ? "save" : "create"}
@@ -346,6 +358,7 @@ export interface ShareDialogProps {
   threadName: string;
   links: ShareLink[];
   isOwner: boolean;
+  agentAvailable?: boolean;
   onCreateLink: (input: NewShareLink) => void;
   onUpdateLink: (id: string, input: NewShareLink) => void;
   onDeleteLink: (id: string) => void;
@@ -359,6 +372,7 @@ export function ShareDialog({
   threadName,
   links,
   isOwner,
+  agentAvailable = false,
   onCreateLink,
   onUpdateLink,
   onDeleteLink,
@@ -384,8 +398,13 @@ export function ShareDialog({
     shareDialogStore.getState().openWizard(draft);
   };
 
-  const wizardRing = (): WizardFocus[] =>
-    wizard?.requireAuth ? ["name", "auth", "allowlist", "actions"] : ["name", "auth", "actions"];
+  const wizardRing = (): WizardFocus[] => [
+    "name",
+    "auth",
+    ...(wizard?.requireAuth ? ["allowlist" as const] : []),
+    ...(agentAvailable ? ["agent" as const] : []),
+    "actions",
+  ];
 
   const moveWizardFocus = (delta: number): void => {
     const ring = wizardRing();
@@ -405,6 +424,7 @@ export function ShareDialog({
       allowlist: wizard.allowlist,
     };
 
+    if (agentAvailable) input.agentEnabled = wizard.agentEnabled ?? false;
     if (wizard.editingId) onUpdateLink(wizard.editingId, input);
     else onCreateLink(input);
     backToList();
@@ -436,6 +456,8 @@ export function ShareDialog({
     const activated = name === "return" || name === "enter";
 
     if (wizardFocus === "auth" && (activated || name === "space")) return toggleAuth();
+    if (wizardFocus === "agent" && (activated || name === "space"))
+      return shareDialogStore.getState().setAgentEnabled(!wizard.agentEnabled);
     if (wizardFocus === "actions" && activated) saveWizard();
   };
 
@@ -494,6 +516,8 @@ export function ShareDialog({
     >
       {wizard ? (
         <Wizard
+          agentAvailable={agentAvailable}
+          onToggleAgent={() => shareDialogStore.getState().setAgentEnabled(!wizard.agentEnabled)}
           draft={wizard}
           focus={wizardFocus}
           saveDisabled={saveDisabled}

package/src/integrations/components/share-dialog-store.ts

@@ -16,6 +16,7 @@ export interface ShareWizardDraft {
   name: string;
   requireAuth: boolean;
   allowlist: string[];
+  agentEnabled?: boolean;
 }
 
 export interface ShareDialogState {
@@ -27,6 +28,7 @@ export interface ShareDialogState {
   setName: (name: string) => void;
   setRequireAuth: (requireAuth: boolean) => void;
   setAllowlist: (allowlist: string[]) => void;
+  setAgentEnabled: (agentEnabled: boolean) => void;
   reset: () => void;
 }
 
@@ -46,6 +48,8 @@ export const shareDialogStore = createStore<ShareDialogState>((set) => ({
     set((state) => (state.wizard ? { wizard: { ...state.wizard, requireAuth } } : {})),
   setAllowlist: (allowlist) =>
     set((state) => (state.wizard ? { wizard: { ...state.wizard, allowlist } } : {})),
+  setAgentEnabled: (agentEnabled) =>
+    set((state) => (state.wizard ? { wizard: { ...state.wizard, agentEnabled } } : {})),
   reset: () => set({ category: "external", wizard: null }),
 }));
 

package/src/markdown/components/ThreadView.tsx

@@ -159,7 +159,7 @@ export interface ThreadViewProps {
   isAnnotationReadOnly?: (id: string) => boolean;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   requestedBlock?: { blockIndex: number };
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   isPromptBlock?: (blockIndex: number) => boolean;
   promptFocusRequest?: PromptFocusRequest;
   promptRestoreRequest?: PromptRestoreRequest;
@@ -177,8 +177,8 @@ export interface ThreadViewProps {
   onCursorChange?: (blockIndex: number) => void;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   onNavCommand?: (key: KeyEvent, selection: TextSpan | null) => boolean;
@@ -412,7 +412,7 @@ export function ThreadView({
       blockIndex === 0 || tight ? null : <box key="lead-gap" style={{ height: 1 }} />;
     const measuredBox = (children: React.ReactNode): React.ReactNode => (
       <box
-        key={`discussion-block-${blockIndex}`}
+        key={isPromptBlock?.(blockIndex) ? "prompt-block" : `discussion-block-${blockIndex}`}
         id={`discussion-block-${blockIndex}`}
         ref={virtual.measureRef(blockIndex)}
         style={{ flexDirection: "column" }}

package/src/thread/agent-transcript.ts

@@ -195,6 +195,8 @@ export function projectThreadConversation(
     display.push(...blocks);
     sources.push(...blocks.map(() => ({ kind: "mirror" as const, commentId })));
     annotations.push(annotation);
+    const mirrorAnnotations = [annotation];
+
     if (commentId) {
       const replies = [...thread.annotations, ...state.comments].filter(
         (entry) => entry.replyTo === commentId,
@@ -210,23 +212,22 @@ export function projectThreadConversation(
         };
 
         annotations.push(replica);
+        mirrorAnnotations.push(replica);
         mirrors.set(replica.id, { commentId: reply.id });
       }
     }
     const localMarks = quote.trim()
-      ? marksByDisplay([annotation], blocks)
+      ? marksByDisplay(mirrorAnnotations, blocks)
       : new Map<number, Mark[]>([
           [
             0,
-            [
-              {
-                start: 0,
-                end: 0,
-                role: "mark-comment",
-                annotationId: annotation.id,
-                span: { start: { blockIndex: 0, char: 0 }, end: { blockIndex: 0, char: 0 } },
-              },
-            ],
+            mirrorAnnotations.map((entry) => ({
+              start: 0,
+              end: 0,
+              role: "mark-comment",
+              annotationId: entry.id,
+              span: { start: { blockIndex: 0, char: 0 }, end: { blockIndex: 0, char: 0 } },
+            })),
           ],
         ]);