(MOT-3732) feat(console): expose injectable UI chat controls

console/web/src/App.tsx

@@ -45,6 +45,7 @@ import {
 } from '@/hooks/use-workspace-tabs'
 import {
   ConversationsProvider,
+  type InjectableUiRuntime,
   useConversationsCtx,
 } from '@/lib/conversations-context'
 import { shortcutPlatform } from '@/lib/keybindings/bindings'
@@ -68,7 +69,11 @@ import { TracesV2 } from '@/pages/TracesV2'
 import { Workers } from '@/pages/Workers'
 import type { PanelSide } from '@/types/injectable-ui'
 
-export function App() {
+export function App({
+  injectableUiRuntime,
+}: {
+  injectableUiRuntime?: Promise<InjectableUiRuntime>
+}) {
   const [theme, setTheme] = useTheme()
   const [view, setView] = useHashRoute()
   const extPageId = useExtPageRoute()
@@ -205,7 +210,12 @@ export function App() {
   })
 
   return (
-    <ConversationsProvider>
+    <ConversationsProvider
+      injectableUiRuntime={injectableUiRuntime}
+      onConversationRequested={() => {
+        workspaceRef.current.openScreen(CHAT_SCREEN)
+      }}
+    >
       <Sheet>
         <Header
           workspace={workspace}

console/web/src/hooks/use-conversations.test.ts

@@ -12,6 +12,7 @@ import {
   mergeConversationMeta,
   mergeHydratedTranscript,
   mergeSessionListSnapshot,
+  resolveActiveConversationId,
 } from './use-conversations'
 
 function conversation(overrides: Partial<Conversation>): Conversation {
@@ -425,58 +426,6 @@ describe('mergeConversationMeta / system_prompt', () => {
     })
   })
 
-  it('restores addons riding the default choice', () => {
-    const next = mergeConversationMeta(
-      undefined,
-      sessionMeta({
-        metadata: {
-          system_prompt: {
-            choice: 'default',
-            strategy: 'enrich',
-            named_body: '',
-            addons: [
-              { kind: 'prompt', name: 'review', body: 'Review checklist.' },
-              { kind: 'skill', name: 'coder/index', body: 'Coder skill.' },
-            ],
-          },
-        },
-      }),
-    )
-    expect(next.systemPrompt).toEqual({
-      choice: 'default',
-      strategy: 'enrich',
-      namedBody: '',
-      customText: '',
-      addons: [
-        { kind: 'prompt', name: 'review', body: 'Review checklist.' },
-        { kind: 'skill', name: 'coder/index', body: 'Coder skill.' },
-      ],
-    })
-  })
-
-  it('drops malformed addon entries but keeps the valid ones', () => {
-    const next = mergeConversationMeta(
-      undefined,
-      sessionMeta({
-        metadata: {
-          system_prompt: {
-            choice: { named: 'pirate' },
-            named_body: 'Arr.',
-            addons: [
-              'nonsense',
-              { kind: 'rule', name: 'x', body: 'y' },
-              { kind: 'prompt', name: 'review' },
-              { kind: 'skill', name: 'coder/index', body: 'Coder skill.' },
-            ],
-          },
-        },
-      }),
-    )
-    expect(next.systemPrompt?.addons).toEqual([
-      { kind: 'skill', name: 'coder/index', body: 'Coder skill.' },
-    ])
-  })
-
   it('degrades malformed persisted values to the default without throwing', () => {
     // Untrusted wire JSON: a string, a bare `custom`, and a missing name all
     // have to fall back rather than produce a half-built choice.
@@ -509,6 +458,40 @@ describe('mergeConversationMeta / system_prompt', () => {
   })
 })
 
+describe('resolveActiveConversationId', () => {
+  it('keeps a pending select until that session appears in the list', () => {
+    const waiting = resolveActiveConversationId({
+      conversationIds: ['draft'],
+      activeId: 'draft',
+      pendingSelectId: 'worker-session',
+    })
+    expect(waiting).toEqual({
+      activeId: 'worker-session',
+      pendingSelectId: 'worker-session',
+    })
+
+    const arrived = resolveActiveConversationId({
+      conversationIds: ['worker-session', 'draft'],
+      activeId: 'draft',
+      pendingSelectId: 'worker-session',
+    })
+    expect(arrived).toEqual({
+      activeId: 'worker-session',
+      pendingSelectId: null,
+    })
+  })
+
+  it('falls back to the first conversation when nothing is pending or active', () => {
+    expect(
+      resolveActiveConversationId({
+        conversationIds: ['a', 'b'],
+        activeId: 'gone',
+        pendingSelectId: null,
+      }),
+    ).toEqual({ activeId: 'a', pendingSelectId: null })
+  })
+})
+
 describe('isUntouchedDraft', () => {
   it('recognises the chat nobody has written in yet', () => {
     expect(isUntouchedDraft(conversation({ draft: true, messages: [] }))).toBe(

console/web/src/hooks/use-conversations.ts

@@ -274,6 +274,30 @@ export function applyCatalogModelFallback(
   return changed ? next : conversations
 }
 
+/** Keep a just-selected session even if `session::created` has not yet
+ *  inserted it into the sidebar list. Without this, the boot-time "always
+ *  have an active chat" effect snaps back to conversations[0]. */
+export function resolveActiveConversationId(input: {
+  conversationIds: readonly string[]
+  activeId: string | null
+  pendingSelectId: string | null
+}): { activeId: string | null; pendingSelectId: string | null } {
+  const { conversationIds, activeId, pendingSelectId } = input
+  if (conversationIds.length === 0) {
+    return { activeId, pendingSelectId }
+  }
+  if (pendingSelectId) {
+    if (conversationIds.includes(pendingSelectId)) {
+      return { activeId: pendingSelectId, pendingSelectId: null }
+    }
+    return { activeId: pendingSelectId, pendingSelectId }
+  }
+  if (!activeId || !conversationIds.includes(activeId)) {
+    return { activeId: conversationIds[0], pendingSelectId: null }
+  }
+  return { activeId, pendingSelectId: null }
+}
+
 /**
  * Mark every backgrounded server-backed conversation stale so the next
  * activation re-hydrates it. A transcript subscription exists only for the
@@ -482,6 +506,7 @@ export function useConversations(
     emptyConversation(loadLastModel()),
   ])
   const [activeId, setActiveId] = useState<string | null>(() => loadActiveId())
+  const pendingSelectIdRef = useRef<string | null>(null)
 
   /** Highest seen `message-updated` revision per (session, entry). */
   const revisionsRef = useRef(new Map<string, Map<string, number>>())
@@ -822,10 +847,13 @@ export function useConversations(
 
   /* Ensure there's always a sensible "active" pointer at the start. */
   useEffect(() => {
-    if (conversations.length === 0) return
-    if (!activeId || !conversations.some((c) => c.id === activeId)) {
-      setActiveId(conversations[0].id)
-    }
+    const next = resolveActiveConversationId({
+      conversationIds: conversations.map((c) => c.id),
+      activeId,
+      pendingSelectId: pendingSelectIdRef.current,
+    })
+    pendingSelectIdRef.current = next.pendingSelectId
+    if (next.activeId !== activeId) setActiveId(next.activeId)
   }, [conversations, activeId])
 
   const active = useMemo(
@@ -851,7 +879,10 @@ export function useConversations(
     return next.id
   }, [conversations, activeId])
 
-  const select = useCallback((id: string) => setActiveId(id), [])
+  const select = useCallback((id: string) => {
+    pendingSelectIdRef.current = id
+    setActiveId(id)
+  }, [])
 
   const rename = useCallback(
     (id: string, title: string) => {

console/web/src/lib/conversations-context.tsx

@@ -3,6 +3,8 @@ import {
   type ReactNode,
   useCallback,
   useContext,
+  useEffect,
+  useRef,
   useState,
 } from 'react'
 import {
@@ -27,11 +29,14 @@ import {
 } from '@/hooks/use-worktree-status'
 import type { ChatBackend } from '@/lib/backend'
 import { getDefaultBackend } from '@/lib/backend'
+import type { IiiClient } from '@/lib/iii-client'
 import {
   type ProviderListEntry,
   refreshProviderModels,
 } from '@/lib/models-catalog'
+import { type ConversationAdapter, startUiLoader } from '@/lib/ui-loader'
 import type { ModelOption } from '@/types/chat'
+import type { ConsoleApi } from '@/types/injectable-ui'
 
 const backend = getDefaultBackend()
 
@@ -88,8 +93,17 @@ const ConversationsContext = createContext<ConversationsContextValue | null>(
   null,
 )
 
+export interface InjectableUiRuntime {
+  client: IiiClient
+  api: ConsoleApi
+}
+
 interface ConversationsProviderProps {
   children: ReactNode
+  injectableUiRuntime?: Promise<InjectableUiRuntime>
+  /** Called when an injected page asks for a conversation, so the host can
+      place the chat pane when none is open. */
+  onConversationRequested?: (sessionId: string) => void
 }
 
 /**
@@ -100,6 +114,8 @@ interface ConversationsProviderProps {
  */
 export function ConversationsProvider({
   children,
+  injectableUiRuntime,
+  onConversationRequested,
 }: ConversationsProviderProps) {
   const harnessStatus = useHarnessStatus(backend.id === 'real')
   const harnessAvailable = isHarnessAvailable(harnessStatus)
@@ -148,6 +164,53 @@ export function ConversationsProvider({
     }
   }, [harnessAvailable, refresh, presentProviders])
 
+  const selectConversationRef = useRef(api.select)
+  selectConversationRef.current = api.select
+  const conversationsRef = useRef(api.conversations)
+  conversationsRef.current = api.conversations
+  const activeIdRef = useRef(api.activeId)
+  activeIdRef.current = api.activeId
+  const conversationRequestedRef = useRef(onConversationRequested)
+  conversationRequestedRef.current = onConversationRequested
+  const conversationAdapterRef = useRef<ConversationAdapter | null>(null)
+  if (!conversationAdapterRef.current) {
+    conversationAdapterRef.current = {
+      selectConversation(sessionId) {
+        const id = sessionId.trim()
+        if (!id) return
+        selectConversationRef.current(id)
+        // Selecting is only half of it: a page that started a turn wants the
+        // operator to see it, and the chat pane may not be on screen at all.
+        conversationRequestedRef.current?.(id)
+      },
+      composerModel(conversationId) {
+        const requested = conversationId?.trim()
+        const id = requested || activeIdRef.current
+        if (!id) return null
+        const model = conversationsRef.current.find(
+          (conversation) => conversation.id === id,
+        )?.model
+        return typeof model === 'string' && model.trim() ? model.trim() : null
+      },
+    }
+  }
+
+  useEffect(() => {
+    if (!injectableUiRuntime) return
+    let active = true
+    let stop: (() => void) | undefined
+    void injectableUiRuntime
+      .then(({ client, api: consoleApi }) => {
+        if (!active || !conversationAdapterRef.current) return
+        stop = startUiLoader(client, consoleApi, conversationAdapterRef.current)
+      })
+      .catch(() => undefined)
+    return () => {
+      active = false
+      stop?.()
+    }
+  }, [injectableUiRuntime])
+
   const value: ConversationsContextValue = {
     ...api,
     backend,