diff --git a/README.md b/README.md
index e4758f9..2150ab3 100644
--- a/README.md
+++ b/README.md
@@ -59,6 +59,27 @@ Out of scope:
   semantics, Tauri, and native projections.
 - Legacy completions or chat completions compatibility.
 
+Modeled in core but deliberately not yet surfaced in the web UI. Each entry
+names its unlock condition so deferral stays distinguishable from neglect:
+
+- Session forking (`parent_session_id`, `fork_point`): modeled and stored,
+  not exposed over the API. Unlocks when a turn-level "fork from here"
+  action is wanted; the turn-grouped transcript is the natural anchor.
+- Image message parts (`MessagePart::Image`): contracts and rendering
+  pipeline accept them; the composer is text-only. Unlocks when a concrete
+  image-input use case shows up in dogfooding.
+- Message editing/deletion (`Message.version`, `deleted_at`,
+  `MessageEvent` audit trail): event-sourced lifecycle exists; the UI
+  renders latest state only. Unlocks if correction workflows matter more
+  than transcript immutability.
+- Soul-view timeline (`SoulSessionEntry`, dual seq sequences): the inspect
+  panel shows memory and compact summaries, not the full "what the agent
+  actually sees" context reconstruction. Unlocks as the inspect panel
+  matures past its v1 form.
+- Effects detail (`SessionEffect` payload/result refs): the inspect panel
+  lists type and status only. Unlocks when hooks start producing effects
+  worth debugging in the UI.
+
 ## Setup
 
 Create `.env` from `.env.example` and fill:
diff --git a/apps/client/soma/web/src/App.tsx b/apps/client/soma/web/src/App.tsx
index c6827ee..999b974 100644
--- a/apps/client/soma/web/src/App.tsx
+++ b/apps/client/soma/web/src/App.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { AppRoot, Grid, GridItem } from "@mini-stim/components";
 import {
   useDebouncedValue,
@@ -7,7 +7,9 @@ import {
   useSessionActions,
   useSessionError,
   useSessionPending,
-  useSessionTimeline,
+  useSessionPreviews,
+  useSessionRuntime,
+  useSessionTurnTimeline,
   useSessions,
 } from "@mini-stim/hooks";
 
@@ -17,17 +19,69 @@ import { SessionRail } from "./components/SessionRail";
 export function App() {
   const sessions = useSessions();
   const selectedSessionId = useSelectedSessionId();
-  const timeline = useSessionTimeline();
+  const timeline = useSessionTurnTimeline();
   const pending = useSessionPending();
   const sessionError = useSessionError();
   const connection = useMessageConnection();
   const actions = useSessionActions();
+  const runtime = useSessionRuntime();
+  const previews = useSessionPreviews();
   const [draft, setDraft] = useState("");
   const [error, setError] = useState<string | null>(null);
+  const [inspecting, setInspecting] = useState(false);
+
+  // The inspect panel is a view over the selected session; switching
+  // sessions returns to the transcript. Opening it refreshes the snapshot
+  // so memory/compacts/effects reflect the turns since selection.
+  useEffect(() => {
+    setInspecting(false);
+  }, [selectedSessionId]);
+
+  function toggleInspect() {
+    if (!inspecting && selectedSessionId) {
+      actions.refreshRuntime(selectedSessionId);
+    }
+    setInspecting((current) => !current);
+  }
 
   const busy = pending > 0;
   const debouncedBusy = useDebouncedValue(busy, { debounceMs: 150 });
-  const visibleError = error ?? sessionError?.message ?? null;
+  // While a turn is running, the header chip names the phase the turn is
+  // actually in instead of a generic "sending".
+  const activity = useMemo(() => {
+    const running = timeline.find((group) => group.turn?.status === "running");
+    if (!running) {
+      return "sending";
+    }
+    if (running.items.some((item) => item.kind === "tool_call" && !item.toolResult)) {
+      return "running tool";
+    }
+    if (
+      running.items.some(
+        (item) => item.kind === "message" && item.message.message.state === "pending",
+      )
+    ) {
+      return "generating";
+    }
+    return "thinking";
+  }, [timeline]);
+  // Turn failures render in place inside the transcript; the composer
+  // notice keeps only errors that no failed turn already carries.
+  const inPlaceErrors = useMemo(
+    () =>
+      new Set(
+        timeline
+          .filter((group) => group.turn?.status === "failed")
+          .map((group) => group.turn?.error_text)
+          .filter((text): text is string => Boolean(text)),
+      ),
+    [timeline],
+  );
+  const sessionErrorMessage =
+    sessionError && !inPlaceErrors.has(sessionError.message)
+      ? sessionError.message
+      : null;
+  const visibleError = error ?? sessionErrorMessage;
   const debouncedConnection = useDebouncedValue(connection, { debounceMs: 150 });
   const selectedTitle = useMemo(() => {
     const selected = sessions.find((session) => session.id === selectedSessionId);
@@ -94,18 +148,23 @@ export function App() {
           busy={busy}
           onCreate={createNewSession}
           onSelect={selectSession}
+          previews={previews}
           selectedSessionId={selectedSessionId}
           sessions={sessions}
         />
         </GridItem>
         <GridItem area="main" tag="main">
         <ChatShell
+          activity={activity}
           busy={debouncedBusy}
           connection={debouncedConnection}
           error={visibleError}
+          inspecting={inspecting}
           onDraftChange={setDraft}
           onSend={send}
           onTitleCommit={updateTitle}
+          onToggleInspect={toggleInspect}
+          runtime={runtime}
           selectedSessionId={selectedSessionId}
           title={selectedTitle}
           titleValue={selectedSession?.title ?? null}
diff --git a/apps/client/soma/web/src/components/ChatHeader.tsx b/apps/client/soma/web/src/components/ChatHeader.tsx
index 1b41c5d..567e474 100644
--- a/apps/client/soma/web/src/components/ChatHeader.tsx
+++ b/apps/client/soma/web/src/components/ChatHeader.tsx
@@ -11,9 +11,12 @@ import {
 } from "@mini-stim/components";
 
 export function ChatHeader(props: {
+  activity: string;
   busy: boolean;
   connection: string;
+  inspecting: boolean;
   onTitleCommit: (title: string | null) => void;
+  onToggleInspect: () => void;
   selectedSessionId: string | null;
   title: string;
   titleValue: string | null;
@@ -84,13 +87,22 @@ export function ChatHeader(props: {
             </Button>
           )}
         </Stack>
-        <Inline gap="sm" wrap>
+        <Inline gap="sm" align="center" wrap>
           {props.busy ? (
-            <Badge size="sm" tone="success">sending</Badge>
+            <Badge size="sm" tone="success">{props.activity}</Badge>
           ) : null}
           {props.connection === "error" ? (
             <Badge size="sm" tone="danger">reconnecting</Badge>
           ) : null}
+          <Button
+            size="sm"
+            variant={props.inspecting ? "outline" : "ghost"}
+            disabled={!props.selectedSessionId}
+            type="button"
+            onClick={props.onToggleInspect}
+          >
+            {props.inspecting ? "Transcript" : "Inspect"}
+          </Button>
         </Inline>
       </Inline>
     </Pane>
diff --git a/apps/client/soma/web/src/components/ChatShell.tsx b/apps/client/soma/web/src/components/ChatShell.tsx
index c2f5d07..61f40fe 100644
--- a/apps/client/soma/web/src/components/ChatShell.tsx
+++ b/apps/client/soma/web/src/components/ChatShell.tsx
@@ -1,16 +1,22 @@
 import { Pane, SectionStackLayout } from "@mini-stim/components";
+import type { SessionRuntimeSnapshot } from "@mini-stim/hooks";
 
 import { ChatHeader } from "./ChatHeader";
 import { Composer } from "./Composer";
+import { InspectPanel } from "./InspectPanel";
 import { Transcript } from "./Transcript";
 
 export function ChatShell(props: {
+  activity: string;
   busy: boolean;
   connection: string;
   error: string | null;
+  inspecting: boolean;
   onDraftChange: (value: string) => void;
   onSend: () => void;
   onTitleCommit: (title: string | null) => void;
+  onToggleInspect: () => void;
+  runtime: SessionRuntimeSnapshot | null;
   selectedSessionId: string | null;
   title: string;
   titleValue: string | null;
@@ -22,15 +28,24 @@ export function ChatShell(props: {
       <SectionStackLayout
         top={(
           <ChatHeader
+            activity={props.activity}
             busy={props.busy}
             connection={props.connection}
+            inspecting={props.inspecting}
             onTitleCommit={props.onTitleCommit}
+            onToggleInspect={props.onToggleInspect}
             selectedSessionId={props.selectedSessionId}
             title={props.title}
             titleValue={props.titleValue}
           />
         )}
-        middle={<Transcript timeline={props.timeline} />}
+        middle={
+          props.inspecting ? (
+            <InspectPanel runtime={props.runtime} />
+          ) : (
+            <Transcript timeline={props.timeline} />
+          )
+        }
         bottom={(
           <Composer
             value={props.draft}
diff --git a/apps/client/soma/web/src/components/InspectPanel.tsx b/apps/client/soma/web/src/components/InspectPanel.tsx
new file mode 100644
index 0000000..e0cb28c
--- /dev/null
+++ b/apps/client/soma/web/src/components/InspectPanel.tsx
@@ -0,0 +1,93 @@
+import {
+  Badge,
+  CodeBlock,
+  Inline,
+  Pane,
+  ScrollArea,
+  Stack,
+  Text,
+  Timestamp,
+} from "@mini-stim/components";
+import type { SessionRuntimeSnapshot } from "@mini-stim/hooks";
+
+export function InspectPanel(props: {
+  runtime: SessionRuntimeSnapshot | null;
+}) {
+  const { runtime } = props;
+  if (!runtime) {
+    return (
+      <Pane padding="lg">
+        <Text tone="muted">No runtime snapshot loaded for this session yet.</Text>
+      </Pane>
+    );
+  }
+
+  const memory = runtime.soul_session?.session_memory.trim() ?? "";
+
+  return (
+    <ScrollArea grow>
+      <Pane padding="lg">
+        <Stack gap="lg">
+          <Stack gap="sm">
+            <Inline justify="between" align="center" gap="sm">
+              <Text size="xs" tone="subtle">SESSION MEMORY</Text>
+              {runtime.soul_session ? (
+                <Text size="xs" tone="subtle">
+                  seen through seq {runtime.soul_session.last_seen_session_seq}
+                </Text>
+              ) : null}
+            </Inline>
+            {memory ? (
+              <CodeBlock>{memory}</CodeBlock>
+            ) : (
+              <Text size="sm" tone="muted">
+                The agent has not written any session memory yet.
+              </Text>
+            )}
+          </Stack>
+
+          <Stack gap="sm">
+            <Text size="xs" tone="subtle">COMPACTS</Text>
+            {runtime.compacts.length ? (
+              runtime.compacts.map((compact) => (
+                <Pane key={compact.id} border="around" padding="md" tone="panel">
+                  <Stack gap="xs">
+                    <Inline justify="between" align="center" wrap gap="sm">
+                      <Text size="xs" tone="subtle">
+                        replaces seq {compact.start_session_seq}–{compact.end_session_seq}
+                      </Text>
+                      <Timestamp value={compact.created_at} size="xs" tone="subtle" />
+                    </Inline>
+                    <Text size="sm">{compact.summary}</Text>
+                  </Stack>
+                </Pane>
+              ))
+            ) : (
+              <Text size="sm" tone="muted">
+                No context compaction has happened in this session.
+              </Text>
+            )}
+          </Stack>
+
+          <Stack gap="sm">
+            <Text size="xs" tone="subtle">EFFECTS</Text>
+            {runtime.effects.length ? (
+              runtime.effects.map((effect) => (
+                <Inline key={effect.id} justify="between" align="center" wrap gap="sm">
+                  <Text size="sm">{effect.effect_type}</Text>
+                  <Badge size="sm" tone={effect.error_text ? "danger" : "neutral"}>
+                    {effect.status}
+                  </Badge>
+                </Inline>
+              ))
+            ) : (
+              <Text size="sm" tone="muted">
+                No hook effects recorded in this session.
+              </Text>
+            )}
+          </Stack>
+        </Stack>
+      </Pane>
+    </ScrollArea>
+  );
+}
diff --git a/apps/client/soma/web/src/components/SessionRail.tsx b/apps/client/soma/web/src/components/SessionRail.tsx
index d2ae79e..a7cd0d6 100644
--- a/apps/client/soma/web/src/components/SessionRail.tsx
+++ b/apps/client/soma/web/src/components/SessionRail.tsx
@@ -17,6 +17,7 @@ export function SessionRail(props: {
   busy: boolean;
   onCreate: () => void;
   onSelect: (sessionId: string) => void;
+  previews: Record<string, string>;
   selectedSessionId: string | null;
   sessions: Session[];
 }) {
@@ -48,7 +49,7 @@ export function SessionRail(props: {
           <Stack gap="xs">
             {props.sessions.map((session) => {
               const selected = session.id === props.selectedSessionId;
-              const label = sessionLabel(session);
+              const label = sessionLabel(session, props.previews[session.id]);
               return (
                 <Button
                   key={session.id}
@@ -83,6 +84,9 @@ export function SessionRail(props: {
   );
 }
 
-function sessionLabel(session: { id: string; title?: string | null }) {
-  return session.title?.trim() || session.id;
+function sessionLabel(
+  session: { id: string; title?: string | null },
+  preview?: string,
+) {
+  return session.title?.trim() || preview || session.id;
 }
diff --git a/apps/client/soma/web/src/components/TimelineItemView.tsx b/apps/client/soma/web/src/components/TimelineItemView.tsx
index d96a21c..dc50419 100644
--- a/apps/client/soma/web/src/components/TimelineItemView.tsx
+++ b/apps/client/soma/web/src/components/TimelineItemView.tsx
@@ -15,6 +15,7 @@ export function TimelineItemView(props: {
 
   if (item.kind === "message") {
     const role = item.message.message.actor_type;
+    const pending = item.message.message.state === "pending";
     return (
       <Surface
         align={roleAlign(role)}
@@ -27,7 +28,11 @@ export function TimelineItemView(props: {
             <Text size="xs" tone="subtle">
               {roleLabel(role)}
             </Text>
-            <Timestamp value={item.createdAt} size="xs" tone="subtle" />
+            {pending ? (
+              <Text size="xs" tone="subtle">generating…</Text>
+            ) : (
+              <Timestamp value={item.createdAt} size="xs" tone="subtle" />
+            )}
           </Inline>
           <Text>{item.message.content_text}</Text>
         </Stack>
diff --git a/apps/client/soma/web/src/components/Transcript.tsx b/apps/client/soma/web/src/components/Transcript.tsx
index 2f7194d..53cfae4 100644
--- a/apps/client/soma/web/src/components/Transcript.tsx
+++ b/apps/client/soma/web/src/components/Transcript.tsx
@@ -1,19 +1,22 @@
 import { Notice, Pane, ScrollArea, Stack, Text } from "@mini-stim/components";
-import type { TimelineItem } from "@mini-stim/hooks";
+import type { TurnGroup } from "@mini-stim/hooks";
 
 import { TimelineItemView } from "./TimelineItemView";
 
 export function Transcript(props: {
-  timeline: TimelineItem[];
+  timeline: TurnGroup[];
 }) {
+  const empty = !props.timeline.some(
+    (group) => group.items.length || group.turn,
+  );
   return (
     <ScrollArea grow>
       <Pane padding="xl">
         <Stack gap="lg">
-          {props.timeline.map((item) => (
-            <TimelineItemView key={item.id} item={item} />
+          {props.timeline.map((group) => (
+            <TurnGroupView key={group.id} group={group} />
           ))}
-          {!props.timeline.length ? (
+          {empty ? (
             <Notice>
               <Text tone="muted">Start a session to see the transcript build here.</Text>
             </Notice>
@@ -23,3 +26,26 @@ export function Transcript(props: {
     </ScrollArea>
   );
 }
+
+function TurnGroupView(props: { group: TurnGroup }) {
+  const { group } = props;
+  const turn = group.turn;
+  return (
+    <Stack gap="lg">
+      {group.items.map((item) => (
+        <TimelineItemView key={item.id} item={item} />
+      ))}
+      {turn?.status === "failed" ? (
+        <Notice tone="danger">
+          <Stack gap="xs">
+            <Text size="xs" tone="subtle">TURN FAILED</Text>
+            <Text>{turn.error_text ?? "The turn failed without an error message."}</Text>
+          </Stack>
+        </Notice>
+      ) : null}
+      {turn?.status === "running" && !group.items.length ? (
+        <Text size="sm" tone="subtle">Working…</Text>
+      ) : null}
+    </Stack>
+  );
+}
diff --git a/packages/hooks/src/index.tsx b/packages/hooks/src/index.tsx
index 2230f20..435e9c7 100644
--- a/packages/hooks/src/index.tsx
+++ b/packages/hooks/src/index.tsx
@@ -20,19 +20,28 @@ import {
   type Session,
   type SessionMessage,
   type SessionProjection,
+  type SessionRuntimeSnapshot,
   type TimelineItem,
+  type TurnGroup,
 } from "@mini-stim/mqueue";
 
 export type {
+  Compact,
   MessageConnectionState,
   MessagePart,
   MqueueError,
   PubAck,
   SantiMqueue,
   Session,
+  SessionEffect,
   SessionMessage,
   SessionProjection,
+  SessionRuntimeSnapshot,
+  SoulSession,
   TimelineItem,
+  Turn,
+  TurnGroup,
+  TurnStatus,
 } from "@mini-stim/mqueue";
 
 interface SantiMqueueProviderProps {
@@ -46,6 +55,7 @@ interface SessionActions {
   create(): PubAck;
   get(sessionId: string): PubAck;
   list(): PubAck;
+  refreshRuntime(sessionId: string): PubAck;
   select(sessionId: string | null): PubAck;
   selectAndGet(sessionId: string): PubAck[];
   send(input: { sessionId?: string | null; content: MessagePart[] }): PubAck;
@@ -114,7 +124,7 @@ export function useSessionMessages(sessionId?: string | null): SessionMessage[]
   return projection.messagesBySessionId[resolvedSessionId] ?? [];
 }
 
-export function useSessionTimeline(sessionId?: string | null): TimelineItem[] {
+export function useSessionTurnTimeline(sessionId?: string | null): TurnGroup[] {
   const mqueue = useSantiMqueue();
   const selectedSessionId = useSelectedSessionId();
   const store = useMemo(() => createMessageStore(mqueue), [mqueue]);
@@ -127,7 +137,43 @@ export function useSessionTimeline(sessionId?: string | null): TimelineItem[] {
   if (!resolvedSessionId) {
     return [];
   }
-  return projection.timelineBySessionId[resolvedSessionId] ?? [];
+  return projection.turnTimelineBySessionId[resolvedSessionId] ?? [];
+}
+
+/**
+ * First user-authored line of each loaded session, keyed by session id.
+ * Only sessions whose messages have been fetched appear; callers fall
+ * back to their own label (title or id) for the rest.
+ */
+export function useSessionPreviews(): Record<string, string> {
+  const projection = useSessionProjection();
+  return useMemo(() => {
+    const previews: Record<string, string> = {};
+    for (const [sessionId, messages] of Object.entries(
+      projection.messagesBySessionId,
+    )) {
+      const first = messages.find(
+        (message) =>
+          message.message.actor_type === "account" &&
+          message.content_text.trim(),
+      );
+      if (first) {
+        previews[sessionId] = first.content_text.trim();
+      }
+    }
+    return previews;
+  }, [projection]);
+}
+
+export function useSessionRuntime(
+  sessionId?: string | null,
+): SessionRuntimeSnapshot | null {
+  const projection = useSessionProjection();
+  const resolvedSessionId = sessionId ?? projection.selectedSessionId;
+  if (!resolvedSessionId) {
+    return null;
+  }
+  return projection.runtimeBySessionId[resolvedSessionId] ?? null;
 }
 
 export function useSessionPending(): number {
@@ -210,6 +256,8 @@ export function useSessionActions(): SessionActions {
       create: () => mqueue.session.pub("create"),
       get: (sessionId: string) => mqueue.session.pub("get", { sessionId }),
       list: () => mqueue.session.pub("list"),
+      refreshRuntime: (sessionId: string) =>
+        mqueue.session.pub("runtime", { sessionId }),
       select: (sessionId: string | null) =>
         mqueue.session.pub("select", { sessionId }),
       selectAndGet: (sessionId: string) => [
diff --git a/packages/mqueue/src/events.ts b/packages/mqueue/src/events.ts
index 0c51b30..8af0ec5 100644
--- a/packages/mqueue/src/events.ts
+++ b/packages/mqueue/src/events.ts
@@ -4,6 +4,7 @@ import type {
   SessionMessage,
   ToolCall,
   ToolResult,
+  Turn,
 } from "@mini-stim/contracts";
 
 import type {
@@ -19,6 +20,7 @@ import type {
   SessionProjection,
   StreamEvent,
   TimelineItem,
+  TurnGroup,
 } from "./types";
 
 const DEFAULT_ACTOR_ID = "account_local";
@@ -197,6 +199,18 @@ export function cloneMessageProjection(value: MessageProjection): MessageProject
         [...items],
       ]),
     ),
+    turnTimelineBySessionId: Object.fromEntries(
+      Object.entries(value.turnTimelineBySessionId).map(([sessionId, groups]) => [
+        sessionId,
+        groups.map((group) => ({ ...group, items: [...group.items] })),
+      ]),
+    ),
+    turnsBySessionId: Object.fromEntries(
+      Object.entries(value.turnsBySessionId).map(([sessionId, turns]) => [
+        sessionId,
+        [...turns],
+      ]),
+    ),
     toolCallsBySessionId: Object.fromEntries(
       Object.entries(value.toolCallsBySessionId).map(([sessionId, calls]) => [
         sessionId,
@@ -212,6 +226,132 @@ export function cloneMessageProjection(value: MessageProjection): MessageProject
   };
 }
 
+export function dedupeTurns(turns: Turn[]): Turn[] {
+  const byId = new Map<string, Turn>();
+  for (const turn of turns) {
+    const existing = byId.get(turn.id);
+    if (!existing || existing.updated_at.localeCompare(turn.updated_at) <= 0) {
+      byId.set(turn.id, turn);
+    }
+  }
+  return [...byId.values()].sort(
+    (left, right) =>
+      left.input_through_session_seq - right.input_through_session_seq ||
+      left.created_at.localeCompare(right.created_at),
+  );
+}
+
+const STREAM_MESSAGE_PREFIX = "stream_";
+
+/**
+ * Group a flat, time-sorted timeline into turn envelopes.
+ *
+ * Attribution rules, strongest first:
+ * - tool_call / paired tool_result: `turn_id` on the call.
+ * - transient streaming message: its id is `stream_<turn_id>` (core emits
+ *   MessageDelta with that synthetic id).
+ * - user message: the turn whose `trigger_ref` is the message id.
+ * - anything else: the turn with the largest `input_through_session_seq`
+ *   that is <= the message's `session_seq` (each turn's appended messages
+ *   sit after its input watermark and before the next turn's).
+ *
+ * Items that resolve to no turn (turns not loaded yet, old data) fall into
+ * envelope-less groups, one per consecutive run, so render order is
+ * preserved and nothing ever fails to render. Turns with no attributed
+ * items (just-started turns) still produce an empty group so the UI can
+ * show a running envelope immediately.
+ */
+export function turnGroups(
+  sessionId: string,
+  items: TimelineItem[],
+  turns: Turn[],
+): TurnGroup[] {
+  const sortedTurns = dedupeTurns(turns);
+  const turnsById = new Map(sortedTurns.map((turn) => [turn.id, turn]));
+  const groupsByTurnId = new Map<string, TurnGroup>();
+  const groups: TurnGroup[] = [];
+  let fallback: TurnGroup | null = null;
+
+  const ensureTurnGroup = (turn: Turn): TurnGroup => {
+    let group = groupsByTurnId.get(turn.id);
+    if (!group) {
+      group = {
+        id: turn.id,
+        sessionId,
+        createdAt: turn.created_at,
+        turn,
+        items: [],
+      };
+      groupsByTurnId.set(turn.id, group);
+      groups.push(group);
+    }
+    return group;
+  };
+
+  for (const item of items) {
+    const turn = attributeItem(item, sortedTurns, turnsById);
+    if (turn) {
+      fallback = null;
+      const group = ensureTurnGroup(turn);
+      group.items.push(item);
+      if (item.createdAt.localeCompare(group.createdAt) < 0) {
+        group.createdAt = item.createdAt;
+      }
+    } else {
+      if (!fallback) {
+        fallback = {
+          id: `ungrouped_${item.id}`,
+          sessionId,
+          createdAt: item.createdAt,
+          items: [],
+        };
+        groups.push(fallback);
+      }
+      fallback.items.push(item);
+    }
+  }
+
+  for (const turn of sortedTurns) {
+    ensureTurnGroup(turn);
+  }
+
+  return groups.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+}
+
+function attributeItem(
+  item: TimelineItem,
+  sortedTurns: Turn[],
+  turnsById: Map<string, Turn>,
+): Turn | undefined {
+  if (item.kind === "tool_call") {
+    return turnsById.get(item.toolCall.turn_id);
+  }
+  if (item.kind === "tool_result") {
+    return item.toolCall ? turnsById.get(item.toolCall.turn_id) : undefined;
+  }
+  const messageId = item.message.message.id;
+  if (messageId.startsWith(STREAM_MESSAGE_PREFIX)) {
+    const turn = turnsById.get(messageId.slice(STREAM_MESSAGE_PREFIX.length));
+    if (turn) {
+      return turn;
+    }
+  }
+  const byTrigger = sortedTurns.find((turn) => turn.trigger_ref === messageId);
+  if (byTrigger) {
+    return byTrigger;
+  }
+  const seq = item.message.relation.session_seq;
+  let candidate: Turn | undefined;
+  for (const turn of sortedTurns) {
+    if (turn.input_through_session_seq <= seq) {
+      candidate = turn;
+    } else {
+      break;
+    }
+  }
+  return candidate;
+}
+
 export function dedupeToolCalls(calls: ToolCall[]): ToolCall[] {
   return [...new Map(calls.map((call) => [call.id, call])).values()].sort(
     (left, right) => left.created_at.localeCompare(right.created_at),
diff --git a/packages/mqueue/src/index.ts b/packages/mqueue/src/index.ts
index cbb5784..82449a5 100644
--- a/packages/mqueue/src/index.ts
+++ b/packages/mqueue/src/index.ts
@@ -15,22 +15,18 @@ import {
 } from "@mini-stim/contracts";
 
 import {
-  appendText,
   cloneMessageProjection,
   cloneProjection,
   dedupeMessages,
-  dedupeToolCalls,
-  dedupeToolResults,
   dispatchMessage,
   dispatchSession,
   expectStatus,
   messageEvent,
   normalizeError,
   sessionEvent,
-  timelineItems,
-  transientMessage,
   validateSessionPayload,
 } from "./events";
+import { createProjectionWriter } from "./projection";
 import { openSessionStream } from "./stream";
 import type {
   MessageConnectionState,
@@ -51,9 +47,11 @@ import type {
   ToolCall,
   ToolResult,
   TimelineItem,
+  Turn,
 } from "./types";
 
 export type {
+  Compact,
   MessageConnectionState,
   MessageDeltaPayload,
   MessageEvent,
@@ -67,16 +65,22 @@ export type {
   SantiWindow,
   Session,
   SessionAction,
+  SessionEffect,
   SessionEvent,
   SessionMqueue,
   SessionMessage,
   SessionPayloads,
   SessionPhase,
   SessionProjection,
+  SessionRuntimeSnapshot,
   SessionSubOptions,
+  SoulSession,
   TimelineItem,
   ToolCall,
   ToolResult,
+  Turn,
+  TurnGroup,
+  TurnStatus,
 } from "./types";
 
 declare global {
@@ -113,12 +117,23 @@ function createMqueueCore(target: Window): SantiMqueue {
   const messageState: MessageProjection = {
     messagesBySessionId: {},
     timelineBySessionId: {},
+    turnTimelineBySessionId: {},
+    turnsBySessionId: {},
     toolCallsBySessionId: {},
     toolResultsBySessionId: {},
     connectionBySessionId: {},
   };
   let activeSessionId: string | null = null;
   let eventSource: EventSource | null = null;
+  const {
+    applyDelta,
+    markTurnFailed,
+    removeTransient,
+    setMessageProjection,
+    upsertMessages,
+    upsertTools,
+    upsertTurns,
+  } = createProjectionWriter(state, messageState);
 
   const session: SessionMqueue = { pub, sub: subSession, snapshot };
   const message: MessageMqueue = { sub: subMessage, snapshot: messageSnapshot };
@@ -299,6 +314,7 @@ function createMqueueCore(target: Window): SantiMqueue {
           200,
         ) as SessionRuntimeSnapshot;
         state.runtimeBySessionId[runtimePayload.sessionId] = runtime;
+        upsertTurns(runtimePayload.sessionId, runtime.turns);
         upsertTools(runtimePayload.sessionId, runtime.tool_calls, runtime.tool_results);
         emitMessageProjection(runtimePayload.sessionId);
         dispatchSession(target, sessionEvent(action, "committed", runtime, "http"));
@@ -344,6 +360,7 @@ function createMqueueCore(target: Window): SantiMqueue {
       response.user_message,
       response.assistant_message,
     ]);
+    upsertTurns(response.session.id, [response.turn]);
     upsertTools(response.session.id, response.tool_calls, response.tool_results);
     state.messages = state.messagesBySessionId[response.session.id];
     emitMessageProjection(response.session.id);
@@ -401,16 +418,21 @@ function createMqueueCore(target: Window): SantiMqueue {
         dispatchMessage(target, messageEvent("tool_result", sessionId, payload, "sse"));
         emitMessageProjection(sessionId);
       },
+      turnStarted: (payload) => {
+        upsertTurns(sessionId, [payload.turn]);
+        dispatchMessage(target, messageEvent("turn_started", sessionId, payload, "sse"));
+        emitMessageProjection(sessionId);
+      },
       turnFailed: (payload) => {
-        const failure = { code: "turn_failed", message: payload.error };
-        state.error = failure;
+        markTurnFailed(sessionId, payload.turn_id, payload.error);
         dispatchMessage(
           target,
           messageEvent("failed", sessionId, payload, "sse", {
-            error: failure,
+            error: { code: "turn_failed", message: payload.error },
           }),
         );
         emitProjection();
+        emitMessageProjection(sessionId);
       },
     });
   }
@@ -434,65 +456,10 @@ function createMqueueCore(target: Window): SantiMqueue {
     emitMessageProjection(sessionId);
   }
 
-  function applyDelta(sessionId: string, payload: MessageDeltaPayload) {
-    const existing = state.messagesBySessionId[sessionId] ?? [];
-    const index = existing.findIndex((message) => message.message.id === payload.message_id);
-    if (index === -1) {
-      state.messagesBySessionId[sessionId] = [...existing, transientMessage(sessionId, payload)];
-    } else {
-      const current = existing[index];
-      state.messagesBySessionId[sessionId] = [
-        ...existing.slice(0, index),
-        appendText(current, payload.text),
-        ...existing.slice(index + 1),
-      ];
-    }
-    if (state.selectedSessionId === sessionId) {
-      state.messages = state.messagesBySessionId[sessionId];
-    }
-    setMessageProjection(sessionId);
-  }
 
-  function removeTransient(sessionId: string, turnId: string) {
-    const transientId = `stream_${turnId}`;
-    state.messagesBySessionId[sessionId] = (state.messagesBySessionId[sessionId] ?? []).filter(
-      (message) => message.message.id !== transientId,
-    );
-  }
 
-  function upsertMessages(sessionId: string, messages: SessionMessage[]) {
-    state.messagesBySessionId[sessionId] = dedupeMessages([
-      ...(state.messagesBySessionId[sessionId] ?? []),
-      ...messages,
-    ]);
-    if (state.selectedSessionId === sessionId) {
-      state.messages = state.messagesBySessionId[sessionId];
-    }
-    setMessageProjection(sessionId);
-  }
 
-  function upsertTools(sessionId: string, calls: ToolCall[], results: ToolResult[]) {
-    messageState.toolCallsBySessionId[sessionId] = dedupeToolCalls([
-      ...(messageState.toolCallsBySessionId[sessionId] ?? []),
-      ...calls,
-    ]);
-    messageState.toolResultsBySessionId[sessionId] = dedupeToolResults([
-      ...(messageState.toolResultsBySessionId[sessionId] ?? []),
-      ...results,
-    ]);
-    setMessageProjection(sessionId);
-  }
 
-  function setMessageProjection(sessionId: string) {
-    const messages = state.messagesBySessionId[sessionId] ?? [];
-    const calls = messageState.toolCallsBySessionId[sessionId] ?? [];
-    const results = messageState.toolResultsBySessionId[sessionId] ?? [];
-    messageState.messagesBySessionId[sessionId] = messages;
-    messageState.timelineBySessionId[sessionId] = timelineItems(
-      sessionId,
-      messages,
-      calls,
-      results,
-    );
-  }
+
+
 }
diff --git a/packages/mqueue/src/projection.ts b/packages/mqueue/src/projection.ts
new file mode 100644
index 0000000..b8d0e22
--- /dev/null
+++ b/packages/mqueue/src/projection.ts
@@ -0,0 +1,129 @@
+import {
+  appendText,
+  dedupeMessages,
+  dedupeToolCalls,
+  dedupeToolResults,
+  dedupeTurns,
+  timelineItems,
+  transientMessage,
+  turnGroups,
+} from "./events";
+import type {
+  MessageDeltaPayload,
+  MessageProjection,
+  SessionMessage,
+  SessionProjection,
+  ToolCall,
+  ToolResult,
+  Turn,
+} from "./types";
+
+/**
+ * Mutation surface over the two projection states. Owns every write that
+ * must keep the per-session message list, flat timeline, and turn-grouped
+ * timeline consistent with each other.
+ */
+export function createProjectionWriter(
+  state: SessionProjection,
+  messageState: MessageProjection,
+) {
+  return {
+    applyDelta,
+    markTurnFailed,
+    removeTransient,
+    setMessageProjection,
+    upsertMessages,
+    upsertTools,
+    upsertTurns,
+  };
+
+  function applyDelta(sessionId: string, payload: MessageDeltaPayload) {
+    const existing = state.messagesBySessionId[sessionId] ?? [];
+    const index = existing.findIndex((message) => message.message.id === payload.message_id);
+    if (index === -1) {
+      state.messagesBySessionId[sessionId] = [...existing, transientMessage(sessionId, payload)];
+    } else {
+      const current = existing[index];
+      state.messagesBySessionId[sessionId] = [
+        ...existing.slice(0, index),
+        appendText(current, payload.text),
+        ...existing.slice(index + 1),
+      ];
+    }
+    if (state.selectedSessionId === sessionId) {
+      state.messages = state.messagesBySessionId[sessionId];
+    }
+    setMessageProjection(sessionId);
+  }
+
+  function removeTransient(sessionId: string, turnId: string) {
+    const transientId = `stream_${turnId}`;
+    state.messagesBySessionId[sessionId] = (state.messagesBySessionId[sessionId] ?? []).filter(
+      (message) => message.message.id !== transientId,
+    );
+  }
+
+  function upsertMessages(sessionId: string, messages: SessionMessage[]) {
+    state.messagesBySessionId[sessionId] = dedupeMessages([
+      ...(state.messagesBySessionId[sessionId] ?? []),
+      ...messages,
+    ]);
+    if (state.selectedSessionId === sessionId) {
+      state.messages = state.messagesBySessionId[sessionId];
+    }
+    setMessageProjection(sessionId);
+  }
+
+  function upsertTurns(sessionId: string, turns: Turn[]) {
+    messageState.turnsBySessionId[sessionId] = dedupeTurns([
+      ...(messageState.turnsBySessionId[sessionId] ?? []),
+      ...turns,
+    ]);
+    setMessageProjection(sessionId);
+  }
+
+  function markTurnFailed(sessionId: string, turnId: string, error: string) {
+    const turns = messageState.turnsBySessionId[sessionId] ?? [];
+    const index = turns.findIndex((turn) => turn.id === turnId);
+    if (index === -1) {
+      return;
+    }
+    const failed: Turn = {
+      ...turns[index],
+      status: "failed",
+      error_text: error,
+    };
+    messageState.turnsBySessionId[sessionId] = [
+      ...turns.slice(0, index),
+      failed,
+      ...turns.slice(index + 1),
+    ];
+    setMessageProjection(sessionId);
+  }
+
+  function upsertTools(sessionId: string, calls: ToolCall[], results: ToolResult[]) {
+    messageState.toolCallsBySessionId[sessionId] = dedupeToolCalls([
+      ...(messageState.toolCallsBySessionId[sessionId] ?? []),
+      ...calls,
+    ]);
+    messageState.toolResultsBySessionId[sessionId] = dedupeToolResults([
+      ...(messageState.toolResultsBySessionId[sessionId] ?? []),
+      ...results,
+    ]);
+    setMessageProjection(sessionId);
+  }
+
+  function setMessageProjection(sessionId: string) {
+    const messages = state.messagesBySessionId[sessionId] ?? [];
+    const calls = messageState.toolCallsBySessionId[sessionId] ?? [];
+    const results = messageState.toolResultsBySessionId[sessionId] ?? [];
+    messageState.messagesBySessionId[sessionId] = messages;
+    const timeline = timelineItems(sessionId, messages, calls, results);
+    messageState.timelineBySessionId[sessionId] = timeline;
+    messageState.turnTimelineBySessionId[sessionId] = turnGroups(
+      sessionId,
+      timeline,
+      messageState.turnsBySessionId[sessionId] ?? [],
+    );
+  }
+}
diff --git a/packages/mqueue/src/stream.ts b/packages/mqueue/src/stream.ts
index 6ea2cc2..352a9b4 100644
--- a/packages/mqueue/src/stream.ts
+++ b/packages/mqueue/src/stream.ts
@@ -4,6 +4,7 @@ import type {
   SessionMessage,
   ToolCall,
   ToolResult,
+  Turn,
   StreamPayload,
 } from "./types";
 
@@ -19,6 +20,7 @@ export interface SessionStreamHandlers {
   }): void;
   toolCall(payload: { type: "tool_call_created"; tool_call: ToolCall }): void;
   toolResult(payload: { type: "tool_result_created"; tool_result: ToolResult }): void;
+  turnStarted(payload: { type: "turn_started"; turn: Turn }): void;
   turnFailed(payload: { type: "turn_failed"; turn_id: string; error: string }): void;
 }
 
@@ -34,6 +36,7 @@ export function openSessionStream(
   listen(source, "message_completed", "message_completed", handlers.messageCompleted);
   listen(source, "tool_call_created", "tool_call_created", handlers.toolCall);
   listen(source, "tool_result_created", "tool_result_created", handlers.toolResult);
+  listen(source, "turn_started", "turn_started", handlers.turnStarted);
   listen(source, "turn_failed", "turn_failed", handlers.turnFailed);
   return source;
 }
diff --git a/packages/mqueue/src/types.ts b/packages/mqueue/src/types.ts
index fe6ceb0..1e16ee6 100644
--- a/packages/mqueue/src/types.ts
+++ b/packages/mqueue/src/types.ts
@@ -5,15 +5,23 @@ import type {
   SessionRuntimeSnapshot,
   ToolCall,
   ToolResult,
+  Turn,
+  TurnStatus,
   UpdateSessionRequest,
 } from "@mini-stim/contracts";
 
 export type {
+  Compact,
   MessagePart,
   Session,
+  SessionEffect,
   SessionMessage,
+  SessionRuntimeSnapshot,
+  SoulSession,
   ToolCall,
   ToolResult,
+  Turn,
+  TurnStatus,
 } from "@mini-stim/contracts";
 
 export type SessionAction =
@@ -70,6 +78,7 @@ export type MessagePhase =
   | "completed"
   | "tool_call"
   | "tool_result"
+  | "turn_started"
   | "failed"
   | "projection";
 
@@ -78,11 +87,24 @@ export type MessageConnectionState = "closed" | "connecting" | "open" | "error";
 export interface MessageProjection {
   messagesBySessionId: Record<string, SessionMessage[]>;
   timelineBySessionId: Record<string, TimelineItem[]>;
+  turnTimelineBySessionId: Record<string, TurnGroup[]>;
+  turnsBySessionId: Record<string, Turn[]>;
   toolCallsBySessionId: Record<string, ToolCall[]>;
   toolResultsBySessionId: Record<string, ToolResult[]>;
   connectionBySessionId: Record<string, MessageConnectionState>;
 }
 
+export interface TurnGroup {
+  /** Turn id, or `ungrouped_<first item id>` for the fallback group. */
+  id: string;
+  sessionId: string;
+  /** Sort key: the earliest createdAt among the turn and its items. */
+  createdAt: string;
+  /** Absent for the fallback group holding items with no resolvable turn. */
+  turn?: Turn;
+  items: TimelineItem[];
+}
+
 export type TimelineItem =
   | {
       kind: "message";
@@ -196,7 +218,7 @@ export type StreamPayload =
   | { type: "message_completed"; turn_id: string; message: SessionMessage }
   | { type: "tool_call_created"; tool_call: ToolCall }
   | { type: "tool_result_created"; tool_result: ToolResult }
-  | { type: "turn_started"; turn: unknown }
+  | { type: "turn_started"; turn: Turn }
   | { type: "turn_failed"; turn_id: string; error: string };
 
 export interface MessageDeltaPayload {