@stigmer/react 3.12.8 → 3.12.9

package/src/internal/useAutoScroll.ts

@@ -69,6 +69,13 @@ export function useAutoScroll(): UseAutoScrollReturn {
   const [isFollowing, setIsFollowing] = useState(true);
   const isFollowingRef = useRef(true);
   const rafIdRef = useRef(0);
+  // The last scrollTop THIS HOOK wrote (mount pin, rAF growth writes,
+  // jumpToLatest). The reader-vs-growth discriminator for the observer
+  // callbacks: content growth never moves scrollTop — only the reader
+  // does — so "not near bottom" while scrollTop still sits exactly on the
+  // system's own last write means content grew under a pin, not that the
+  // reader escaped.
+  const lastSystemScrollTopRef = useRef<number | null>(null);
 
   // Keep ref in sync with state so observer callbacks read the latest
   // value without re-subscribing on every state change.
@@ -85,6 +92,7 @@ export function useAutoScroll(): UseAutoScrollReturn {
     // Establish initial position at the bottom so the first IO
     // callback sees the sentinel as intersecting.
     scroller.scrollTop = scroller.scrollHeight;
+    lastSystemScrollTopRef.current = scroller.scrollTop;
 
     const io = new IntersectionObserver(
       () => {
@@ -101,6 +109,18 @@ export function useAutoScroll(): UseAutoScrollReturn {
         const visible =
           el.scrollHeight - el.scrollTop - el.clientHeight <=
           NEAR_BOTTOM_MARGIN_PX;
+        // The growth-vs-reader discriminator (the write-time guard's
+        // mirror, found via the stigmer-cloud#267 pin-on-send suite): a
+        // delivery can measure geometry where content ALREADY grew below
+        // a system pin but the pin's ResizeObserver write has not run
+        // yet. Measured live that reads "not visible" — yet the reader
+        // never moved (scrollTop still sits exactly on the system's own
+        // last write). Disengaging here would make the imminent RO
+        // callback drop its write and strand the thread one row shy of
+        // the bottom with follow off. Only the READER may disengage.
+        if (!visible && el.scrollTop === lastSystemScrollTopRef.current) {
+          return;
+        }
         isFollowingRef.current = visible;
         setIsFollowing(visible);
       },
@@ -147,6 +167,7 @@ export function useAutoScroll(): UseAutoScrollReturn {
         if (!el) return;
         if (scheduledAt !== null && el.scrollTop !== scheduledAt) return;
         el.scrollTop = el.scrollHeight;
+        lastSystemScrollTopRef.current = el.scrollTop;
       });
     });
     ro.observe(node);
@@ -157,6 +178,7 @@ export function useAutoScroll(): UseAutoScrollReturn {
     const el = scrollRef.current;
     if (!el) return;
     el.scrollTop = el.scrollHeight;
+    lastSystemScrollTopRef.current = el.scrollTop;
     // Eagerly set following — IO callback will confirm when the
     // sentinel becomes visible after the scroll.
     isFollowingRef.current = true;
@@ -165,3 +187,35 @@ export function useAutoScroll(): UseAutoScrollReturn {
 
   return { scrollRef, sentinelRef, contentRef, isFollowing, jumpToLatest };
 }
+
+/**
+ * Pins the thread to its latest content whenever `signal` changes — the
+ * scroll-on-send idiom (stigmer-cloud#267): each surface increments a
+ * monotonic counter at its own "the reader sent something" moment (an
+ * optimistic message appearing, a conversation reply dispatched, a HITL
+ * decision submitted), and the pin re-engages follow mode so the resulting
+ * content lands in view even for a reader who had deliberately scrolled up.
+ * WhatsApp convention: showing the result of the reader's OWN action is
+ * Nielsen #1 system-status feedback — distinct from INCOMING content, which
+ * must never move a scrolled-up reader (the F-09 posture, unchanged).
+ *
+ * <p>No pin fires on mount, on an `undefined` signal (surface opted out or
+ * prop not wired), or on the `undefined`→number transition (a prop
+ * appearing is not a send).
+ *
+ * @internal Not part of the public API.
+ */
+export function usePinToLatestOnSignal(
+  signal: number | undefined,
+  pinToLatest: () => void,
+): void {
+  const previousRef = useRef(signal);
+  useEffect(() => {
+    const previous = previousRef.current;
+    previousRef.current = signal;
+    if (signal === undefined || previous === undefined || signal === previous) {
+      return;
+    }
+    pinToLatest();
+  }, [signal, pinToLatest]);
+}

package/src/organization/OrgPreferencesPanel.tsx

@@ -221,7 +221,7 @@ export function OrgPreferencesPanel({
         saving={isSavingMemoryFlag}
         readOnly={!canEdit}
         error={memoryFlagError}
-        helperText="Allow agents to remember confirmed facts about members of this organization. Each member must also turn memory on in their own account preferences. Changes apply immediately."
+        helperText="Allow agents to remember confirmed facts about members of this organization. Each member must also turn memory on in their own account preferences; once a member has many memories, each conversation recalls their most relevant ones, shown on the execution. Changes apply immediately."
       />
 
       {!canEdit && (

package/src/settings/MemorySection.tsx

@@ -29,8 +29,10 @@ export function MemorySection() {
       <p className="stg:text-muted-foreground stg:mb-6 stg:text-xs">
         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&apos; records. Only you can see
-        them here, and you can edit or delete any of them at any time.
+        and appear in those executions&apos; 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.
       </p>
 
       {!org ? (

package/src/workflow/__tests__/WorkflowExecutionViewer.approvals.test.tsx

@@ -31,7 +31,11 @@ import {
 } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import type { WorkflowExecutionEvent } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
-import { ExecutionPhase as AgentExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  ApprovalAction,
+  ExecutionPhase as AgentExecutionPhase,
+  FileDecisionAction,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { DerivedCostSummary } from "../../internal/store/workflow-execution-event-store";
 import { WorkflowExecutionEventStore } from "../../internal/store/workflow-execution-event-store";
 import { useWorkflowExecution } from "../useWorkflowExecution";
@@ -303,14 +307,29 @@ describe("WorkflowExecutionViewer in-thread HITL (S10/T06/T07)", () => {
     const actions = arrange();
     render(<WorkflowExecutionViewer executionId="wex_1" />);
 
-    // Identity, not equivalence: the transcript submits through the SAME
-    // workflow-level handlers every other surface uses, so in-flight and
-    // error state can never fork — and never the child's agentExecution.*
-    // path (checked exhaustively in WorkflowAgentCallTranscript.test.tsx).
+    // The transcript submits through the SAME workflow-level handlers
+    // every other surface uses, so in-flight and error state can never
+    // fork — and never the child's agentExecution.* path (checked
+    // exhaustively in WorkflowAgentCallTranscript.test.tsx). State fields
+    // pass by IDENTITY; the submit fns are asserted by DELEGATION since
+    // the thread's scroll-on-send wrapper (stigmer-cloud#267) pins the
+    // view before handing each call to the single instance — a per-card
+    // duplicate would still fail here, because the delegate IS the
+    // viewer's own spy.
+    expect(mockedTranscript.mock.calls.length).toBeGreaterThan(0);
     for (const call of mockedTranscript.mock.calls) {
       const hitl = call[0].hitl!;
-      expect(hitl.submitApproval).toBe(actions.submitApproval);
-      expect(hitl.submitFileDecision).toBe(actions.submitFileDecision);
+      hitl.submitApproval("tc-probe", ApprovalAction.APPROVE);
+      expect(actions.submitApproval).toHaveBeenLastCalledWith(
+        "tc-probe",
+        ApprovalAction.APPROVE,
+      );
+      hitl.submitFileDecision("agx-probe", "cs-probe", FileDecisionAction.APPROVE);
+      expect(actions.submitFileDecision).toHaveBeenLastCalledWith(
+        "agx-probe",
+        "cs-probe",
+        FileDecisionAction.APPROVE,
+      );
       expect(hitl.approvalSubmittingToolCallIds).toBe(
         actions.approvalSubmittingToolCallIds,
       );

package/src/workflow/__tests__/task-presentation.test.ts

@@ -286,21 +286,55 @@ describe("per-kind preview lines", () => {
       overrides: { agentSlug: "blog-writer", messagesCount: 12, toolCallsCount: 5 },
       expected: "blog-writer · 12 msgs · 5 tools",
     },
+    {
+      label: "switch_case settled on a target branch (R6-5)",
+      kind: WorkflowTaskKind.switch_case,
+      overrides: { outputSummary: { __flow_directive__: "approved-path" } },
+      expected: "→ approved-path",
+    },
+    {
+      label: "switch_case settled on a termination directive",
+      kind: WorkflowTaskKind.switch_case,
+      overrides: { outputSummary: { __flow_directive__: "exit" } },
+      expected: "→ exit",
+    },
+    {
+      label: "try_catch recovered via catch retry (R6-5)",
+      kind: WorkflowTaskKind.try_catch,
+      overrides: { attemptNumber: 3, outputSummary: { result: "ok" } },
+      expected: "recovered after 3 attempts",
+    },
+    {
+      label: "try_catch settled block result (first-attempt success)",
+      kind: WorkflowTaskKind.try_catch,
+      overrides: { outputSummary: { result: 42 } },
+      expected: "42",
+    },
   ])("$label", ({ kind, overrides, expected }) => {
     const { previewLine } = resolveTaskPreview(state({ taskKind: kind, ...overrides }));
     expect(previewLine).toBe(expected);
   });
 
-  // Kinds that deliberately stay status-only: control flow (branch/fork
-  // detail needs graph topology the thread lacks — deferred), raise_error
-  // (the failure precedence carries the message), the invocation kinds
-  // (no verified output envelope — backend follow-up), and unspecified
-  // (the snapshot fallback).
+  // switch_case degrades to status-only when no case matched: the executor
+  // returns no directive, so there is honestly nothing to say (R6-5).
+  it("switch_case yields an empty line without a flow directive", () => {
+    const { previewLine } = resolveTaskPreview(
+      state({
+        taskKind: WorkflowTaskKind.switch_case,
+        outputSummary: { some: "data" },
+      }),
+    );
+    expect(previewLine).toBe("");
+  });
+
+  // Kinds that deliberately stay status-only: remaining control flow
+  // (for/fork detail needs graph topology the thread lacks — deferred),
+  // raise_error (the failure precedence carries the message; its preview
+  // BODY carries the detail), the invocation kinds (no verified output
+  // envelope — backend follow-up), and unspecified (the snapshot fallback).
   it.each([
-    WorkflowTaskKind.switch_case,
     WorkflowTaskKind.for_each,
     WorkflowTaskKind.fork,
-    WorkflowTaskKind.try_catch,
     WorkflowTaskKind.raise_error,
     WorkflowTaskKind.http_call,
     WorkflowTaskKind.grpc_call,
@@ -396,9 +430,12 @@ type JsonValueLike = Parameters<typeof valueSnippet>[0];
 describe("defaultDisclosureForKind", () => {
   // T05 (DD-T05-5): every kind whose output CAN matter is a preview kind —
   // the showBody gate keeps output-less cards as one-line rows, so preview
-  // disclosure costs nothing until the runner writes real output. Only
-  // genuinely body-less kinds (control flow, wait/listen, unspecified)
-  // remain summary.
+  // disclosure costs nothing until the runner writes real output. R6-5
+  // adds try_catch (its output is the block's settled result) and
+  // raise_error (always fails; the preview body IS the always-visible
+  // failure detail). Only genuinely body-less kinds remain summary —
+  // including switch_case DELIBERATELY: its whole content is the one-word
+  // directive on its preview line; a body would only repeat it.
   it.each([
     [WorkflowTaskKind.transform, "preview"],
     [WorkflowTaskKind.validate, "preview"],
@@ -413,13 +450,13 @@ describe("defaultDisclosureForKind", () => {
     [WorkflowTaskKind.grpc_call, "preview"],
     [WorkflowTaskKind.activity_call, "preview"],
     [WorkflowTaskKind.run_workflow, "preview"],
+    [WorkflowTaskKind.try_catch, "preview"],
+    [WorkflowTaskKind.raise_error, "preview"],
     [WorkflowTaskKind.wait, "summary"],
     [WorkflowTaskKind.switch_case, "summary"],
     [WorkflowTaskKind.fork, "summary"],
-    [WorkflowTaskKind.try_catch, "summary"],
     [WorkflowTaskKind.for_each, "summary"],
     [WorkflowTaskKind.listen, "summary"],
-    [WorkflowTaskKind.raise_error, "summary"],
     [WorkflowTaskKind.workflow_task_kind_unspecified, "summary"],
   ] as const)("kind %d defaults to %s", (kind, expected) => {
     expect(defaultDisclosureForKind(kind)).toBe(expected);

package/src/workflow/__tests__/workflow-thread-scroll-on-send.test.tsx

@@ -0,0 +1,145 @@
+// Scroll-on-send wiring pins for WorkflowTaskThread (stigmer-cloud#267):
+// the workflow surface's send-analog is a HITL decision submission —
+// submitting pins the thread (default-ON, opt-out via
+// `scrollOnSend={false}`) BEFORE delegating, so the unblocked run's
+// continuation lands in view. The real scroll mechanics are pinned in
+// `internal/__tests__/useAutoScroll.layout.test.tsx`; this file pins the
+// hitl-wrapper wiring through a spied `jumpToLatest`.
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup, within } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import { ApprovalRequestedPayloadSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
+import type { DerivedTaskState } from "../../internal/store/workflow-execution-event-store";
+
+const jumpToLatestSpy = vi.fn();
+
+// Replaces only the scroll machine (browser observers happy-dom lacks) with
+// a spied jumpToLatest — the wrapper under test calls it directly.
+vi.mock("../../internal/useAutoScroll", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("../../internal/useAutoScroll")>();
+  return {
+    ...original,
+    useAutoScroll: () => ({
+      scrollRef: { current: null },
+      sentinelRef: { current: null },
+      contentRef: () => {},
+      isFollowing: true,
+      jumpToLatest: jumpToLatestSpy,
+    }),
+  };
+});
+
+import {
+  WorkflowTaskThread,
+  type WorkflowThreadHitl,
+} from "../thread/WorkflowTaskThread";
+
+afterEach(() => {
+  cleanup();
+  jumpToLatestSpy.mockClear();
+});
+
+function makeHitl(): WorkflowThreadHitl {
+  return {
+    submitApproval: vi.fn(),
+    approvalSubmittingToolCallIds: new Set<string>(),
+    approvalErrorsByToolCallId: new Map<string, Error>(),
+    submitTaskApproval: vi.fn(),
+    taskApprovalSubmittingTaskNames: new Set<string>(),
+    taskApprovalErrorsByTaskName: new Map<string, Error>(),
+    submitFileDecision: vi.fn(),
+    fileDecisionSubmittingKeys: new Set<string>(),
+    fileDecisionErrorsByKey: new Map<string, Error>(),
+  };
+}
+
+/** A gating human_input task carrying its captured request payload. */
+function gatedHumanInput(taskName: string): DerivedTaskState {
+  return {
+    taskName,
+    taskKind: WorkflowTaskKind.human_input,
+    status: "waiting_approval",
+    durationMs: 0,
+    costMicros: 0n,
+    tokensUsed: 0n,
+    attemptNumber: 1,
+    error: "",
+    childExecutionId: "",
+    agentSlug: "",
+    currentToolName: "",
+    messagesCount: 0,
+    toolCallsCount: 0,
+    inputSummary: null,
+    outputSummary: null,
+    approvalRequest: create(ApprovalRequestedPayloadSchema, {
+      prompt: "Ship the release?",
+      outcomes: [
+        { name: "ship", label: "Ship It" },
+        { name: "hold", label: "Hold" },
+      ],
+    }),
+    approvalResolution: null,
+  } as DerivedTaskState;
+}
+
+function statesOf(...states: DerivedTaskState[]): ReadonlyMap<string, DerivedTaskState> {
+  return new Map(states.map((s) => [s.taskName, s]));
+}
+
+function submitShipIt(): void {
+  const form = screen.getByRole("form", {
+    name: "Approval decision for review-gate",
+  });
+  fireEvent.click(within(form).getByRole("button", { name: "Ship It" }));
+}
+
+describe("WorkflowTaskThread — scroll-on-send (stigmer-cloud#267)", () => {
+  it("pins the thread when a HITL decision is submitted, then delegates to the workflow-level submit (default-on)", () => {
+    const hitl = makeHitl();
+    render(
+      <WorkflowTaskThread
+        taskStates={statesOf(gatedHumanInput("review-gate"))}
+        totalTasks={1}
+        isRunning
+        hitl={hitl}
+      />,
+    );
+    expect(jumpToLatestSpy).not.toHaveBeenCalled();
+
+    submitShipIt();
+
+    expect(jumpToLatestSpy).toHaveBeenCalledTimes(1);
+    expect(hitl.submitTaskApproval).toHaveBeenCalledWith(
+      "review-gate",
+      "ship",
+      undefined,
+      undefined,
+    );
+  });
+
+  it("never pins with scrollOnSend={false} — the decision still routes through unchanged", () => {
+    const hitl = makeHitl();
+    render(
+      <WorkflowTaskThread
+        taskStates={statesOf(gatedHumanInput("review-gate"))}
+        totalTasks={1}
+        isRunning
+        hitl={hitl}
+        scrollOnSend={false}
+      />,
+    );
+
+    submitShipIt();
+
+    expect(jumpToLatestSpy).not.toHaveBeenCalled();
+    expect(hitl.submitTaskApproval).toHaveBeenCalledWith(
+      "review-gate",
+      "ship",
+      undefined,
+      undefined,
+    );
+  });
+});

package/src/workflow/thread/WorkflowTaskThread.tsx

@@ -92,6 +92,19 @@ export interface WorkflowTaskThreadProps {
    * summaries already on the items.
    */
   readonly taskSnapshotsByName?: ReadonlyMap<string, WorkflowTask>;
+  /**
+   * Scroll to the latest content when the reader submits a HITL decision
+   * from a scrolled-up position (stigmer-cloud#267) — the workflow surface's
+   * send-analog: approving a gate, deciding a file review, or answering a
+   * task-level human_input gate re-engages follow mode, so the run's
+   * continuation lands in view. Incoming task activity is unaffected — it
+   * still never moves a scrolled-up reader. 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 behavior.
+   *
+   * @default true
+   */
+  readonly scrollOnSend?: boolean;
   /** Additional CSS class names for the root container. */
   readonly className?: string;
 }
@@ -135,12 +148,38 @@ export const WorkflowTaskThread = memo(function WorkflowTaskThread({
   onNavigateToAgentExecution,
   hitl,
   taskSnapshotsByName,
+  scrollOnSend = true,
   className,
 }: WorkflowTaskThreadProps) {
   const { items, progress } = useWorkflowThreadItems(taskStates, totalTasks);
   const { scrollRef, sentinelRef, contentRef, isFollowing, jumpToLatest } =
     useAutoScroll();
 
+  // Scroll-on-send (stigmer-cloud#267): submitting a decision pins the
+  // thread before delegating, so the unblocked run's continuation lands in
+  // view. The wrapper's identity moves with the bundle's — deliberate: the
+  // bundle re-materializes exactly when its gate state flips (see the
+  // render-site note below), and a stale wrapper would leak stale state
+  // fields. `jumpToLatest` is referentially stable (useAutoScroll pins it).
+  const threadHitl = useMemo<WorkflowThreadHitl | undefined>(() => {
+    if (!hitl || !scrollOnSend) return hitl;
+    return {
+      ...hitl,
+      submitApproval: (...args: Parameters<WorkflowThreadHitl["submitApproval"]>) => {
+        jumpToLatest();
+        return hitl.submitApproval(...args);
+      },
+      submitTaskApproval: (...args: Parameters<WorkflowThreadHitl["submitTaskApproval"]>) => {
+        jumpToLatest();
+        return hitl.submitTaskApproval(...args);
+      },
+      submitFileDecision: (...args: Parameters<WorkflowThreadHitl["submitFileDecision"]>) => {
+        jumpToLatest();
+        return hitl.submitFileDecision(...args);
+      },
+    };
+  }, [hitl, scrollOnSend, jumpToLatest]);
+
   return (
     <div className={cn("stg:relative stg:flex stg:h-full stg:min-h-0 stg:flex-col", className)}>
       <ThreadProgressHeader progress={progress} isRunning={isRunning} />
@@ -164,7 +203,7 @@ export const WorkflowTaskThread = memo(function WorkflowTaskThread({
                 // would re-render the whole column per spinner tick. Scoped
                 // here, non-gating cards keep `undefined === undefined` and
                 // their memo bails hold.
-                hitl={item.status === "waiting_approval" ? hitl : undefined}
+                hitl={item.status === "waiting_approval" ? threadHitl : undefined}
                 snapshot={taskSnapshotsByName?.get(item.taskName)}
               />
             ))
@@ -412,6 +451,10 @@ const ThreadTaskCard = memo(function ThreadTaskCard({
                 </pre>
               </BoundedContent>
             )}
+            {/* Carries the card's (wrapped) bundle: a child-gate decision
+                inside this transcript is a send too, and the gating card is
+                the thread's active tail — pinning the outer thread keeps
+                the transcript's continuation in view as it streams. */}
             <WorkflowAgentCallTranscript
               childExecutionId={item.childExecutionId}
               agentSlug={item.agentSlug || undefined}
@@ -596,10 +639,11 @@ function ThreadTaskDetail({
   readonly inputIO: TaskDetailIO | null;
   readonly outputIO: TaskDetailIO | null;
 }) {
-  const rows: Array<[string, string]> = [["Status", statusLabel(item.status)]];
-  if (item.durationMs > 0) {
-    rows.push(["Duration", formatMetaChips({ durationMs: item.durationMs }) ?? ""]);
-  }
+  // No Status/Duration rows (R6-6): the card header is the single source
+  // for both — the status glyph and the duration meta chip. The detail
+  // body carries only what the header cannot: attempt count, usage, the
+  // agent slug.
+  const rows: Array<[string, string]> = [];
   if (item.attemptNumber > 1) rows.push(["Attempt", String(item.attemptNumber)]);
   const costChip = formatMetaChips({
     costMicros: item.costMicros,
@@ -612,14 +656,16 @@ function ThreadTaskDetail({
 
   return (
     <div className="stg:flex stg:flex-col stg:gap-2">
-      <dl className="stg:grid stg:grid-cols-[auto_1fr] stg:gap-x-4 stg:gap-y-1 stg:text-xs">
-        {rows.map(([label, value]) => (
-          <div key={label} className="stg:contents">
-            <dt className="stg:text-muted-foreground">{label}</dt>
-            <dd className="stg:text-foreground">{value}</dd>
-          </div>
-        ))}
-      </dl>
+      {rows.length > 0 && (
+        <dl className="stg:grid stg:grid-cols-[auto_1fr] stg:gap-x-4 stg:gap-y-1 stg:text-xs">
+          {rows.map(([label, value]) => (
+            <div key={label} className="stg:contents">
+              <dt className="stg:text-muted-foreground">{label}</dt>
+              <dd className="stg:text-foreground">{value}</dd>
+            </div>
+          ))}
+        </dl>
+      )}
 
       {item.error && (
         <BoundedContent>
@@ -637,25 +683,6 @@ function ThreadTaskDetail({
   );
 }
 
-function statusLabel(status: WorkflowThreadItem["status"]): string {
-  switch (status) {
-    case "waiting_approval":
-      return "Waiting for approval";
-    case "retrying":
-      return "Retrying";
-    case "running":
-      return "Running";
-    case "completed":
-      return "Completed";
-    case "failed":
-      return "Failed";
-    case "skipped":
-      return "Skipped";
-    case "pending":
-      return "Pending";
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Status glyph — the shared thread-card set, colored by status token (T05)
 // ---------------------------------------------------------------------------

package/src/workflow/thread/task-presentation.ts

@@ -124,9 +124,18 @@ export function getTaskPresenter(
  * the output-envelope follow-up standardizes them (DD-T04-3) — stays a
  * clean one-line row with zero cost. `set_vars` earns its place from live
  * data: the runner writes the seeded variables to task output (T05, R2-5).
+ * `try_catch` earns it the same way: its output is the try (or catch.do)
+ * block's settled result — the `transform` class. `raise_error` earns it
+ * from the OTHER `showBody` arm: it always fails, and the preview body
+ * renders the full failure detail without a click (R6-5).
  *
- * Only genuinely body-less kinds (control flow, `wait`/`listen`, and the
- * snapshot fallback's `unspecified`) stay compact summary rows.
+ * Only genuinely body-less kinds stay compact summary rows: `wait`/
+ * `listen`, the snapshot fallback's `unspecified`, and the remaining
+ * control flow — including `switch_case`, DELIBERATELY (an R6-5
+ * refinement): its entire settled content is the one-word flow directive,
+ * carried by its always-visible preview line below; a body would only
+ * re-render the raw `{__flow_directive__}` marker, failing the "does the
+ * body carry content the one-line row cannot?" rule.
  */
 const PREVIEW_KINDS: ReadonlySet<WorkflowTaskKind> = new Set([
   WorkflowTaskKind.transform,
@@ -142,6 +151,8 @@ const PREVIEW_KINDS: ReadonlySet<WorkflowTaskKind> = new Set([
   WorkflowTaskKind.grpc_call,
   WorkflowTaskKind.activity_call,
   WorkflowTaskKind.run_workflow,
+  WorkflowTaskKind.try_catch,
+  WorkflowTaskKind.raise_error,
 ]);
 
 /** Default disclosure mode for a task kind. */
@@ -218,12 +229,17 @@ function defaultPreviewLine(state: DerivedTaskState): string | null {
       return waitLine(state);
     case WorkflowTaskKind.listen:
       return listenLine(state);
+    case WorkflowTaskKind.switch_case:
+      return switchCaseLine(state.outputSummary);
+    case WorkflowTaskKind.try_catch:
+      return tryCatchLine(state);
     default:
-      // Control flow (branch-taken / fork progress need graph topology the
-      // thread does not have — deferred), raise_error (the failure
-      // precedence already shows the message), the invocation kinds
-      // (pending the backend output-envelope follow-up), and the snapshot
-      // fallback's `unspecified` all stay status-only.
+      // Remaining control flow (for_each / fork progress need graph
+      // topology the thread does not have — deferred), raise_error (the
+      // failure precedence already shows the message; its preview body
+      // carries the full detail), the invocation kinds (pending the
+      // backend output-envelope follow-up), and the snapshot fallback's
+      // `unspecified` all stay status-only.
       return null;
   }
 }
@@ -354,6 +370,35 @@ function listenLine(state: DerivedTaskState): string | null {
   return null;
 }
 
+/**
+ * `→ approved-path` / `→ exit` — the flow directive the switch settled on
+ * (R6-5). The switch executor's only output is the `__flow_directive__`
+ * marker carrying the matched case's `then` (a target task name, or the
+ * `continue`/`end`/`exit` terminals), and `do-executor` writes raw task
+ * output to the event summary — so the branch taken is already on the
+ * wire. No case matched means no output: status-only, honestly.
+ */
+function switchCaseLine(output: JsonObject | null): string | null {
+  const directive = asString(output?.["__flow_directive__"]);
+  return directive ? `\u2192 ${directive}` : null;
+}
+
+/**
+ * `recovered after 2 attempts` / snippet of the settled block result
+ * (R6-5). The try task's own `task_retrying` events drive
+ * `attemptNumber`, so a completion above attempt 1 IS a catch-retry
+ * recovery. A catch.do-path recovery (no retry configured) is NOT
+ * distinguishable from plain success in the emitted data — deliberately
+ * unmarked: adding a marker to task output would leak presentation into
+ * workflow dataflow (`processTaskOutput` consumes it downstream).
+ */
+function tryCatchLine(state: DerivedTaskState): string | null {
+  if (state.status === "completed" && state.attemptNumber > 1) {
+    return `recovered after ${state.attemptNumber} attempts`;
+  }
+  return state.outputSummary ? valueSnippet(state.outputSummary) : null;
+}
+
 // ---------------------------------------------------------------------------
 // Struct-reading helpers (defensive by construction)
 // ---------------------------------------------------------------------------

package/workflow/thread/WorkflowTaskThread.d.ts

@@ -44,6 +44,19 @@ export interface WorkflowTaskThreadProps {
      * summaries already on the items.
      */
     readonly taskSnapshotsByName?: ReadonlyMap<string, WorkflowTask>;
+    /**
+     * Scroll to the latest content when the reader submits a HITL decision
+     * from a scrolled-up position (stigmer-cloud#267) — the workflow surface's
+     * send-analog: approving a gate, deciding a file review, or answering a
+     * task-level human_input gate re-engages follow mode, so the run's
+     * continuation lands in view. Incoming task activity is unaffected — it
+     * still never moves a scrolled-up reader. 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 behavior.
+     *
+     * @default true
+     */
+    readonly scrollOnSend?: boolean;
     /** Additional CSS class names for the root container. */
     readonly className?: string;
 }