ompchamber 1.2.1 → 2.0.1

package/src/client/hooks/chat/btw/intercept.ts

@@ -7,8 +7,13 @@
  * `/btw [question]` typed into the main composer is the side-question entry
  * point, not chat text: the panel owns the token (omp's `/btw` is TUI-only, so
  * nothing downstream would understand it). This module is the whole
- * interception — recognize the command, carry the composer's images across as
- * provider payloads, and hand the question to the panel over `omp:btw`.
+ * interception — recognize the command and hand it, with the composer's
+ * attachments, to the panel over `omp:btw`.
+ *
+ * The attachments cross as the composer's own `Attachment` objects, not as
+ * pre-built provider payloads: the side session accepts the same shapes the chat
+ * does (images as payloads, text files inlined into the prompt), and it makes
+ * that split itself — from the fields the attach step already filled in.
  *
  * It lives beside the rest of the client-side btw state (`hooks/chat/btw/`)
  * rather than in the send handler: the attachment read goes through the shared
@@ -16,7 +21,6 @@
  */
 
 import type { Attachment } from '@/shared/types';
-import { attachmentImage } from '@/shared/lib/chat/attachments';
 
 /** A bare `/btw` opens the form on the current history; anything after it is
  *  the first question. Case-insensitive, because omp's command tokens are. */
@@ -30,13 +34,9 @@ export function dispatchBtwCommand(text: string, attachments: Attachment[]): boo
   const match = BTW_COMMAND_RE.exec(text);
   if (!match) return false;
 
-  const images = attachments
-    .map((attachment) => attachmentImage(attachment))
-    .filter((image): image is NonNullable<typeof image> => image !== null);
-
   window.dispatchEvent(
     new CustomEvent('omp:btw', {
-      detail: { question: match[1]?.trim() ?? '', ...(images.length ? { images } : {}) },
+      detail: { question: match[1]?.trim() ?? '', ...(attachments.length ? { attachments } : {}) },
     }),
   );
   return true;

package/src/client/hooks/chat/btw/mode.ts

@@ -16,17 +16,26 @@
  * arrived with the command is asked immediately, which is what the TUI does.
  */
 
-import { useCallback } from 'preact/hooks';
-import type { BtwState, BtwTopic } from '@/shared/types';
-import { useBtwSession, type BtwImage, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
+import { useCallback, useState } from 'preact/hooks';
+import type { Attachment, BtwDialog, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { useBtwSession, type BtwFirstQuestionPicks, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
 import { useChamberEvent } from '@/client/hooks/ui/window-event';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { useSearchParams } from '@/client/lib/router/search-params';
 import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
+import { normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
+import { readChamberSetting } from '@/shared/lib/settings/client';
 
 /** Question sent when a question arrived carrying only images. */
 const ATTACHMENT_ONLY_QUESTION = 'Describe the attached image.';
 
+/** The composer's persisted access pick, for a topic that has none yet. */
+function readAccessMode(appSettings: Record<string, unknown>): ApprovalMode {
+  return normalizeApprovalMode(readChamberSetting<unknown>('omp_access_mode', appSettings));
+}
+
 export interface BtwMode {
   open: boolean;
   topics: BtwTopic[];
@@ -35,9 +44,16 @@ export interface BtwMode {
   runningTopicId: string | null;
   /** A command is still in flight — the panel holds its actions meanwhile. */
   busy: boolean;
-  /** Partial answer of the running turn, when it belongs to the active topic. */
-  liveAnswer: string;
+  /** The running turn's conversation, chat-shaped; empty when none. */
+  liveMessages: ChatMessageData[];
+  /** What that turn is doing, for the panel's indicator (side stream's own). */
+  liveVerb?: string;
   error: string | null;
+  /** Ask/approval dialogs the side child is blocked on, oldest first. */
+  dialogs: BtwDialog[];
+  /** Access mode the active topic's child runs under. */
+  accessMode: ApprovalMode;
+  thinkingLevel: string;
   askDraft: string;
   followUpDraft: string;
   setAskDraft: (value: string) => void;
@@ -51,8 +67,13 @@ export interface BtwMode {
   /** Submit the ask card: a question of its own. */
   submitAsk: () => void;
   /** Submit the side session's composer: a follow-up to the active topic. */
-  submitFollowUp: (question: string, images?: BtwImage[]) => void;
+  submitFollowUp: (question: string, attachments?: Attachment[]) => void;
   abort: () => void;
+  /** Re-target the side child's model (applies to the running turn). */
+  setModel: (provider: string, modelId: string) => void;
+  setThinkingLevel: (level: string) => void;
+  setAccessMode: (mode: ApprovalMode) => void;
+  respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => void;
   /** Returns the session id to open, or null when promotion was refused. */
   promote: () => Promise<string | null>;
   removeTopic: (topicId: string) => void;
@@ -61,7 +82,18 @@ export interface BtwMode {
 }
 
 export function useBtwMode(sessionId: string | null, appSettings: Record<string, unknown>): BtwMode {
-  const [open, setOpen] = useSessionState<boolean>('chat.btwOpen', false);
+  /**
+   * Whether the panel is on screen. Deliberately NOT restored from session
+   * state: a panel that reopens itself on every load leaves the user with no
+   * chat composer and a field they did not ask for, and a `/btw` typed into
+   * that field becomes a real question to the model. The panel is a mode the
+   * user enters, so every load starts in the chat.
+   *
+   * The drafts and the selected topic DO persist (`chat.btwAsk` and friends):
+   * leaving and re-entering the panel loses nothing, which is what those slots
+   * are for.
+   */
+  const [open, setOpen] = useState(false);
   const [askDraft, setAskDraft] = useSessionState<string>('chat.btwAsk', '');
   const [followUpDraft, setFollowUpDraft] = useSessionState<string>('chat.btwFollowUp', '');
   const [selectedTopicId, setSelectedTopicId] = useSessionState<string | null>('chat.btwTopicId', null);
@@ -79,6 +111,26 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
   const runningTopicId = session.state?.runningTopicId ?? null;
   const live: BtwLiveAnswer | null = session.live && session.live.topicId === activeTopic?.id ? session.live : null;
 
+  /**
+   * What the running turn is doing, for the panel's indicator.
+   *
+   * The verb is the SERVER's, derived from the side child's own frames
+   * (`describeAssistantPhase` / `describeToolActivity` over `btw_activity`) —
+   * never the chat's, whose run is a different process. Until the child reports
+   * one the turn is still working, which is all the panel can honestly say.
+   */
+  const liveVerb = live?.activity || (runningTopicId ? PHASE_VERBS.sideQuestion : undefined);
+
+  /**
+   * Composer picks made before a topic exists. They are per-session UI state
+   * rather than props, because the form must show what the FIRST question will
+   * actually run with — the topic that would otherwise own these values has not
+   * been created yet.
+   */
+  const [pendingModel, setPendingModel] = useSessionState<BtwFirstQuestionPicks['model'] | null>('chat.btwModel', null);
+  const [pendingThinking, setPendingThinking] = useSessionState<string>('chat.btwThinking', 'auto');
+  const [pendingAccess, setPendingAccess] = useSessionState<ApprovalMode | null>('chat.btwAccess', null);
+
   const selectNewest = useCallback(
     (next: BtwState | null) => {
       if (!next) return;
@@ -90,30 +142,45 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
   // `/btw [question]` hands the question over; a bare `/btw` only opens the
   // form, which is the history view.
   useChamberEvent('omp:btw', (event) => {
-    const detail = (event as CustomEvent<{ question?: string; images?: BtwImage[] }>).detail;
+    const detail = (event as CustomEvent<{ question?: string; attachments?: Attachment[] }>).detail;
     const question = detail?.question?.trim();
     setOpen(true);
-    if (question || detail?.images?.length) {
+    if (question || detail?.attachments?.length) {
       setAskDraft('');
-      void session.ask(question || ATTACHMENT_ONLY_QUESTION, detail?.images).then(selectNewest);
+      void session.ask(question || ATTACHMENT_ONLY_QUESTION, detail?.attachments).then(selectNewest);
     }
   });
 
+  /**
+   * What the next FIRST question will run with: the composer's picks until a
+   * topic exists, then that topic's own settings. Every setter below writes to
+   * the topic when there is one and to this pending slot when there is not —
+   * a pick that only reached the UI would silently not apply.
+   */
+  const firstQuestionPicks = useCallback(
+    (): BtwFirstQuestionPicks => ({
+      ...(pendingModel ? { model: pendingModel } : {}),
+      ...(pendingThinking && pendingThinking !== 'auto' ? { thinkingLevel: pendingThinking } : {}),
+      ...(pendingAccess ? { approvalMode: pendingAccess } : {}),
+    }),
+    [pendingModel, pendingThinking, pendingAccess],
+  );
+
   const submitAsk = useCallback(() => {
     const question = askDraft.trim();
     if (!question) return;
     setAskDraft('');
-    void session.ask(question).then(selectNewest);
-  }, [askDraft, session, setAskDraft, selectNewest]);
+    void session.ask(question, undefined, undefined, firstQuestionPicks()).then(selectNewest);
+  }, [askDraft, session, setAskDraft, selectNewest, firstQuestionPicks]);
 
   const submitFollowUp = useCallback(
-    (question: string, images?: BtwImage[]) => {
+    (question: string, attachments?: Attachment[]) => {
       const text = question.trim();
-      if (!text && !images?.length) return;
+      if (!text && !attachments?.length) return;
       setFollowUpDraft('');
       // With no topic in view yet, the side session's first question is the
       // topic — there is nothing to follow up on.
-      void session.ask(text || ATTACHMENT_ONLY_QUESTION, images, activeTopic?.id).then((next) => {
+      void session.ask(text || ATTACHMENT_ONLY_QUESTION, attachments, activeTopic?.id).then((next) => {
         if (!activeTopic) selectNewest(next);
       });
     },
@@ -150,8 +217,15 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     activeTopic,
     runningTopicId,
     busy: session.busy,
-    liveAnswer: live ? live.text : '',
+    liveMessages: live ? live.messages : [],
+    liveVerb,
     error: session.error,
+    dialogs: session.state?.dialogs ?? [],
+    // Before a topic exists the composer's own picks are what the next question
+    // will run with, so they are what the controls must show — and after it,
+    // the topic's own settings (which the pick was written to).
+    accessMode: activeTopic?.approvalMode ?? pendingAccess ?? readAccessMode(appSettings),
+    thinkingLevel: activeTopic?.thinkingLevel ?? pendingThinking,
     askDraft,
     followUpDraft,
     setAskDraft,
@@ -168,6 +242,27 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     abort: () => {
       if (runningTopicId) void session.abort(runningTopicId);
     },
+    setModel: (provider: string, modelId: string) => {
+      if (!activeTopic) {
+        setPendingModel({ provider, id: modelId });
+        return;
+      }
+      void session.setModel(activeTopic.id, provider, modelId);
+    },
+    setThinkingLevel: (level: string) => {
+      setPendingThinking(level);
+      if (!activeTopic) return;
+      void session.setThinkingLevel(activeTopic.id, level);
+    },
+    setAccessMode: (mode: ApprovalMode) => {
+      setPendingAccess(mode);
+      if (!activeTopic) return;
+      void session.setAccessMode(activeTopic.id, mode);
+    },
+    respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
+      if (!activeTopic) return;
+      void session.respondToDialog(activeTopic.id, id, response);
+    },
     promote,
     removeTopic,
     selectTopic: (topicId: string) => {

package/src/client/hooks/chat/composer/index.ts

@@ -13,6 +13,12 @@ export interface UseComposerTriggerOptions {
   disabled?: boolean;
   /** Workspace root to scope `@` file mentions to (null → app root). */
   rootPath?: string | null;
+  /**
+   * Whether the popup may open at all. A composer with no completable surface
+   * (the side-question form) turns it off so a stray `@` or `/` cannot open an
+   * empty list over its text.
+   */
+  enabled?: boolean;
 }
 
 export interface ComposerTriggerController {
@@ -55,7 +61,7 @@ function shouldOpen(trigger: ComposerTrigger | null, matches: ComposerMatchItem[
 
 /** Orchestrates the composer `@`-mention / `/`-command autocomplete flow. */
 export function useComposerTrigger(options: UseComposerTriggerOptions): ComposerTriggerController {
-  const { value, setValue, textareaRef, disabled = false, rootPath } = options;
+  const { value, setValue, textareaRef, disabled = false, rootPath, enabled = true } = options;
 
   const [trigger, setTrigger] = useState<ComposerTrigger | null>(null);
   const [activeIndex, setActiveIndexState] = useState(0);
@@ -77,7 +83,7 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
 
   const optionId = useCallback((index: number) => `${listboxId}-option-${index}`, [listboxId]);
 
-  const open = shouldOpen(trigger, matches);
+  const open = enabled && shouldOpen(trigger, matches);
 
   const close = useCallback(() => {
     setTrigger(null);
@@ -109,14 +115,14 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
       }
 
       setValue(text);
-      if (disabled) {
+      if (disabled || !enabled) {
         close();
         return;
       }
       setTrigger(detectComposerTrigger(text, caret));
       setActiveIndexState(0);
     },
-    [setValue, close, disabled],
+    [setValue, close, disabled, enabled],
   );
 
   const selectItem = useCallback(

package/src/client/hooks/chat/timeline/access-mode.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Access-control (approval) mode for the composer: a global, persisted user
+ * preference, unlike the per-session model/thinking picks. It hydrates from
+ * appSettings at first paint and is mirrored into a ref so the send path reads
+ * the latest value without re-creating `executeSend`. Extracted from
+ * useChatTimeline so that hook stays under the repo's per-file size ceiling.
+ */
+
+import { useCallback, useRef, useState } from 'preact/hooks';
+import { ACCESS_MODE_SETTING_KEY, normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { writeSetting } from '@/shared/lib/settings/client';
+
+export interface ChatTimelineAccessMode {
+  accessMode: ApprovalMode;
+  /** Live value for callbacks created once (send, queue delivery). */
+  accessModeRef: { current: ApprovalMode };
+  setAccessMode: (mode: ApprovalMode) => void;
+}
+
+export function useChatTimelineAccessMode(appSettings: Record<string, any>): ChatTimelineAccessMode {
+  const [accessMode, setAccessModeState] = useState<ApprovalMode>(() => normalizeApprovalMode(appSettings.omp_access_mode));
+  const accessModeRef = useRef<ApprovalMode>(accessMode);
+  accessModeRef.current = accessMode;
+
+  const setAccessMode = useCallback((mode: ApprovalMode) => {
+    setAccessModeState(mode);
+    accessModeRef.current = mode;
+    // Persist the last selection; the server reads this key as the spawn-time
+    // default. Fire-and-forget: the in-memory value is already authoritative
+    // for this session's requests, which carry it explicitly.
+    writeSetting(ACCESS_MODE_SETTING_KEY, mode);
+  }, []);
+
+  return { accessMode, accessModeRef, setAccessMode };
+}

package/src/client/hooks/chat/timeline/ask-frames.test.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The ask/approval routing split, and the one thing it must never do: paint a
+ * dialog as a modal and then take it back.
+ *
+ * On session open the pending dialogs are replayed from the agent-state probe
+ * (which answers out of the wrapper's local flags) long before the session
+ * JSONL lands, so every replayed frame looks unowned while `messages` is still
+ * empty — while the ask card that owns it is one fetch away. Deciding "no card
+ * owns this" during that window flashed the ask modal on every switch to a
+ * session parked on a question. These pin the hold, and that it never turns
+ * into a silently dropped question.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ChatMessageData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import { splitAskFrames } from '@/client/hooks/chat/timeline/ask-frames';
+
+/** An assistant turn whose `ask` tool call asked `questions`, as the JSONL and
+ *  the live stream both deliver it. */
+function askHistory(questions: string[]): ChatMessageData[] {
+  return [
+    {
+      id: 'msg-ask',
+      role: 'ai',
+      content: '',
+      toolCalls: [
+        {
+          id: 'call_ask',
+          type: 'ask',
+          name: 'ask',
+          title: 'ask',
+          input: { questions: questions.map((question) => ({ question, options: [{ label: 'A' }, { label: 'B' }] })) },
+        },
+      ],
+    },
+  ];
+}
+
+function selectFrame(id: string, title: string): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'select', title, options: ['A (Recommended)', 'B', 'Other (type your own)'] };
+}
+
+function confirmFrame(id: string, title: string): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'confirm', title };
+}
+
+describe('splitAskFrames', () => {
+  test('a question dialog is claimed by the ask card, not handed to the modal', () => {
+    const frame = selectFrame('f1', 'Which language?');
+    const split = splitAskFrames(askHistory(['Which language?']), [frame], true);
+
+    expect(split.framesByTool.get('call_ask')?.[0]?.map((held) => held.id)).toEqual(['f1']);
+    expect(split.modalRequest).toBeNull();
+  });
+
+  test('the modal is held while the session history is still loading', () => {
+    const question = selectFrame('f1', 'Which language?');
+    const gate = confirmFrame('g1', 'Run bash?');
+
+    // The regression: the frame has been replayed, its tool call has not.
+    expect(splitAskFrames([], [question], false)).toEqual({ framesByTool: new Map(), modalRequest: null });
+    // The hold is uniform — a gate cannot be told from an ask before history
+    // either, and it is re-decided the moment the history settles.
+    expect(splitAskFrames([], [gate], false).modalRequest).toBeNull();
+  });
+
+  test('once the history has settled an unclaimed dialog stays answerable', () => {
+    const frame = selectFrame('f1', 'Which language?');
+    expect(splitAskFrames([], [frame], true).modalRequest).toBe(frame);
+  });
+
+  test('an approval gate keeps the modal beside a claimed question', () => {
+    const question = selectFrame('f1', 'Which language?');
+    const gate = confirmFrame('g1', 'Run bash?');
+    const split = splitAskFrames(askHistory(['Which language?']), [question, gate], true);
+
+    expect(split.framesByTool.get('call_ask')?.[0]?.map((held) => held.id)).toEqual(['f1']);
+    expect(split.modalRequest).toBe(gate);
+  });
+});

package/src/client/hooks/chat/timeline/ask-frames.ts

@@ -18,6 +18,17 @@
  * Any frame left over is modal material — including an ask-shaped frame whose
  * tool call the timeline has not seen, which must stay answerable rather than
  * silently vanish.
+ *
+ * That fallback must wait for the session's own history, though. Ownership is
+ * decided against the ask tool calls in `messages`, and on session open the
+ * pending dialogs are replayed from the agent-state probe — which answers out
+ * of the wrapper's local flags — long before the JSONL fetch lands. Every
+ * replayed frame therefore looks unowned for that window, and rendering one as
+ * a modal painted the question on screen and yanked it away the instant the
+ * timeline arrived and its card claimed it: the flash seen when switching to a
+ * session parked on an ask. `historyLoaded` holds the modal — never the card
+ * claim — until there is a timeline to decide against; a frame no card claims
+ * after that still gets its modal.
  */
 
 import { createContext, useContext } from 'preact/compat';
@@ -51,6 +62,9 @@ export function useAskFrames(): AskFramesHandle {
 export function splitAskFrames(
   messages: ChatMessageData[],
   pending: ExtensionUiDialogRequest[],
+  /** Whether `messages` is the session's committed history yet (see the module
+   *  note). False holds the modal back; it never blocks a card from claiming. */
+  historyLoaded: boolean,
 ): AskFramesSplit {
   const framesByTool = new Map<string, ExtensionUiDialogRequest[][]>();
   if (pending.length === 0) return { framesByTool, modalRequest: null };
@@ -98,5 +112,10 @@ export function splitAskFrames(
     framesByTool.set(toolId, groupAskFrames(openAsks.get(toolId) ?? [], frames));
   }
 
-  return { framesByTool, modalRequest: pending.find((request) => !claimed.has(request)) ?? null };
+  // The frame stays queued either way — only the modal waits for the history,
+  // so nothing is dropped and nothing flashes.
+  return {
+    framesByTool,
+    modalRequest: historyLoaded ? pending.find((request) => !claimed.has(request)) ?? null : null,
+  };
 }

package/src/client/hooks/chat/timeline/auto-scroll.ts

@@ -10,6 +10,14 @@
  * because every other trigger lives in the streaming callbacks. This jumps to
  * the tail exactly once per session, on the commit where that session's
  * messages appear.
+ *
+ * The jump is the UNCONDITIONAL one (`jumpToBottom`), not the follow-gated
+ * `scrollToBottom`. Follow mode is a property of this mounted view, not of the
+ * session being opened: a user who scrolled up before switching left it
+ * disengaged, and the open then painted the top of the new session with no
+ * scroll event to re-engage it — the session stayed at the head until the
+ * button was clicked (reproduced: scroll up in session A, open session B,
+ * `scrollTop` pinned at 0 with the jump button showing).
  */
 
 import type { RefObject } from 'preact/compat';
@@ -24,14 +32,15 @@ export interface UseTimelineAutoScrollDeps {
   messages: ChatMessageData[];
   /** Scroll container owned by useChatTimelineScroll. */
   scrollRef: RefObject<HTMLDivElement>;
-  scrollToBottom: (behavior?: ScrollBehavior) => void;
+  /** Unconditional tail jump (bypasses follow mode, re-engages it). */
+  jumpToBottom: (behavior?: ScrollBehavior) => void;
   /** Pending "new-…" sessions render the workspace picker, which owns its own
    *  timeline and scroll handling. */
   enabled: boolean;
 }
 
 export function useTimelineAutoScroll(deps: UseTimelineAutoScrollDeps): void {
-  const { sessionId, messages, scrollRef, scrollToBottom, enabled } = deps;
+  const { sessionId, messages, scrollRef, jumpToBottom, enabled } = deps;
   // Session the container was last rendering. On the commit where this flips
   // the DOM still holds the previous session's rows, so scrolling then would
   // aim at content that is about to be replaced.
@@ -53,6 +62,6 @@ export function useTimelineAutoScroll(deps: UseTimelineAutoScrollDeps): void {
     // scrollHeight forces layout, so the jump lands before the browser paints.
     // 'instant' is required because the container carries Tailwind's
     // `scroll-smooth`, which 'auto' would resolve to.
-    scrollToBottom('instant');
-  }, [sessionId, messages, enabled, scrollRef, scrollToBottom]);
+    jumpToBottom('instant');
+  }, [sessionId, messages, enabled, scrollRef, jumpToBottom]);
 }

package/src/client/hooks/chat/timeline/index.ts

@@ -15,10 +15,8 @@ import { useBrowserPageContextInsert } from '@/client/hooks/chat/timeline/browse
 import { createOmpAgentCallbacks } from '@/shared/lib/chat/timeline/omp-callbacks';
 import { cancelStreamingCoalescer } from '@/shared/lib/chat/timeline/stream-coalescer';
 import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
-import { ACCESS_MODE_SETTING_KEY, normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { useChatTimelineAccessMode } from '@/client/hooks/chat/timeline/access-mode';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
-import { writeSetting } from '@/shared/lib/settings/client';
 
 interface UseChatTimelineOptions {
   folders?: any[];
@@ -51,7 +49,7 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
   // without re-creating it (useSessionLoad is defined below the scroll hook).
   const loadOlderRef = useRef<() => void>(() => {});
 
-  const { scrollRef, contentRef, showScrollBottom, isScrolling, handleScroll, scrollToBottom, jumpToBottom } = useChatTimelineScroll({
+  const { scrollRef, contentRef, showScrollBottom, isScrolling, handleScroll, scrollToBottom, jumpToBottom, jumpActiveRef, jumpCountRef } = useChatTimelineScroll({
     onScrollTop: () => loadOlderRef.current(),
   });
 
@@ -65,11 +63,12 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
   const isPendingSession = Boolean(sessionId?.startsWith('new-'));
   // Committed history lands asynchronously (session-load.ts), so the container
   // paints at the top first; jump to the tail once per session when it does.
+  // Unconditional: follow mode is this view's, not the opened session's.
   useTimelineAutoScroll({
     sessionId,
     messages: localMessages,
     scrollRef,
-    scrollToBottom,
+    jumpToBottom,
     enabled: !isPendingSession,
   });
 
@@ -135,6 +134,8 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     cancelStreamingCoalescer,
     metaRefreshedRef,
     scrollRef,
+    jumpActiveRef,
+    jumpCountRef,
   });
   loadOlderRef.current = loadOlder;
 
@@ -165,21 +166,8 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
   }, [sessionId]);
 
   // Access-control mode is a global, persisted user preference (unlike the
-  // per-session model/thinking picks): it hydrates from appSettings at first
-  // paint and is mirrored into a ref so the send path reads the latest value
-  // without re-creating executeSend.
-  const [accessMode, setAccessMode] = useState<ApprovalMode>(() => normalizeApprovalMode(appSettings.omp_access_mode));
-  const accessModeRef = useRef<ApprovalMode>(accessMode);
-  accessModeRef.current = accessMode;
-
-  const handleAccessModeChange = useCallback((mode: ApprovalMode) => {
-    setAccessMode(mode);
-    accessModeRef.current = mode;
-    // Persist the last selection; the server reads this key as the spawn-time
-    // default. Fire-and-forget: the in-memory value is already authoritative
-    // for this session's requests, which carry it explicitly.
-    writeSetting(ACCESS_MODE_SETTING_KEY, mode);
-  }, []);
+  // per-session model/thinking picks).
+  const { accessMode, accessModeRef, setAccessMode: handleAccessModeChange } = useChatTimelineAccessMode(appSettings);
 
   const persistMessages = useCallback((messagesToSave: any[]) => {
     if (!sessionId) return;