@happyvertical/smrt-chat 0.51.14 → 0.51.16

package/dist/manifest.json

@@ -2,7 +2,7 @@
   "version": "1.0.0",
   "timestamp": 0,
   "packageName": "@happyvertical/smrt-chat",
-  "packageVersion": "0.51.14",
+  "packageVersion": "0.51.16",
   "objects": {
     "@happyvertical/smrt-chat:AgentSessionCollection": {
       "name": "agentsessioncollection",

package/dist/smrt-knowledge.json

@@ -3,12 +3,12 @@
   "sensitiveFieldsExcluded": true,
   "generatedAt": "1970-01-01T00:00:00.000Z",
   "packageName": "@happyvertical/smrt-chat",
-  "packageVersion": "0.51.14",
+  "packageVersion": "0.51.16",
   "sourceManifestPath": "dist/manifest.json",
   "agentDocPath": "AGENTS.md",
   "sourceHashes": {
-    "manifest": "224ce698fafb422e17fde5f86cd31c3f42456dca06c545ad4b1c6c900800e214",
-    "packageJson": "d9de1f7b46e75775af3124ff6f427cfe00b8118cc84100f4a532c370f7866536",
+    "manifest": "238cce53d1747fd54174b55f699556ac2cfc85cc759387dbb12dc5642e4114f5",
+    "packageJson": "e3feff654d5abf25692fbc53edc42108d21f4b02a297d1150576ff74cdc57487",
     "agents": "60e1f7c7079515ceee9741763b2b31d191c8234c0603245ebc6c7270213a979a",
     "moduleDoc:agents/dev-workbench.md": "69b6f827d25c8aeb0e7516c90303af23948803213b5d34bc334c1e3376c83a16",
     "agentSurface:src/routes/chat-dev.intents.ts": "ff8f7c19c7eb6e841a08f03c97773c53092ed208004666bfed372bd1ad456b35"

package/dist/svelte/components/assistant/AssistantComposer.svelte

@@ -34,16 +34,19 @@ export interface Props {
   disabled?: boolean;
   /** Placeholder text for the empty textarea. */
   placeholder?: string;
+  /** The draft text (#2991). Bindable: a host can seed it with a prompt for
+   * the user to edit, and read back what they typed. Setting it never sends.
+   * Cleared after `onsend` resolves. */
+  value?: string;
 }
 
-const {
+let {
   onsend,
   onupload,
   disabled = false,
   placeholder = 'Ask the assistant…',
+  value: content = $bindable(''),
 }: Props = $props();
-
-let content = $state('');
 let stagedAttachments = $state<AssistantAttachmentRef[]>([]);
 let uploading = $state(false);
 let sending = $state(false);
@@ -61,6 +64,23 @@ let fileInputEl: HTMLInputElement | undefined;
 // Captured from the textarea's input event so auto-resize works without
 // binding to the Textarea primitive's inner DOM node.
 let textareaEl: HTMLTextAreaElement | undefined;
+// The Textarea primitive's own instance, for its public `getElement()`.
+let textareaComponent:
+  | { getElement(): HTMLTextAreaElement | null }
+  | undefined = $state();
+
+function resize(el: HTMLTextAreaElement) {
+  el.style.height = 'auto';
+  el.style.height = `${Math.min(el.scrollHeight, 120)}px`;
+}
+
+// #2991: a seeded draft never fires the textarea's input event, so size the
+// textarea to it here. Typed input still resizes through handleInput.
+$effect(() => {
+  void content;
+  textareaEl ??= textareaComponent?.getElement() ?? undefined;
+  if (textareaEl) resize(textareaEl);
+});
 
 async function handleFileChange(event: Event) {
   const input = event.currentTarget as HTMLInputElement;
@@ -114,7 +134,9 @@ async function handleSend() {
   // user's message forever on a transport failure, with no visible error.
   try {
     await onsend(trimmed, stagedAttachments);
-    content = '';
+    // #2991: text typed while the send was in flight is newer than what was
+    // sent; keep it.
+    if (content.trim() === trimmed) content = '';
     stagedAttachments = [];
     if (textareaEl) {
       textareaEl.style.height = 'auto';
@@ -142,8 +164,7 @@ function handleKeydown(event: KeyboardEvent) {
 function handleInput(event: Event) {
   const el = event.currentTarget as HTMLTextAreaElement;
   textareaEl = el;
-  el.style.height = 'auto';
-  el.style.height = `${Math.min(el.scrollHeight, 120)}px`;
+  resize(el);
 }
 
 function removeAttachment(id: string) {
@@ -219,6 +240,7 @@ function removeAttachment(id: string) {
       aria-label={t(M['chat.assistant_composer.attach_files'])}
     />
     <Textarea
+      bind:this={textareaComponent}
       bind:value={content}
       class="assistant-composer-textarea"
       {placeholder}

package/dist/svelte/components/assistant/AssistantComposer.svelte.d.ts

@@ -13,8 +13,12 @@ export interface Props {
     disabled?: boolean;
     /** Placeholder text for the empty textarea. */
     placeholder?: string;
+    /** The draft text (#2991). Bindable: a host can seed it with a prompt for
+     * the user to edit, and read back what they typed. Setting it never sends.
+     * Cleared after `onsend` resolves. */
+    value?: string;
 }
-declare const AssistantComposer: import("svelte").Component<Props, {}, "">;
+declare const AssistantComposer: import("svelte").Component<Props, {}, "value">;
 type AssistantComposer = ReturnType<typeof AssistantComposer>;
 export default AssistantComposer;
 //# sourceMappingURL=AssistantComposer.svelte.d.ts.map

package/dist/svelte/components/assistant/AssistantComposer.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantComposer.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/assistant/AssistantComposer.svelte.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvE,MAAM,WAAW,KAAK;IACpB;;;;4DAIwD;IACxD,MAAM,EAAE,CACN,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,sBAAsB,EAAE,KAClC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B;sEACkE;IAClE,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACjE,yDAAyD;IACzD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA6KD,QAAA,MAAM,iBAAiB,2CAAwC,CAAC;AAChE,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"AssistantComposer.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/assistant/AssistantComposer.svelte.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvE,MAAM,WAAW,KAAK;IACpB;;;;4DAIwD;IACxD,MAAM,EAAE,CACN,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,sBAAsB,EAAE,KAClC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B;sEACkE;IAClE,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACjE,yDAAyD;IACzD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;0CAEsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA8LD,QAAA,MAAM,iBAAiB,gDAAwC,CAAC;AAChE,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,eAAe,iBAAiB,CAAC"}

package/dist/svelte/components/assistant/AssistantDock.svelte

@@ -32,6 +32,7 @@ import type {
 import { safeAttachmentHref } from './attachment-href.js';
 import {
   type AssistantActionClient,
+  type AssistantActionOutcome,
   type AssistantDockController,
   createAssistantDockController,
 } from './create-assistant-dock-controller.svelte.js';
@@ -101,6 +102,21 @@ export interface Props {
     request: DataSurfaceActionRequest,
     result: DataSurfaceActionResult,
   ) => void;
+  /** Called each time a proposed action reaches an outcome (#2991): applied,
+   * rejected (by the server or the user), or unknown. See
+   * `AssistantDockControllerOptions.onActionSettled`. */
+  onactionsettled?: (
+    request: DataSurfaceActionRequest,
+    outcome: AssistantActionOutcome,
+  ) => void;
+  /** Initial composer draft (#2991), for example a prompt computed for the
+   * item being edited. Read once, on mount; the user edits and sends it.
+   * It is never sent on their behalf. To replace it later, call
+   * `controller.setDraft(text)` from `oncontroller`. */
+  initialDraft?: string;
+  /** Placeholder for the composer's empty textarea (#2991). Defaults to the
+   * composer's own placeholder. */
+  composerPlaceholder?: string;
 }
 
 const {
@@ -112,6 +128,9 @@ const {
   toolCall,
   oncontroller,
   onactionapplied,
+  onactionsettled,
+  initialDraft,
+  composerPlaceholder,
 }: Props = $props();
 const { t } = useI18n();
 
@@ -135,6 +154,9 @@ const controller: AssistantDockController = createAssistantDockController({
   },
   visible: () => visible,
   onActionApplied: (request, result) => onactionapplied?.(request, result),
+  onActionSettled: (request, outcome) => onactionsettled?.(request, outcome),
+  // Read once, on mount, like the controller itself.
+  initialDraft: untrack(() => initialDraft),
 });
 
 // F1 (#2904 review): the whole body runs under `untrack` so the effect takes
@@ -495,9 +517,13 @@ async function handleConfirmAction(requestId: string) {
           </div>
         {/if}
         <AssistantComposer
+          bind:value={
+            () => controller.draft, (text) => controller.setDraft(text)
+          }
           onsend={handleSend}
           onupload={handleUpload}
           disabled={!controller.activeThreadId}
+          placeholder={composerPlaceholder}
         />
       </div>
     </div>

package/dist/svelte/components/assistant/AssistantDock.svelte.d.ts

@@ -1,7 +1,7 @@
 import type { DataSurfaceActionRequest, DataSurfaceActionResult, DataSurfaceIdentity, DataSurfaceRegistry } from '@happyvertical/smrt-ui/data-surface';
 import { type Snippet } from 'svelte';
 import type { AssistantMessage, AssistantTransport } from './assistant-transport.js';
-import { type AssistantActionClient, type AssistantDockController } from './create-assistant-dock-controller.svelte.js';
+import { type AssistantActionClient, type AssistantActionOutcome, type AssistantDockController } from './create-assistant-dock-controller.svelte.js';
 export interface Props {
     /** Thread/message I/O backend; see `./assistant-transport.js`. */
     transport: AssistantTransport;
@@ -38,6 +38,18 @@ export interface Props {
     /** Called after the server accepts an apply (#2989). See
      * `AssistantDockControllerOptions.onActionApplied`. */
     onactionapplied?: (request: DataSurfaceActionRequest, result: DataSurfaceActionResult) => void;
+    /** Called each time a proposed action reaches an outcome (#2991): applied,
+     * rejected (by the server or the user), or unknown. See
+     * `AssistantDockControllerOptions.onActionSettled`. */
+    onactionsettled?: (request: DataSurfaceActionRequest, outcome: AssistantActionOutcome) => void;
+    /** Initial composer draft (#2991), for example a prompt computed for the
+     * item being edited. Read once, on mount; the user edits and sends it.
+     * It is never sent on their behalf. To replace it later, call
+     * `controller.setDraft(text)` from `oncontroller`. */
+    initialDraft?: string;
+    /** Placeholder for the composer's empty textarea (#2991). Defaults to the
+     * composer's own placeholder. */
+    composerPlaceholder?: string;
 }
 declare const AssistantDock: import("svelte").Component<Props, {}, "">;
 type AssistantDock = ReturnType<typeof AssistantDock>;

package/dist/svelte/components/assistant/AssistantDock.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantDock.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/assistant/AssistantDock.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,QAAQ,CAAC;AAOrD,OAAO,KAAK,EAEV,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAE7B,MAAM,8CAA8C,CAAC;AAGtD,MAAM,WAAW,KAAK;IACpB,kEAAkE;IAClE,SAAS,EAAE,kBAAkB,CAAC;IAC9B;;qBAEiB;IACjB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B;qEACiE;IACjE,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC;;;;;;;;gEAQ4D;IAC5D,QAAQ,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACjC,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;0EAIsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACvC;;;yEAGqE;IACrE,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAC7D;2DACuD;IACvD,eAAe,CAAC,EAAE,CAChB,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,uBAAuB,KAC5B,IAAI,CAAC;CACX;AAkYD,QAAA,MAAM,aAAa,2CAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}
+{"version":3,"file":"AssistantDock.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/assistant/AssistantDock.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,QAAQ,CAAC;AAOrD,OAAO,KAAK,EAEV,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAE7B,MAAM,8CAA8C,CAAC;AAGtD,MAAM,WAAW,KAAK;IACpB,kEAAkE;IAClE,SAAS,EAAE,kBAAkB,CAAC;IAC9B;;qBAEiB;IACjB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B;qEACiE;IACjE,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC;;;;;;;;gEAQ4D;IAC5D,QAAQ,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACjC,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;0EAIsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACvC;;;yEAGqE;IACrE,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAC7D;2DACuD;IACvD,eAAe,CAAC,EAAE,CAChB,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,uBAAuB,KAC5B,IAAI,CAAC;IACV;;2DAEuD;IACvD,eAAe,CAAC,EAAE,CAChB,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,sBAAsB,KAC5B,IAAI,CAAC;IACV;;;0DAGsD;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;qCACiC;IACjC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAwYD,QAAA,MAAM,aAAa,2CAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

package/dist/svelte/components/assistant/__tests__/assistant-dock-draft-settled.test.js

@@ -0,0 +1,448 @@
+// @vitest-environment jsdom
+/**
+ * #2991: a host can seed the composer draft (`initialDraft`,
+ * `controller.setDraft`) without sending it, and pass a composer
+ * `placeholder` through the dock. Also the `onActionSettled` /
+ * `onactionsettled` outcome callback for applied, rejected, and unknown
+ * action outcomes.
+ */
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
+import { render, screen, userEvent } from '@happyvertical/smrt-vitest/svelte';
+import { flushSync } from 'svelte';
+import { describe, expect, it, vi } from 'vitest';
+import AssistantComposer from '../AssistantComposer.svelte';
+import AssistantDock from '../AssistantDock.svelte';
+import { createInMemoryAssistantTransport } from '../assistant-transport.js';
+import { createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
+const identity = {
+    surfaceId: 'assets',
+    kind: 'table',
+    subject: { type: 'tenant', id: 'tenant-a' },
+};
+function registryWithSurface() {
+    const registry = createDataSurfaceRegistry();
+    const descriptor = {
+        version: 1,
+        identity,
+        schemaVersion: 1,
+        label: 'Assets',
+        rowKey: 'id',
+        columns: [
+            { id: 'id', label: 'ID', capabilities: ['read'], role: 'row-key' },
+        ],
+        query: {
+            modes: ['rows'],
+            projectableColumnIds: ['id'],
+            searchableColumnIds: [],
+            filterableColumnIds: [],
+            sortableColumnIds: [],
+        },
+        actions: [],
+        controls: [],
+        limits: { maxQueryRows: 10, maxQueryBytes: 10_000, maxSelectionSize: 10 },
+    };
+    registry.register({
+        descriptor,
+        getSnapshot: () => ({ revision: 1, state: {} }),
+    });
+    return registry;
+}
+function proposal(requestId = 'req-1') {
+    return {
+        version: 1,
+        requestId,
+        identity,
+        actionId: 'approve',
+        phase: 'preview',
+        selection: { scope: 'explicit-ids', rowIds: ['row-1'] },
+    };
+}
+function result(request, phase, ok, extra = {}) {
+    return {
+        version: 1,
+        requestId: request.requestId,
+        identity: request.identity,
+        actionId: request.actionId,
+        phase,
+        ok,
+        ...extra,
+    };
+}
+function client(apply) {
+    return {
+        preview: async (request) => result(request, 'preview', true, { confirmationToken: 'tok' }),
+        apply,
+    };
+}
+function textarea() {
+    return screen.getByLabelText('Message');
+}
+describe('AssistantComposer value (#2991)', () => {
+    it('renders a seeded value without sending it', () => {
+        const onsend = vi.fn();
+        render(AssistantComposer, {
+            props: { onsend, onupload: vi.fn(), value: 'Remove the background' },
+        });
+        expect(textarea()).toHaveValue('Remove the background');
+        expect(onsend).not.toHaveBeenCalled();
+    });
+    it('sends the edited seed only when the user sends', async () => {
+        const onsend = vi.fn().mockResolvedValue(undefined);
+        render(AssistantComposer, {
+            props: { onsend, onupload: vi.fn(), value: 'Remove the background' },
+        });
+        await userEvent.type(textarea(), ' please');
+        expect(onsend).not.toHaveBeenCalled();
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        expect(onsend).toHaveBeenCalledWith('Remove the background please', []);
+        expect(textarea()).toHaveValue('');
+    });
+});
+describe('AssistantComposer in-flight edits (#2991)', () => {
+    it('keeps text typed while the send was in flight', async () => {
+        let release;
+        const onsend = vi.fn(() => new Promise((resolve) => {
+            release = resolve;
+        }));
+        render(AssistantComposer, {
+            props: { onsend, onupload: vi.fn(), value: 'first' },
+        });
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        await userEvent.type(textarea(), ' and more');
+        release();
+        await vi.waitFor(() => expect(onsend).toHaveBeenCalledTimes(1));
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(textarea()).toHaveValue('first and more');
+    });
+});
+describe('controller draft (#2991)', () => {
+    it('starts from initialDraft and setDraft replaces it without sending', async () => {
+        const transport = createInMemoryAssistantTransport();
+        const sendMessage = vi.spyOn(transport, 'sendMessage');
+        const controller = createAssistantDockController({
+            transport,
+            registry: registryWithSurface(),
+            initialDraft: 'first',
+        });
+        expect(controller.draft).toBe('first');
+        controller.setDraft('second');
+        expect(controller.draft).toBe('second');
+        expect(sendMessage).not.toHaveBeenCalled();
+        controller.dispose();
+    });
+    it('keeps the draft across a registry or transport swap', () => {
+        let registry = registryWithSurface();
+        let transport = createInMemoryAssistantTransport();
+        const controller = createAssistantDockController({
+            get transport() {
+                return transport;
+            },
+            get registry() {
+                return registry;
+            },
+            initialDraft: 'unsent text',
+        });
+        registry = registryWithSurface();
+        controller.syncRegistry();
+        expect(controller.draft).toBe('unsent text');
+        transport = createInMemoryAssistantTransport();
+        controller.syncTransport();
+        expect(controller.draft).toBe('unsent text');
+        controller.dispose();
+    });
+    it('clears the draft after a headless send of that draft', async () => {
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+        });
+        const thread = await controller.createThread('t');
+        await controller.openThread(thread.id);
+        controller.setDraft('hello');
+        await controller.send('hello');
+        expect(controller.draft).toBe('');
+        controller.dispose();
+    });
+    it('keeps a draft changed while the send was in flight', async () => {
+        const transport = createInMemoryAssistantTransport();
+        const controller = createAssistantDockController({
+            transport,
+            registry: registryWithSurface(),
+        });
+        const thread = await controller.createThread('t');
+        await controller.openThread(thread.id);
+        controller.setDraft('hello');
+        const sending = controller.send('hello');
+        controller.setDraft('next message');
+        await sending;
+        expect(controller.draft).toBe('next message');
+        controller.dispose();
+    });
+    it('does not clear a kept draft when a send completes after a swap', async () => {
+        let transport = createInMemoryAssistantTransport();
+        const controller = createAssistantDockController({
+            get transport() {
+                return transport;
+            },
+            registry: registryWithSurface(),
+        });
+        const thread = await controller.createThread('t');
+        await controller.openThread(thread.id);
+        controller.setDraft('hello');
+        const sending = controller.send('hello');
+        transport = createInMemoryAssistantTransport();
+        controller.syncTransport();
+        await sending.catch(() => undefined);
+        expect(controller.draft).toBe('hello');
+        controller.dispose();
+    });
+    it('defaults to an empty draft', () => {
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+        });
+        expect(controller.draft).toBe('');
+        controller.dispose();
+    });
+});
+describe('AssistantDock draft seeding and placeholder (#2991)', () => {
+    it('renders initialDraft in the composer and never sends it', async () => {
+        const transport = createInMemoryAssistantTransport();
+        const sendMessage = vi.spyOn(transport, 'sendMessage');
+        render(AssistantDock, {
+            props: {
+                transport,
+                registry: registryWithSurface(),
+                initialDraft: 'Remove the background from this photo',
+            },
+        });
+        expect(textarea()).toHaveValue('Remove the background from this photo');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        expect(sendMessage).not.toHaveBeenCalled();
+    });
+    it('lets the host seed the draft through controller.setDraft', async () => {
+        let hostController;
+        const transport = createInMemoryAssistantTransport();
+        const sendMessage = vi.spyOn(transport, 'sendMessage');
+        render(AssistantDock, {
+            props: {
+                transport,
+                registry: registryWithSurface(),
+                oncontroller: (c) => {
+                    hostController = c;
+                },
+            },
+        });
+        expect(textarea()).toHaveValue('');
+        hostController?.setDraft('Describe the edit');
+        flushSync();
+        expect(textarea()).toHaveValue('Describe the edit');
+        expect(sendMessage).not.toHaveBeenCalled();
+    });
+    it('reflects typed text back into controller.draft', async () => {
+        let hostController;
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+                initialDraft: 'seed',
+                oncontroller: (c) => {
+                    hostController = c;
+                },
+            },
+        });
+        // The composer is disabled until a thread is open; open one first.
+        const thread = await hostController?.createThread('t');
+        if (thread)
+            await hostController?.openThread(thread.id);
+        flushSync();
+        await userEvent.type(textarea(), ' more');
+        expect(hostController?.draft).toBe('seed more');
+    });
+    it('forwards composerPlaceholder to the composer', () => {
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+                composerPlaceholder: 'Describe the image edit to generate…',
+            },
+        });
+        expect(textarea()).toHaveAttribute('placeholder', 'Describe the image edit to generate…');
+    });
+    it('keeps the composer default placeholder when none is passed', () => {
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+            },
+        });
+        expect(textarea()).toHaveAttribute('placeholder', 'Ask the assistant…');
+    });
+});
+describe('controller onActionSettled', () => {
+    function settledController(apply, onActionSettled) {
+        return createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: client(apply),
+            onActionSettled,
+        });
+    }
+    it('reports an accepted apply as applied with the server result', async () => {
+        const onActionSettled = vi.fn();
+        const controller = settledController(async (request) => result(request, 'apply', true, { details: { assetId: 'srv-1' } }), onActionSettled);
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        expect(onActionSettled).toHaveBeenCalledTimes(1);
+        const [request, outcome] = onActionSettled.mock.calls[0];
+        expect(request.phase).toBe('apply');
+        expect(outcome.status).toBe('applied');
+        expect(outcome.result.details).toEqual({ assetId: 'srv-1' });
+        controller.dispose();
+    });
+    it('reports a server refusal as rejected by the server', async () => {
+        const onActionSettled = vi.fn();
+        const controller = settledController(async (request) => result(request, 'apply', false, { reason: 'stale_revision' }), onActionSettled);
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        expect(onActionSettled).toHaveBeenCalledTimes(1);
+        const outcome = onActionSettled.mock.calls[0][1];
+        expect(outcome).toMatchObject({ status: 'rejected', by: 'server' });
+        expect(outcome.result.reason).toBe('stale_revision');
+        controller.dispose();
+    });
+    it('reports a user reject as rejected by the user', async () => {
+        const onActionSettled = vi.fn();
+        const controller = settledController(async (request) => result(request, 'apply', true), onActionSettled);
+        await controller.previewAction(proposal());
+        controller.rejectAction('req-1');
+        expect(controller.actions.has('req-1')).toBe(false);
+        expect(onActionSettled).toHaveBeenCalledTimes(1);
+        const [request, outcome] = onActionSettled.mock.calls[0];
+        expect(request.requestId).toBe('req-1');
+        expect(outcome).toEqual({ status: 'rejected', by: 'user' });
+        controller.dispose();
+    });
+    it('reports a thrown apply as unknown, then the later decision', async () => {
+        const onActionSettled = vi.fn();
+        let mode = 'throw';
+        const controller = settledController(async (request) => {
+            if (mode === 'throw')
+                throw new Error('network down');
+            return result(request, 'apply', true);
+        }, onActionSettled);
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        expect(onActionSettled).toHaveBeenCalledTimes(1);
+        expect(onActionSettled.mock.calls[0][1]).toEqual({
+            status: 'unknown',
+            error: 'network down',
+        });
+        mode = 'ok';
+        await controller.applyAction('req-1');
+        expect(onActionSettled).toHaveBeenCalledTimes(2);
+        expect(onActionSettled.mock.calls[1][1].status).toBe('applied');
+        controller.dispose();
+    });
+    it('reports an unknown-outcome reason as unknown with the result', async () => {
+        const onActionSettled = vi.fn();
+        const controller = settledController(async (request) => result(request, 'apply', false, { reason: 'idempotency_in_progress' }), onActionSettled);
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        const outcome = onActionSettled.mock.calls[0][1];
+        expect(outcome.status).toBe('unknown');
+        expect(outcome.result.reason).toBe('idempotency_in_progress');
+        controller.dispose();
+    });
+    it('does not report a refused reject while the outcome is unknown', async () => {
+        const onActionSettled = vi.fn();
+        const controller = settledController(async () => {
+            throw new Error('timeout');
+        }, onActionSettled);
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        onActionSettled.mockClear();
+        controller.rejectAction('req-1');
+        expect(controller.actions.has('req-1')).toBe(true);
+        expect(onActionSettled).not.toHaveBeenCalled();
+        controller.dispose();
+    });
+    it('does not report an apply that lands after a context swap', async () => {
+        const onActionSettled = vi.fn();
+        let release;
+        let registry = registryWithSurface();
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            get registry() {
+                return registry;
+            },
+            actionClient: client(async (request) => {
+                await new Promise((resolve) => {
+                    release = resolve;
+                });
+                return result(request, 'apply', true);
+            }),
+            onActionSettled,
+        });
+        await controller.previewAction(proposal());
+        const applying = controller.applyAction('req-1');
+        registry = registryWithSurface();
+        controller.syncRegistry();
+        release();
+        await applying;
+        expect(onActionSettled).not.toHaveBeenCalled();
+        controller.dispose();
+    });
+    it('keeps action state when the host callback throws', async () => {
+        const onActionSettled = vi.fn(() => {
+            throw new Error('host bug');
+        });
+        const controller = settledController(async (request) => result(request, 'apply', true), onActionSettled);
+        await controller.previewAction(proposal());
+        await expect(controller.applyAction('req-1')).resolves.toBeUndefined();
+        expect(controller.actions.get('req-1')?.status).toBe('applied');
+        await controller.previewAction(proposal('req-2'));
+        expect(() => controller.rejectAction('req-2')).not.toThrow();
+        expect(controller.actions.has('req-2')).toBe(false);
+        controller.dispose();
+    });
+    it('still calls onActionApplied alongside onActionSettled', async () => {
+        const onActionApplied = vi.fn();
+        const onActionSettled = vi.fn();
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: client(async (request) => result(request, 'apply', true)),
+            onActionApplied,
+            onActionSettled,
+        });
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-1');
+        expect(onActionApplied).toHaveBeenCalledTimes(1);
+        expect(onActionSettled).toHaveBeenCalledTimes(1);
+        controller.dispose();
+    });
+});
+describe('AssistantDock onactionsettled', () => {
+    it('reports a Reject click to the host', async () => {
+        let hostController;
+        const onactionsettled = vi.fn();
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+                actionClient: client(async (request) => result(request, 'apply', true)),
+                oncontroller: (c) => {
+                    hostController = c;
+                },
+                onactionsettled,
+            },
+        });
+        await hostController?.previewAction(proposal());
+        await userEvent.click(await screen.findByRole('button', { name: 'Reject' }));
+        await vi.waitFor(() => expect(onactionsettled).toHaveBeenCalledTimes(1));
+        expect(onactionsettled.mock.calls[0][1]).toEqual({
+            status: 'rejected',
+            by: 'user',
+        });
+    });
+});