@stigmer/react 3.12.7 → 3.12.9

package/settings/MemorySection.js

@@ -16,6 +16,6 @@ import { useActiveOrgSlug } from "../organization/OrgProvider.js";
 export function MemorySection() {
     const headingId = useId();
     const org = useActiveOrgSlug();
-    return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, className: "stg:text-foreground stg:mb-1 stg:text-sm stg:font-semibold", children: "Memory" }), _jsx("p", { className: "stg:text-muted-foreground stg:mb-6 stg:text-xs", children: "Facts agents proposed to remember about you in this organization. Confirmed memories are shared with agents in your future sessions and appear in those executions' records. Only you can see them here, and you can edit or delete any of them at any time." }), !org ? (_jsx("p", { className: "stg:text-muted-foreground stg:py-4 stg:text-center stg:text-xs", children: "Select an organization to view its memories." })) : (_jsx(MemoryListPanel, { org: org }))] }));
+    return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, className: "stg:text-foreground stg:mb-1 stg:text-sm stg:font-semibold", children: "Memory" }), _jsx("p", { className: "stg:text-muted-foreground stg:mb-6 stg:text-xs", children: "Facts agents proposed to remember about you in this organization. Confirmed memories are shared with agents in your future sessions and appear in those executions' records; once you have many, each conversation recalls the most relevant ones, shown on the execution. Only you can see them here, and you can edit or delete any of them at any time." }), !org ? (_jsx("p", { className: "stg:text-muted-foreground stg:py-4 stg:text-center stg:text-xs", children: "Select an organization to view its memories." })) : (_jsx(MemoryListPanel, { org: org }))] }));
 }
 //# sourceMappingURL=MemorySection.js.map

package/settings/MemorySection.js.map

@@ -1 +1 @@
-{"version":3,"file":"MemorySection.js","sourceRoot":"","sources":["../../src/settings/MemorySection.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,SAAS,GAAG,KAAK,EAAE,CAAC;IAC1B,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAE/B,OAAO,CACL,sCAA0B,SAAS,aACjC,aACE,EAAE,EAAE,SAAS,EACb,SAAS,EAAC,4DAA4D,uBAGnE,EACL,YAAG,SAAS,EAAC,gDAAgD,6QAKzD,EAEH,CAAC,GAAG,CAAC,CAAC,CAAC,CACN,YAAG,SAAS,EAAC,gEAAgE,6DAEzE,CACL,CAAC,CAAC,CAAC,CACF,KAAC,eAAe,IAAC,GAAG,EAAE,GAAG,GAAI,CAC9B,IACO,CACX,CAAC;AACJ,CAAC"}
+{"version":3,"file":"MemorySection.js","sourceRoot":"","sources":["../../src/settings/MemorySection.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,SAAS,GAAG,KAAK,EAAE,CAAC;IAC1B,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAE/B,OAAO,CACL,sCAA0B,SAAS,aACjC,aACE,EAAE,EAAE,SAAS,EACb,SAAS,EAAC,4DAA4D,uBAGnE,EACL,YAAG,SAAS,EAAC,gDAAgD,2WAOzD,EAEH,CAAC,GAAG,CAAC,CAAC,CAAC,CACN,YAAG,SAAS,EAAC,gEAAgE,6DAEzE,CACL,CAAC,CAAC,CAAC,CACF,KAAC,eAAe,IAAC,GAAG,EAAE,GAAG,GAAI,CAC9B,IACO,CACX,CAAC;AACJ,CAAC"}

package/src/attachment/__tests__/prepare-image.test.ts

@@ -1,6 +1,10 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi, afterEach } from "vitest";
 import { prepareImageForVision } from "../prepare-image.js";
 
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
 /**
  * happy-dom half of the prepare-image coverage: the guard rails that make
  * the function safe to call from any environment. The actual pixel work
@@ -17,11 +21,13 @@ describe("prepareImageForVision — environment guard rails", () => {
   });
 
   it("returns an image untouched when the canvas pipeline is unavailable", async () => {
-    // happy-dom has no createImageBitmap — the exact situation of an old
-    // browser or a privacy extension that blocks canvas. The paste must
-    // still work end to end with the original bytes; it merely degrades
-    // at the runner with the standard disclosure.
-    expect(typeof createImageBitmap).toBe("undefined");
+    // The situation of an old browser or a privacy extension that blocks
+    // canvas. Stubbed explicitly rather than relying on the DOM shim
+    // lacking createImageBitmap — newer shims ship one, and this guard
+    // must hold regardless of the test environment's capabilities. The
+    // paste must still work end to end with the original bytes; it merely
+    // degrades at the runner with the standard disclosure.
+    vi.stubGlobal("createImageBitmap", undefined);
 
     const png = new File([new Uint8Array([0x89, 0x50, 0x4e, 0x47])], "shot.png", {
       type: "image/png",

package/src/composer/ComposerToolbar.tsx

@@ -1,6 +1,5 @@
 "use client";
 
-import { useId } from "react";
 import { cn } from "@stigmer/theme";
 import {
   Tooltip,
@@ -8,7 +7,6 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "../internal/tooltip.js";
-import { Switch } from "../switch/Switch.js";
 import { ContextPopover } from "./ContextPopover.js";
 import { ConfigureMenu, type ConfigureMenuItem } from "./ConfigureMenu.js";
 import { ModelSelector } from "../models/ModelSelector.js";
@@ -25,18 +23,6 @@ import {
 } from "./icons.js";
 import { SpinnerIcon } from "../internal/SpinnerIcon.js";
 
-/**
- * Wiring for the always-available "auto-approve tool calls" toggle
- * (stigmer/stigmer#816). Presence renders the control; omission keeps the
- * toolbar byte-identical for consumers that don't wire it (DD-011).
- */
-export interface ComposerAutoApproveProps {
-  /** Whether auto-approve is currently armed for this conversation. */
-  readonly armed: boolean;
-  /** Called with the next value when the user flips the toggle. */
-  readonly onChange: (armed: boolean) => void;
-}
-
 export interface ComposerToolbarProps {
   readonly disabled: boolean;
   readonly isSubmitting: boolean;
@@ -61,14 +47,6 @@ export interface ComposerToolbarProps {
   readonly interactionMode?: InteractionModeOption;
   readonly onInteractionModeChange: (mode: InteractionModeOption) => void;
 
-  /**
-   * Always-available auto-approve toggle (#816). Deliberately NOT bound to
-   * {@link disabled}: the walk-away user flips it exactly while a turn
-   * streams, so it stays interactive under the composer lock — the same
-   * exemption the Stop button carries.
-   */
-  readonly autoApprove?: ComposerAutoApproveProps;
-
   readonly showModelSelector: boolean;
   readonly modelId?: string;
   readonly onModelChange: (id: string) => void;
@@ -150,7 +128,6 @@ export function ComposerToolbar({
   showInteractionModePicker,
   interactionMode,
   onInteractionModeChange,
-  autoApprove,
   showModelSelector,
   modelId,
   onModelChange,
@@ -160,7 +137,6 @@ export function ComposerToolbar({
   onThinkingModeChange,
 }: ComposerToolbarProps) {
   const showHarnessSeparate = showHarnessSelector && !showModelSelector;
-  const autoApproveLabelId = useId();
 
   return (
     <div className="stg:flex stg:items-center stg:justify-between stg:gap-2 stg:border-t stg:border-border-muted stg:px-3 stg:py-2">
@@ -198,39 +174,6 @@ export function ComposerToolbar({
           />
         )}
 
-        {/* Auto-approve (#816): primary state like Mode and Model — armed
-            vs gated is something the user glances at before walking away.
-            Never bound to `disabled` (see ComposerAutoApproveProps): the
-            whole point is flipping it while a turn streams. Scoped provider:
-            this tooltip does not share the icon cluster's hover-delay group. */}
-        {autoApprove && (
-          <TooltipProvider>
-            <Tooltip>
-              <TooltipTrigger render={<span className="stg:inline-flex" />}>
-                <span className="stg:flex stg:shrink-0 stg:items-center stg:gap-1.5 stg:px-1">
-                  <label
-                    id={autoApproveLabelId}
-                    htmlFor={`${autoApproveLabelId}-switch`}
-                    className="stg:cursor-pointer stg:select-none stg:text-xs stg:text-muted-foreground"
-                  >
-                    Auto-approve
-                  </label>
-                  <Switch
-                    id={`${autoApproveLabelId}-switch`}
-                    checked={autoApprove.armed}
-                    onCheckedChange={autoApprove.onChange}
-                    aria-labelledby={autoApproveLabelId}
-                  />
-                </span>
-              </TooltipTrigger>
-              <TooltipContent side="top">
-                {autoApprove.armed
-                  ? "Tool calls run without asking — this conversation only. Turn off to be asked again."
-                  : "Run this conversation's tool calls without asking for approval, including the run in progress."}
-              </TooltipContent>
-            </Tooltip>
-          </TooltipProvider>
-        )}
       </div>
 
       {/* ---- Right group: Secondary actions (icon-only) + Send ----

package/src/composer/SessionComposer.tsx

@@ -4,7 +4,7 @@ import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useMemo,
 import { cn } from "@stigmer/theme";
 import { getUserMessage, type AttachmentInput, type EnvVarInput, type McpServerUsageInput, type ResourceRef } from "@stigmer/sdk";
 import { useComposer } from "./useComposer.js";
-import { ComposerToolbar, type ComposerAutoApproveProps } from "./ComposerToolbar.js";
+import { ComposerToolbar } from "./ComposerToolbar.js";
 import { type ConfigureMenuItem } from "./ConfigureMenu.js";
 import type { HarnessOption } from "../models/harness.js";
 import { FAST_SERVICE_TIER, type ServiceTierOption } from "../models/service-tier.js";
@@ -300,16 +300,6 @@ export interface SessionComposerProps {
   /** Show the model selector. @default true */
   readonly showModelSelector?: boolean;
 
-  /**
-   * Always-visible "auto-approve tool calls" toggle in the toolbar
-   * (stigmer/stigmer#816). Presence renders it; omission keeps the composer
-   * byte-identical (DD-011). Stays interactive while the composer is
-   * `disabled` — the walk-away user flips it exactly while a turn streams —
-   * so consumers must only wire it on surfaces whose viewer may submit
-   * approvals (never guest/observer). See {@link ComposerAutoApproveProps}.
-   */
-  readonly autoApprove?: ComposerAutoApproveProps;
-
   /**
    * Workspace state managed by {@link useWorkspaceEntries}.
    * When provided, renders a workspace trigger in the toolbar
@@ -627,7 +617,6 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
   defaultModelId,
   onModelChange,
   showModelSelector = true,
-  autoApprove,
   workspace,
   gitHubConnection,
   enableGitHub = true,
@@ -1931,7 +1920,6 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
           interactionMode={interactionMode}
           onInteractionModeChange={handleInteractionModeChange}
           showModelSelector={showModelSelector}
-          autoApprove={autoApprove}
           // The pill renders the effective selection — the same value the
           // submit payload carries (#663), never a fallback of its own.
           modelId={effective.modelId}

package/src/composer/index.ts

@@ -7,7 +7,6 @@ export type {
   SessionComposerProps,
   SessionComposerSubmitContext,
 } from "./SessionComposer.js";
-export type { ComposerAutoApproveProps } from "./ComposerToolbar.js";
 
 export { InteractionModePicker } from "./InteractionModePicker.js";
 export type {

package/src/conversation/ConversationTimelineView.tsx

@@ -17,7 +17,7 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "../internal/tooltip.js";
-import { useAutoScroll } from "../internal/useAutoScroll.js";
+import { useAutoScroll, usePinToLatestOnSignal } from "../internal/useAutoScroll.js";
 import { ConversationMediaAttachment } from "./ConversationMediaAttachment.js";
 import {
   attemptExplanationOf,
@@ -69,6 +69,20 @@ export interface ConversationTimelineViewProps {
   readonly provider: ChannelProviderId | null;
   /** Frozen instant for deterministic hosts (tests, documentation tours). */
   readonly now?: Date;
+  /**
+   * Scroll-on-send signal (stigmer-cloud#267): increment this counter when
+   * the reader dispatches a reply and the view pins to the latest content,
+   * re-engaging follow mode so the item stays in view when the timeline
+   * refetch delivers it — even for a reader who had deliberately scrolled
+   * up. The view stays presentational: it has no composer and deliberately
+   * renders no optimistic item (the SDK never fabricates what the provider
+   * might not have done), so the send moment must arrive from the host —
+   * `ConversationsWorkbench` wires its own composer's send here; headless
+   * hosts composing their own composer get the same seam. Omit to keep
+   * today's leave-the-reader-alone behavior. Incoming items never move a
+   * scrolled-up reader either way.
+   */
+  readonly pinToLatestSignal?: number;
   /** Additional classes for the view container. */
   readonly className?: string;
 }
@@ -100,10 +114,12 @@ export function ConversationTimelineView({
   isLoadingOlder,
   provider,
   now,
+  pinToLatestSignal,
   className,
 }: ConversationTimelineViewProps) {
   const { scrollRef, sentinelRef, contentRef, isFollowing, jumpToLatest } =
     useAutoScroll();
+  usePinToLatestOnSignal(pinToLatestSignal, jumpToLatest);
 
   const days = useMemo(() => groupByDay(items, now), [items, now]);
   const descriptor = channelProviderOf(provider ?? undefined);

package/src/conversation/ConversationsWorkbench.tsx

@@ -82,6 +82,19 @@ export interface ConversationsWorkbenchProps {
   readonly channelHref?: (channel: AgentChannel) => string | null;
   /** Frozen instant for deterministic hosts (tests, documentation tours). */
   readonly now?: Date;
+  /**
+   * Scroll to the reader's own reply when they send one from a scrolled-up
+   * position (stigmer-cloud#267): an accepted send pins the timeline to the
+   * latest content and re-engages follow mode, so the reply stays in view
+   * when the refetch delivers its real ledger item. Refused sends never pin
+   * — the composer restores the draft and there is nothing to show. Default
+   * `true` on all three SDK thread surfaces at once (the ratified DD-011
+   * divergence — cross-surface consistency is the point); set `false` to
+   * keep today's leave-the-reader-alone behavior.
+   *
+   * @default true
+   */
+  readonly scrollOnSend?: boolean;
   /** Additional classes for the workbench container. */
   readonly className?: string;
 }
@@ -103,6 +116,7 @@ export function ConversationsWorkbench({
   headerAccessory,
   channelHref,
   now,
+  scrollOnSend = true,
   className,
 }: ConversationsWorkbenchProps) {
   const [channelFilter, setChannelFilter] = useState("");
@@ -233,6 +247,12 @@ export function ConversationsWorkbench({
     }
   }, [timeline.items, settlingItemId]);
 
+  // Scroll-on-send (stigmer-cloud#267): a monotonic counter the timeline
+  // view pins on. Lives outside the conversation-keyed column, which is
+  // safe by the signal contract: the view initializes to the current value
+  // on (re)mount and pins only on increments it observes.
+  const [sendPinSignal, setSendPinSignal] = useState(0);
+
   const handleSend = useCallback(
     async (payload: ConversationReplyPayload) => {
       const output = await participation.reply(payload);
@@ -252,6 +272,10 @@ export function ConversationsWorkbench({
           selectionKey,
           itemId: outboundItemIdOf(output.outboundMessageId),
         });
+        // The reply produced a ledger item to show — pin the timeline so
+        // it lands in view (a refusal pins nothing: the draft came back
+        // and the reader's position should not move for it).
+        setSendPinSignal((n) => n + 1);
       }
       timeline.refetch();
       return output;
@@ -379,6 +403,7 @@ export function ConversationsWorkbench({
             isLoadingOlder={timeline.isLoadingOlder}
             provider={descriptor?.id ?? null}
             now={now}
+            pinToLatestSignal={scrollOnSend ? sendPinSignal : undefined}
           />
 
           <ConversationComposer

package/src/conversation/__tests__/ConversationTimelineView.layout.test.tsx

@@ -35,7 +35,13 @@ function items(count: number): ConversationTimelineItem[] {
           ? ConversationItemAuthor.author_customer
           : ConversationItemAuthor.author_agent,
       text: `message ${i}`,
-      at: timestampFromDate(new Date(NOW.getTime() - (count - i) * 60_000)),
+      // Anchored by INDEX, never by count: growth must only APPEND rows,
+      // as production items keep their timestamps. A count-relative time
+      // rewrote every existing row on growth — the resulting full-thread
+      // reflow could clamp scrollTop mid-pin and trip the hook's
+      // reader-took-control guard (measured flaky ~1-in-5 on the
+      // scroll-on-send case).
+      at: timestampFromDate(new Date(NOW.getTime() - (1_000 - i) * 60_000)),
     }),
   );
 }
@@ -43,6 +49,7 @@ function items(count: number): ConversationTimelineItem[] {
 function view(props: {
   readonly items: readonly ConversationTimelineItem[];
   readonly isLoading: boolean;
+  readonly pinToLatestSignal?: number;
 }): ReactElement {
   return (
     <ConversationTimelineView
@@ -54,6 +61,7 @@ function view(props: {
       isLoadingOlder={false}
       provider="whatsapp"
       now={NOW}
+      pinToLatestSignal={props.pinToLatestSignal}
     />
   );
 }
@@ -157,4 +165,32 @@ describe("ConversationTimelineView scroll behavior (F-09)", () => {
       expect(jumpButton().getAttribute("aria-hidden")).toBe("true");
     });
   });
+
+  it("pins a scrolled-up reader on their OWN send via pinToLatestSignal, and keeps following as the reply's real item lands (stigmer-cloud#267)", async () => {
+    const { rerender } = renderInPane(
+      view({ items: [], isLoading: true, pinToLatestSignal: 0 }),
+    );
+    rerender(view({ items: items(40), isLoading: false, pinToLatestSignal: 0 }));
+    await settled(() => expect(isPinnedToBottom(scroller())).toBe(true));
+
+    // The reader scrolls up to read history.
+    scroller().scrollTop = 0;
+    await settled(() =>
+      expect(jumpButton().getAttribute("aria-hidden")).toBe("false"),
+    );
+
+    // They send a reply: the workbench increments the signal on the
+    // accepted send. The view pins and re-engages follow — the timeline
+    // has no optimistic item, so re-engaged follow is what carries the
+    // reply's REAL ledger item into view when the refetch delivers it.
+    rerender(view({ items: items(40), isLoading: false, pinToLatestSignal: 1 }));
+    await settled(() => {
+      expect(isPinnedToBottom(scroller())).toBe(true);
+      expect(jumpButton().getAttribute("aria-hidden")).toBe("true");
+    });
+
+    // The refetch delivers the item — still pinned, the reply visible.
+    rerender(view({ items: items(41), isLoading: false, pinToLatestSignal: 1 }));
+    await settled(() => expect(isPinnedToBottom(scroller())).toBe(true));
+  });
 });

package/src/execution/MessageThread.tsx

@@ -1,8 +1,9 @@
 "use client";
 
-import { lazy, memo, Suspense, useCallback, useMemo, type ComponentType } from "react";
+import { lazy, memo, Suspense, useCallback, useEffect, useMemo, useRef, useState, type ComponentType } from "react";
 import { create } from "@bufbuild/protobuf";
-import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { AgentExecution, RecalledMemoriesReport } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { RecalledMemoryFact } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import type { AgentMessage, ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
 import { AgentMessageSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
 import type { SubAgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
@@ -29,6 +30,7 @@ import { ToolCallGroup } from "./ToolCallGroup.js";
 import { SubAgentSection } from "./SubAgentSection.js";
 import { ExecutionPhaseBadge } from "./ExecutionPhaseBadge.js";
 import { SetupProgress, type SetupProgressProps } from "./SetupProgress.js";
+import { RecalledMemoriesCard, type RecalledMemoriesCardProps } from "./RecalledMemoriesCard.js";
 import {
   LivenessStatusLine,
   type LivenessStatusLineProps,
@@ -56,7 +58,7 @@ import {
   unwrapEnclosingMarkdownFence,
 } from "../internal/markdown-components.js";
 import { useRenderTracer, useKeyStability, useDomNodeCount, DevProfiler } from "../internal/dev/index.js";
-import { useAutoScroll } from "../internal/useAutoScroll.js";
+import { useAutoScroll, usePinToLatestOnSignal } from "../internal/useAutoScroll.js";
 import { JumpToLatestButton } from "../internal/JumpToLatestButton.js";
 import { ApprovalPeekBar } from "../internal/ApprovalPeekBar.js";
 import { ThreadItemWrapper } from "../internal/ThreadItemWrapper.js";
@@ -113,6 +115,11 @@ export interface MessageThreadSlots {
   readonly PlanStreamingCard?: ComponentType<PlanStreamingCardProps>;
   /** Pre-first-token setup / "Thinking…" indicator. */
   readonly SetupProgress?: ComponentType<SetupProgressProps>;
+  /**
+   * The retriever transparency card at a selection-active execution's
+   * segment start — "Recalled N of M memories" (DD-008 D5).
+   */
+  readonly RecalledMemoriesCard?: ComponentType<RecalledMemoriesCardProps>;
   /**
    * The terminal execution-failure notice. Receives the raw server-reported
    * reason and the retry wiring, so a host can turn the failure into its own
@@ -170,6 +177,25 @@ export interface MessageThreadProps {
    * "Retry" control when {@link pendingMessageFailed} is `true`.
    */
   readonly onRetrySend?: () => void;
+  /**
+   * Scroll to the reader's own message when they send one from a
+   * scrolled-up position (stigmer-cloud#267 — the WhatsApp convention:
+   * showing the result of the reader's own action is Nielsen #1
+   * system-status feedback). The send moment is the
+   * {@link pendingUserMessage} transition from empty to present; the pin
+   * re-engages follow mode, so the optimistic bubble and the streamed
+   * reply stay in view. Incoming content is unaffected — it still never
+   * moves a scrolled-up reader.
+   *
+   * Default `true` on all three SDK thread surfaces at once — a deliberate,
+   * ratified divergence from DD-011's opt-in default: the issue's whole
+   * point is cross-surface consistency, and a per-surface opt-in would
+   * re-create the inconsistency it fixes. Set `false` to keep today's
+   * leave-the-reader-alone behavior.
+   *
+   * @default true
+   */
+  readonly scrollOnSend?: boolean;
   /**
    * When provided, the in-flight human turn (the active execution's prompt)
    * shows a hover "Edit" affordance. Clicking it invokes this callback with
@@ -379,6 +405,7 @@ export type ThreadItem =
   | { readonly kind: "approval-request"; readonly pendingApproval: PendingApproval; readonly key: string }
   | { readonly kind: "file-review-record"; readonly fileChangeSet: FileChangeSet; readonly key: string }
   | { readonly kind: "setup-progress"; readonly workspaceEntries: readonly WorkspaceEntry[]; readonly serverPhase?: string; readonly isAwaitingResponse?: boolean; readonly key: string }
+  | { readonly kind: "recalled-memories"; readonly report: RecalledMemoriesReport; readonly facts: readonly RecalledMemoryFact[]; readonly key: string }
   | { readonly kind: "context-compacted"; readonly event: SummarizationEventView; readonly key: string }
   | {
       readonly kind: "todos";
@@ -805,6 +832,24 @@ export function buildThreadItems(
       });
     }
 
+    // The retriever transparency card (stigmer#293 Phase 3a, DD-008 D5):
+    // this execution ran semantic selection over its memory snapshot, so
+    // its segment discloses the subset right after the user's turn —
+    // spec.message is the query the retriever embedded. Absent report or
+    // selection_active=false means wholesale (unchanged Phase 2 behavior)
+    // and renders nothing. Gated on the REPORT, not the prompt bubble:
+    // syntheticUserPrompt deliberately skips some user turns (empty
+    // prompt, build-from-plan) that can still be selection-active.
+    const recalledReport = exec.status?.recalledMemoriesReport;
+    if (recalledReport?.selectionActive) {
+      items.push({
+        kind: "recalled-memories",
+        report: recalledReport,
+        facts: exec.spec?.recalledMemories?.facts ?? [],
+        key: `${execId}-recalled-memories`,
+      });
+    }
+
     for (let mi = 0; mi < messages.length; mi++) {
       const msg = messages[mi];
 
@@ -1163,6 +1208,7 @@ export function MessageThread({
   pendingAttachments,
   pendingMessageFailed = false,
   onRetrySend,
+  scrollOnSend = true,
   onRetryExecution,
   onEditMessage,
   className,
@@ -1199,6 +1245,22 @@ export function MessageThread({
 
   useKeyStability(items);
 
+  // Scroll-on-send (stigmer-cloud#267): the send moment is the optimistic
+  // message's empty→present transition — the one signal both render paths
+  // share. A monotonic counter (not the message text) carries it down, so
+  // repeated sends of identical text still pin and a retry of a FAILED send
+  // (pending stays present throughout) deliberately does not re-pin.
+  const [sendSignal, setSendSignal] = useState(0);
+  const wasPendingRef = useRef(false);
+  useEffect(() => {
+    const isPending = !!pendingUserMessage;
+    if (isPending && !wasPendingRef.current) {
+      setSendSignal((n) => n + 1);
+    }
+    wasPendingRef.current = isPending;
+  }, [pendingUserMessage]);
+  const pinToLatestSignal = scrollOnSend ? sendSignal : undefined;
+
   const filePathCtx = useMemo<FilePathContextValue>(
     () => ({
       workspaceEntries: workspaceEntries ?? [],
@@ -1288,6 +1350,7 @@ export function MessageThread({
             onRetryExecution={onRetryExecution}
             onEditMessage={onEditMessage}
             slots={slots}
+            pinToLatestSignal={pinToLatestSignal}
           />
         </Suspense>
       </div>
@@ -1317,6 +1380,7 @@ export function MessageThread({
       onRetryExecution={onRetryExecution}
       onEditMessage={onEditMessage}
       slots={slots}
+      pinToLatestSignal={pinToLatestSignal}
     />
   );
 }
@@ -1352,6 +1416,8 @@ interface NonVirtualizedThreadProps {
   readonly onRetryExecution?: (message: string) => void;
   readonly onEditMessage?: (text: string) => void;
   readonly slots?: MessageThreadSlots;
+  /** Scroll-on-send counter from the parent (see `usePinToLatestOnSignal`). */
+  readonly pinToLatestSignal?: number;
 }
 
 function NonVirtualizedThread({
@@ -1376,9 +1442,11 @@ function NonVirtualizedThread({
   onRetryExecution,
   onEditMessage,
   slots,
+  pinToLatestSignal,
 }: NonVirtualizedThreadProps) {
   const { scrollRef, sentinelRef, contentRef, isFollowing, jumpToLatest } =
     useAutoScroll();
+  usePinToLatestOnSignal(pinToLatestSignal, jumpToLatest);
 
   useDomNodeCount(scrollRef, "MessageThread");
 
@@ -1593,6 +1661,10 @@ export function ThreadItemRenderer({
         />
       );
     }
+    case "recalled-memories": {
+      const Recalled = slots?.RecalledMemoriesCard ?? RecalledMemoriesCard;
+      return <Recalled report={item.report} facts={item.facts} />;
+    }
     case "context-compacted":
       return <SummarizationCard event={item.event} />;
     case "liveness": {