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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.100",
+  "version": "0.1.0-alpha.101",
   "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.101",
+    "@cueloop/extension-api": "0.1.0-alpha.101",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.101",
+    "@cueloop/schema": "0.1.0-alpha.101",
     "@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" }}>

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

@@ -290,6 +290,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   };
   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 +437,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);
@@ -903,6 +905,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       tokens={tokens}
       onSave={saveComment}
       agentEnabled={Boolean(onInvoke)}
+      focusRequest={composerFocusRequest}
       onReady={(readText) => {
         readComposerText.current = readText;
         composerReady.current = true;
@@ -996,6 +999,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 +1008,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 +1155,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?.();

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,
@@ -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}
@@ -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/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

@@ -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/components/AgentThreadPane.test.tsx

@@ -1,7 +1,12 @@
 import { expect, test } from "bun:test";
 import React from "react";
 import { testRender } from "@opentui/react/test-utils";
-import { SCHEMA_VERSION, type Thread, type ThreadAgentState } from "@cueloop/schema";
+import {
+  SCHEMA_VERSION,
+  type Thread,
+  type ThreadAgentState,
+  type AgentPromptRequest,
+} from "@cueloop/schema";
 import { AgentThreadPane, AgentThreadPrototype } from "./AgentThreadPane";
 import { ThreadFooter } from "./ThreadFooter";
 import { ThreadView } from "../../markdown/components/ThreadView";
@@ -16,6 +21,7 @@ import {
   waitForState,
 } from "../../testing/test-support";
 import type { ThreadAgentClient } from "../use-thread-agent";
+import type { EventFrame } from "@cueloop/daemon/client";
 
 const thread: Thread = {
   schemaVersion: SCHEMA_VERSION,
@@ -39,8 +45,14 @@ const empty: ThreadAgentState = {
 
 function createTestAgentClient(initial: ThreadAgentState) {
   let state = initial;
-  const prompts: { id: string; text: string; retry?: string }[] = [];
+  const prompts: AgentPromptRequest[] = [];
+  const listeners = new Set<(event: EventFrame) => void>();
   const client: ThreadAgentClient = {
+    onEvent: (listener) => {
+      listeners.add(listener);
+
+      return () => listeners.delete(listener);
+    },
     agentGet: async () => state,
     agentPrompt: async (params) => {
       prompts.push(params);
@@ -66,7 +78,12 @@ function createTestAgentClient(initial: ThreadAgentState) {
     agentPermission: async () => ({ ...state, phase: { kind: "idle" } }),
   };
 
-  return { client, prompts };
+  const publishTestAgentState = (next: ThreadAgentState): void => {
+    state = next;
+    for (const listener of listeners) listener({ event: "agent.updated", sessionId: thread.id });
+  };
+
+  return { client, prompts, publishTestAgentState };
 }
 
 function artifactView(
@@ -132,6 +149,7 @@ test("typing on the final blank line invokes the agent while the existing footer
     setup.mockInput.pressKey("RETURN", { ctrl: true });
     await waitForText(setup, "The timer survives cancellation.");
     expect(prompts[0]?.text).toBe("Explain retries");
+    expect(prompts[0]?.inputOnly).toBe(true);
     const send = locateText(setup, "Send message (0)");
 
     await setup.mockMouse.click(send.column, send.row);
@@ -827,3 +845,91 @@ test("a failed mutation flush restores the prompt alongside a newer visible draf
     setup.renderer.destroy();
   }
 });
+
+test("an offline shared agent accepts continuation below its status without model controls", async () => {
+  const state: ThreadAgentState = {
+    ...empty,
+    messages: [
+      { id: "online-answer", role: "agent", text: "An online answer", complete: true, revision: 1 },
+    ],
+  };
+  const { client, prompts, publishTestAgentState } = createTestAgentClient(state);
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={thread}
+      client={client}
+      focused
+      theme={DARK}
+      onActiveChange={noop}
+      onOpenFile={noop}
+    >
+      {artifactView(thread)}
+    </AgentThreadPane>,
+    { width: 80, height: 15, kittyKeyboard: true },
+  );
+
+  try {
+    await waitForText(setup, "An online answer");
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor !== null,
+      "online continuation editor",
+    );
+    publishTestAgentState({ ...state, phase: { kind: "offline" } });
+    await waitForText(setup, "Owner offline");
+    expect(setup.captureCharFrame()).toContain("Original artifact");
+    expect(setup.captureCharFrame()).not.toContain("Thinking");
+    const status = locateText(setup, "Owner offline");
+
+    await setup.mockMouse.click(status.column + 5, status.row + 3);
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor !== null,
+      "offline continuation editor",
+    );
+    await typeText(setup, "Queue until the owner reconnects");
+    await waitForText(setup, "Queue until the owner reconnects");
+    await pressKey(setup, "RETURN", { ctrl: true });
+    expect(prompts[0]?.text).toBe("Queue until the owner reconnects");
+    expect(prompts[0]?.inputOnly).toBe(true);
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
+test("shared viewers see pending activity without owner permission controls", async () => {
+  const { client } = createTestAgentClient({
+    ...empty,
+    phase: {
+      kind: "permission",
+      permission: {
+        id: "owner-permission",
+        title: "Owner approval required",
+        options: [{ optionId: "allow", name: "Allow once", kind: "allow_once" }],
+      },
+    },
+  });
+
+  client.canControlAgent = false;
+  const setup = await testRender(
+    <AgentThreadPane
+      thread={thread}
+      client={client}
+      focused
+      theme={DARK}
+      onActiveChange={noop}
+      onOpenFile={noop}
+    >
+      {artifactView(thread)}
+    </AgentThreadPane>,
+    { width: 80, height: 15 },
+  );
+
+  try {
+    await waitForText(setup, "Thinking");
+    expect(setup.captureCharFrame()).not.toContain("Allow once");
+    expect(setup.captureCharFrame()).not.toContain("Owner approval required");
+  } finally {
+    setup.renderer.destroy();
+  }
+});

package/src/thread/components/AgentThreadPane.tsx

@@ -86,18 +86,20 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
   const notifyState = useEffectEvent(() => props.onStateChange?.(state));
   const notifyControls = useEffectEvent(() =>
     props.onControlsChange?.(
-      <AgentConfigControls
-        state={state}
-        theme={theme}
-        onConfigure={(configId, value) =>
-          void agent.act((client) => {
-            if (!client.agentConfigure)
-              return Promise.reject(new Error("Agent configuration is unavailable"));
-
-            return client.agentConfigure({ id: thread.id, configId, value });
-          })
-        }
-      />,
+      props.client && !props.client.agentConfigure ? null : (
+        <AgentConfigControls
+          state={state}
+          theme={theme}
+          onConfigure={(configId, value) =>
+            void agent.act((client) => {
+              if (!client.agentConfigure)
+                return Promise.reject(new Error("Agent configuration is unavailable"));
+
+              return client.agentConfigure({ id: thread.id, configId, value });
+            })
+          }
+        />
+      ),
     ),
   );
 
@@ -135,7 +137,12 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
           }
           await props.flushMutations?.();
           const accepted = await agent.act((client) =>
-            client.agentPrompt({ id: thread.id, text: input.text }),
+            client.agentPrompt({
+              id: thread.id,
+              text: input.text,
+              inputOnly: Boolean(input.text.trim()),
+              operationId: newAnnotationId(),
+            }),
           );
 
           if (!accepted) rejected.push(input.text);
@@ -194,7 +201,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     );
 
     if (!submission) return undefined;
-    if (submission.status === "failed")
+    if (submission.status === "failed" && props.client?.canControlAgent !== false)
       return {
         label: "Retry",
         run: () =>
@@ -317,8 +324,11 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
       renderBlock={(index) =>
         index === projection.activityIndex ? (
           <box style={{ flexDirection: "column", paddingLeft: 2 }}>
+            {state.phase.kind === "offline" ? (
+              <text fg={theme.textMuted}>Owner offline</text>
+            ) : null}
             {busy ? <text fg={pulse ? theme.textDim : theme.textMuted}>Thinking…</text> : null}
-            {state.phase.kind === "permission" ? (
+            {state.phase.kind === "permission" && props.client?.canControlAgent !== false ? (
               <>
                 <text fg={theme.text}>{state.phase.permission.title}</text>
                 <box style={{ flexDirection: "row", gap: 2 }}>

package/src/thread/thread-controller.ts

@@ -39,6 +39,7 @@ import {
   type Artifact,
   type DiffFileContents,
   type ShareLink,
+  type SharePolicy,
   type Thread,
   type SessionHistory,
   type MessageOutcome,
@@ -241,6 +242,7 @@ export interface NewShareLink {
   name?: string;
   requireAuth: boolean;
   allowlist: string[];
+  agentEnabled?: boolean;
 }
 
 export interface ReviewControllerOptions {
@@ -1697,15 +1699,16 @@ class Controller implements ReviewController {
     this.setStatus("sharing…");
     this.freezeForShare(session)
       .then((shared) => {
-        return this.shareTransport.publish(
-          shared,
-          {},
-          {
-            requireAuth: input.requireAuth,
-            allowlist: input.allowlist,
-            shareBranch,
-          },
-        );
+        const policy: ShareLink = {
+          id: session.id,
+          requireAuth: input.requireAuth,
+          allowlist: input.allowlist,
+          shareBranch,
+        };
+
+        if (input.agentEnabled !== undefined) policy.agentEnabled = input.agentEnabled;
+
+        return this.shareTransport.publish(shared, {}, policy);
       })
       .then(async ({ line, copied }) => {
         const id = this.shareTransport.parseShareId(line);
@@ -1719,6 +1722,7 @@ class Controller implements ReviewController {
           shareBranch,
         };
 
+        if (input.agentEnabled !== undefined) link.agentEnabled = input.agentEnabled;
         await client.sessionSetShares(session.id, [...this.linksFor(this.snapshot.session), link]);
         this.setStatus("");
         this.showToast(line, copied ? "link copied" : "link created");
@@ -1738,20 +1742,24 @@ class Controller implements ReviewController {
     if (!links.some((link) => link.id === id)) return;
     const allowlist = input.requireAuth ? input.allowlist : [];
 
+    const policy: SharePolicy = { requireAuth: input.requireAuth, allowlist };
+
+    if (input.agentEnabled !== undefined) policy.agentEnabled = input.agentEnabled;
     // Publish the same policy stored on the local link.
-    void this.shareTransport
-      .push(id, [], { requireAuth: input.requireAuth, allowlist })
-      .catch(() => {});
-    const next = links.map((link) =>
-      link.id === id
-        ? {
-            ...link,
-            name: input.name?.trim() || undefined,
-            requireAuth: input.requireAuth,
-            allowlist,
-          }
-        : link,
-    );
+    void this.shareTransport.push(id, [], policy).catch(() => {});
+    const next = links.map((link) => {
+      if (link.id !== id) return link;
+      const updated = {
+        ...link,
+        name: input.name?.trim() || undefined,
+        requireAuth: input.requireAuth,
+        allowlist,
+      };
+
+      if (input.agentEnabled !== undefined) updated.agentEnabled = input.agentEnabled;
+
+      return updated;
+    });
 
     this.applyOptimistic(
       { ...session, shares: next },

package/src/thread/use-thread-agent.ts

@@ -8,7 +8,7 @@ export type ThreadAgentClient = Pick<
   DaemonClient,
   "agentGet" | "agentPrompt" | "agentCancel" | "agentComment" | "agentPermission"
 > &
-  Partial<Pick<DaemonClient, "agentConfigure">>;
+  Partial<Pick<DaemonClient, "agentConfigure" | "onEvent">> & { canControlAgent?: boolean };
 
 /** Subscribe to durable agent state; unmount closes only this client connection. */
 export function useThreadAgent(id: string, home?: string, injected?: ThreadAgentClient) {
@@ -48,6 +48,12 @@ export function useThreadAgent(id: string, home?: string, injected?: ThreadAgent
     void (async () => {
       try {
         if (injected) {
+          unsubscribe = injected.onEvent?.((event) => {
+            if (event.event === "agent.updated" && event.sessionId === id)
+              void refresh(injected).catch((error) => {
+                if (!cancelled) setError(String(error));
+              });
+          });
           await refresh(injected);
           await configure(injected);