@stigmer/react 3.12.8 → 3.13.0

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/provider-standing/useProviderStanding.ts

@@ -25,7 +25,7 @@ export interface UseProviderStandingReturn {
  *
  * Platform-operator surface: the caller needs
  * `can_view_provider_standing` on `platform:stigmer`. Cloud-only — the
- * OSS Go server does not implement the controller.
+ * OSS server does not implement the controller.
  *
  * Pass `enabled: false` to skip fetching (stable no-op).
  *

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__/WorkflowExecutionViewer.reconciliation.test.tsx

@@ -383,19 +383,21 @@ describe("WorkflowExecutionViewer (center-column Thread|Graph toggle, S9)", () =
   it("a thread card offers no selection or drill-down gesture — the card IS the surface (T06)", () => {
     renderViewer();
 
-    // build-report has kind 0 (unspecified → summary disclosure): its header
-    // is the expand gesture, never a selection.
-    const header = screen.getByRole("button", { name: /^build-report/ });
-    expect(header.getAttribute("aria-expanded")).toBe("false");
-    expect(header.getAttribute("aria-pressed")).toBeNull();
+    // build-report renders from the snapshot fallback (no events): kind 0
+    // (unspecified → summary disclosure) with nothing beyond what its
+    // header row already carries — so it is a PLAIN row (stigmer#886): no
+    // expand chevron, no selection, no Inspect drill-down. (Expansion
+    // being card-local for content-bearing summary cards is pinned in
+    // WorkflowTaskThread.test.tsx.)
+    expect(
+      screen.queryByRole("button", { name: /^build-report/ }),
+    ).toBeNull();
     expect(
       screen.queryByRole("button", { name: "Inspect build-report" }),
     ).toBeNull();
 
-    fireEvent.click(header);
-
-    // Expansion is card-local; the panel never opens on a card gesture.
-    expect(header.getAttribute("aria-expanded")).toBe("true");
+    // Clicking the row is inert: the panel never opens on a card gesture.
+    fireEvent.click(screen.getByText("build-report"));
     expect(screen.queryByRole("radio", { name: "Inspect" })).toBeNull();
   });
 

package/src/workflow/__tests__/WorkflowTaskThread.test.tsx

@@ -451,6 +451,48 @@ describe("WorkflowTaskThread", () => {
     expect(screen.getByText(/at dial tcp 10\.0\.0\.1:443/)).toBeTruthy();
   });
 
+  it("a summary-kind card with a body-less detail renders no expand gesture (stigmer#886)", () => {
+    // A settled wait card with nothing the header cannot carry — no retry,
+    // no usage, no error, no I/O. Since R6-6 moved Status/Duration onto
+    // the header, its detail body would be empty, so the header is a plain
+    // row: offering a chevron that reveals nothing is worse than none.
+    render(
+      <WorkflowTaskThread
+        taskStates={statesOf(
+          taskState({ taskName: "blocking_wait", taskKind: WorkflowTaskKind.wait }),
+        )}
+        totalTasks={1}
+        isRunning={false}
+      />,
+    );
+
+    expect(screen.getByText("blocking_wait")).toBeTruthy();
+    expect(screen.queryByRole("button", { name: /^blocking_wait/ })).toBeNull();
+  });
+
+  it("the expand gesture returns the moment the detail body has content (stigmer#886)", () => {
+    // The same wait card with a retry behind it: the Attempt row gives the
+    // body content, so the header is the expand gesture again.
+    render(
+      <WorkflowTaskThread
+        taskStates={statesOf(
+          taskState({
+            taskName: "blocking_wait",
+            taskKind: WorkflowTaskKind.wait,
+            attemptNumber: 2,
+          }),
+        )}
+        totalTasks={1}
+        isRunning={false}
+      />,
+    );
+
+    const header = screen.getByRole("button", { name: /^blocking_wait/ });
+    fireEvent.click(header);
+    expect(screen.getByText("Attempt")).toBeTruthy();
+    expect(screen.getByText("2")).toBeTruthy();
+  });
+
   it("shows the full error in a summary-kind card's expanded body", () => {
     render(
       <WorkflowTaskThread
@@ -471,9 +513,15 @@ describe("WorkflowTaskThread", () => {
   });
 
   it("keeps a card's expanded state across streaming updates (no remount)", () => {
+    // The wait card carries input so its detail body has content — a
+    // body-less summary card has no expand gesture at all (stigmer#886).
     const running = () =>
       statesOf(
-        taskState({ taskName: "settled", taskKind: WorkflowTaskKind.wait }),
+        taskState({
+          taskName: "settled",
+          taskKind: WorkflowTaskKind.wait,
+          inputSummary: { duration: "10s" },
+        }),
         taskState({ taskName: "live", status: "running", messagesCount: 1 }),
       );
     const { rerender } = render(
@@ -495,7 +543,11 @@ describe("WorkflowTaskThread", () => {
     rerender(
       <WorkflowTaskThread
         taskStates={statesOf(
-          taskState({ taskName: "settled", taskKind: WorkflowTaskKind.wait }),
+          taskState({
+            taskName: "settled",
+            taskKind: WorkflowTaskKind.wait,
+            inputSummary: { duration: "10s" },
+          }),
           taskState({ taskName: "live", status: "running", messagesCount: 2 }),
         )}
         totalTasks={2}

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,
+    );
+  });
+});