Add Pi structured native chat through its RPC mode

config/scripts/check-runtime-electron-ratchet.mjs

@@ -49,7 +49,9 @@ export const STRUCTURED_CHAT_LANES = [
   { directory: ['src', 'shared'] },
   { directory: ['src', 'main', 'runtime'], basename: /^(?:structured-|agent-session-)/ },
   { directory: ['src', 'main', 'provider-process'] },
-  { directory: ['src', 'main', 'acp'] }
+  { directory: ['src', 'main', 'acp'] },
+  { directory: ['src', 'main', 'jsonl-rpc'] },
+  { directory: ['src', 'main', 'pi'], basename: /^rpc-/ }
 ]
 
 export function collectStructuredChatEntryPoints(root = ROOT) {

config/scripts/check-runtime-electron-ratchet.test.mjs

@@ -39,6 +39,8 @@ describe('structured chat coverage', () => {
     'src/main/runtime/structured-agent-session-host.ts': 'export {}',
     'src/main/provider-process/provider-process-teardown.ts': 'export {}',
     'src/main/acp/acp-structured-session-adapter.ts': 'export {}',
+    'src/main/jsonl-rpc/peer.ts': 'export {}',
+    'src/main/pi/rpc-launch.ts': 'export {}',
     'src/shared/agent-session-record.ts': 'export {}'
   }
 
@@ -55,7 +57,8 @@ describe('structured chat coverage', () => {
       'src/main/runtime/structured-agent-runtime-registrations.ts',
       'src/main/runtime/rpc/methods/structured-agent-session-agents.ts',
       'src/main/acp/adapter.ts',
-      'src/main/provider-process/worker.ts'
+      'src/main/provider-process/worker.ts',
+      'src/main/jsonl-rpc/nested/dialect.ts'
     ]
     const excluded = [
       'src/main/native-chat/reader.test.ts',
@@ -73,7 +76,10 @@ describe('structured chat coverage', () => {
       'src/main/runtime/orca-runtime-tests/structured-agent-session-host.ts',
       'src/shared/types.d.ts',
       'src/main/runtime/other.ts',
-      'src/main/runtime/rpc/methods/browser.ts'
+      'src/main/runtime/rpc/methods/browser.ts',
+      'src/main/jsonl-rpc/peer.test.ts',
+      'src/main/pi/rpc-launch.test.ts',
+      'src/main/pi/titlebar-extension-service.ts'
     ]
     const root = fixture(
       Object.fromEntries([...sources, ...excluded].map((file) => [file, 'export {}']))
@@ -90,7 +96,9 @@ describe('structured chat coverage', () => {
         Object.entries(requiredLanes).filter(([file]) => !file.startsWith(`${lane}/`))
       )
       expect(() => collectStructuredChatEntryPoints(fixture(without))).toThrow(`${lane} is missing`)
-      expect(collectStructuredChatEntryPoints(fixture(requiredLanes))).toHaveLength(7)
+      expect(collectStructuredChatEntryPoints(fixture(requiredLanes))).toHaveLength(
+        Object.keys(requiredLanes).length
+      )
     }
   )
 
@@ -101,6 +109,8 @@ describe('structured chat coverage', () => {
         ...requiredLanes,
         'src/main/acp/adapter.ts': "import 'acp-desktop-package'",
         'src/main/provider-process/worker.ts': "import 'provider-desktop-package'",
+        'src/main/jsonl-rpc/peer.ts': "import 'rpc-desktop-package'",
+        'src/main/pi/rpc-launch.ts': "import 'pi-desktop-package'",
         'node_modules/acp-desktop-package/package.json': JSON.stringify({
           main: 'index.js',
           sideEffects
@@ -110,12 +120,24 @@ describe('structured chat coverage', () => {
           main: 'index.js',
           sideEffects
         }),
-        'node_modules/provider-desktop-package/index.js': "require('electron')"
+        'node_modules/provider-desktop-package/index.js': "require('electron')",
+        'node_modules/rpc-desktop-package/package.json': JSON.stringify({
+          main: 'index.js',
+          sideEffects
+        }),
+        'node_modules/rpc-desktop-package/index.js': "require('electron')",
+        'node_modules/pi-desktop-package/package.json': JSON.stringify({
+          main: 'index.js',
+          sideEffects
+        }),
+        'node_modules/pi-desktop-package/index.js': "require('electron')"
       })
       const current = await collectElectronImporters(collectStructuredChatEntryPoints(root))
       expect(current.map((file) => file.split('/node_modules/').pop())).toEqual([
         'acp-desktop-package/index.js',
-        'provider-desktop-package/index.js'
+        'pi-desktop-package/index.js',
+        'provider-desktop-package/index.js',
+        'rpc-desktop-package/index.js'
       ])
     }
   )

config/scripts/vitest-sqlite-runtime-files.mjs

@@ -150,6 +150,7 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-wire-admission.test.ts',
   'src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts',
   'src/main/orcad/orcad-automations.test.ts',
+  'src/main/pi/rpc-launch-resolution.test.ts',
   'src/main/runtime/agent-session-conversation-clear-commit.test.ts',
   'src/main/runtime/agent-session-conversation-name-store.test.ts',
   'src/main/runtime/agent-session-death-evidence-persistence.test.ts',

mobile/src/session/MobileNativeChatQuestion.test.tsx

@@ -129,4 +129,71 @@ describe('MobileNativeChatQuestion', () => {
     await act(async () => cancel.props.onPress())
     expect(onCancel).toHaveBeenCalledWith({ itemId: 'question-1', expectedRevision: 7 })
   })
+
+  it('prefills an editor and sends its whitespace unchanged', async () => {
+    const onAnswer = vi.fn(async () => true)
+    await act(async () => {
+      renderer = create(
+        createElement(MobileNativeChatQuestion, {
+          question: {
+            question: 'Edit the draft',
+            options: [],
+            multiSelect: false,
+            optionTokens: [],
+            freeTextToken: 'editor-token',
+            freeTextInput: {
+              allowEmpty: true,
+              multiline: true,
+              initialValue: '  draft\n',
+              placeholder: 'Write here'
+            }
+          },
+          onAnswer
+        })
+      )
+    })
+
+    const input = renderer.root.findByType('TextInput')
+    expect(input.props).toMatchObject({
+      value: '  draft\n',
+      placeholder: 'Write here',
+      multiline: true
+    })
+    await act(async () => input.props.onChangeText('  \n '))
+    const send = renderer.root.findByProps({ accessibilityLabel: 'Send reply' })
+    expect(send.props.disabled).toBe(false)
+    await act(async () => send.props.onPress())
+    expect(onAnswer).toHaveBeenCalledWith(`editor-token:${encodeURIComponent('  \n ')}`)
+  })
+
+  it('sends an empty allowed answer and still disables an empty legacy answer', async () => {
+    const onAnswer = vi.fn(async () => true)
+    const question = {
+      question: 'Input',
+      options: [],
+      multiSelect: false,
+      optionTokens: [],
+      freeTextToken: 'input-token'
+    }
+    await act(async () => {
+      renderer = create(
+        createElement(MobileNativeChatQuestion, {
+          question: { ...question, freeTextInput: { allowEmpty: true, multiline: false } },
+          onAnswer
+        })
+      )
+    })
+    const send = renderer.root.findByProps({ accessibilityLabel: 'Send reply' })
+    expect(renderer.root.findByType('TextInput').props.multiline).toBe(false)
+    expect(send.props.disabled).toBe(false)
+    await act(async () => send.props.onPress())
+    expect(onAnswer).toHaveBeenCalledWith('input-token:')
+
+    await act(async () =>
+      renderer.update(createElement(MobileNativeChatQuestion, { question, onAnswer }))
+    )
+    expect(renderer.root.findByProps({ accessibilityLabel: 'Send reply' }).props.disabled).toBe(
+      true
+    )
+  })
 })

mobile/src/session/MobileNativeChatQuestion.tsx

@@ -30,13 +30,13 @@ export function MobileNativeChatQuestion({
   onCollapse
 }: Props): React.JSX.Element {
   const [selectedOptionIndexes, setSelectedOptionIndexes] = useState<number[]>([])
-  const [freeText, setFreeText] = useState('')
+  const [freeText, setFreeText] = useState(() => question.freeTextInput?.initialValue ?? '')
   const [sending, setSending] = useState(false)
   const sendingRef = useRef(false)
   const allowOther = question.allowOther !== false
 
   const hasOptions = question.options.length > 0
-  const trimmedFreeText = freeText.trim()
+  const answerText = question.freeTextInput?.allowEmpty ? freeText : freeText.trim()
 
   const toggle = (optionIndex: number): void => {
     setSelectedOptionIndexes((prev) =>
@@ -72,29 +72,30 @@ export function MobileNativeChatQuestion({
       return
     }
     const answer =
-      question.freeTextToken && trimmedFreeText.length > 0
-        ? formatQuestionAnswerWithOtherByIndexes(question, selectedOptionIndexes, trimmedFreeText)
+      question.freeTextToken && answerText.length > 0
+        ? formatQuestionAnswerWithOtherByIndexes(question, selectedOptionIndexes, answerText)
         : formatQuestionAnswerByIndexes(question, selectedOptionIndexes)
     if (await sendAnswer(answer)) {
       setFreeText('')
     }
   }
 
   const submitFreeText = async (): Promise<void> => {
-    if (trimmedFreeText.length === 0) {
+    if (!allowOther || (answerText.length === 0 && !question.freeTextInput?.allowEmpty)) {
       return
     }
     const answer =
       question.multiSelect && question.freeTextToken && selectedOptionIndexes.length > 0
-        ? formatQuestionAnswerWithOtherByIndexes(question, selectedOptionIndexes, trimmedFreeText)
-        : formatQuestionFreeTextAnswer(question, trimmedFreeText)
+        ? formatQuestionAnswerWithOtherByIndexes(question, selectedOptionIndexes, answerText)
+        : formatQuestionFreeTextAnswer(question, answerText)
     if (await sendAnswer(answer)) {
       setFreeText('')
     }
   }
 
   const canSubmitMulti = selectedOptionIndexes.length > 0 && !sending
-  const canSendFreeText = allowOther && trimmedFreeText.length > 0 && !sending
+  const canSendFreeText =
+    allowOther && (answerText.length > 0 || question.freeTextInput?.allowEmpty === true) && !sending
 
   // Stable keys for option rows even if an agent repeats a label.
   const optionRows = useMemo(
@@ -178,12 +179,15 @@ export function MobileNativeChatQuestion({
             style={mobileNativeChatInputStyles.freeInput}
             value={freeText}
             onChangeText={setFreeText}
-            placeholder={hasOptions ? 'Or type a reply…' : 'Type your reply…'}
+            placeholder={
+              question.freeTextInput?.placeholder ??
+              (hasOptions ? 'Or type a reply…' : 'Type your reply…')
+            }
             placeholderTextColor={colors.textMuted}
             selectionColor={colors.accentBlue}
             onSubmitEditing={submitFreeText}
             returnKeyType="send"
-            multiline
+            multiline={question.freeTextInput?.multiline ?? true}
           />
           <Pressable
             accessibilityLabel="Send reply"

mobile/src/session/mobile-native-chat-question.test.ts

@@ -148,6 +148,21 @@ describe('formatQuestionAnswer', () => {
       formatQuestionFreeTextAnswer({ ...numbered, freeTextToken: 'target' }, '  hi there  ')
     ).toBe(`target:${encodeURIComponent('hi there')}`)
   })
+
+  it('encodes empty and whitespace answers only when allowed', () => {
+    const withInput: MobileChatQuestion = {
+      ...numbered,
+      freeTextToken: 'target',
+      freeTextInput: { allowEmpty: true }
+    }
+    expect(formatQuestionFreeTextAnswer(withInput, '')).toBe('target:')
+    expect(formatQuestionFreeTextAnswer(withInput, '  \n ')).toBe(
+      `target:${encodeURIComponent('  \n ')}`
+    )
+    expect(formatQuestionFreeTextAnswer({ ...withInput, freeTextInput: undefined }, '  \n ')).toBe(
+      ''
+    )
+  })
 })
 
 describe('mobileChatQuestionKey', () => {

mobile/src/session/mobile-native-chat-question.ts

@@ -3,6 +3,8 @@
 // have no structured signal, so we parse the text conservatively and only treat
 // it as a question when a clear option list is present.
 
+import type { AgentJournalFreeTextInput } from '../../../src/shared/agent-session-journal-types'
+
 export type MobileChatQuestion = {
   question: string
   /** Structured prompt identity, present only for durable host prompts. */
@@ -19,6 +21,7 @@ export type MobileChatQuestion = {
   optionDescriptions?: (string | undefined)[]
   /** Opaque prefix used when free-text answers must target a specific prompt. */
   freeTextToken?: string
+  freeTextInput?: AgentJournalFreeTextInput
 }
 
 export function mobileChatQuestionKey(question: MobileChatQuestion): string {
@@ -203,11 +206,13 @@ export function formatQuestionAnswer(question: MobileChatQuestion, selected: str
 }
 
 export function formatQuestionFreeTextAnswer(question: MobileChatQuestion, text: string): string {
-  const trimmed = text.trim()
-  if (trimmed.length === 0) {
+  const answer = question.freeTextInput?.allowEmpty ? text : text.trim()
+  if (answer.length === 0 && !question.freeTextInput?.allowEmpty) {
     return ''
   }
   return question.freeTextToken
-    ? `${question.freeTextToken}:${encodeURIComponent(trimmed)}`
-    : formatQuestionAnswer(question, [trimmed])
+    ? `${question.freeTextToken}:${encodeURIComponent(answer)}`
+    : question.freeTextInput?.allowEmpty
+      ? answer
+      : formatQuestionAnswer(question, [answer])
 }

mobile/src/session/mobile-structured-agent-prompts-free-text.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentJournalFreeTextInput } from '../../../src/shared/agent-session-journal-types'
+import { formatQuestionFreeTextAnswer } from './mobile-native-chat-question'
+import {
+  projectStructuredQuestion,
+  structuredQuestionResponseTarget,
+  type StructuredQuestionItem
+} from './mobile-structured-agent-prompts'
+
+function prompt(freeTextInput?: AgentJournalFreeTextInput): StructuredQuestionItem {
+  return {
+    itemId: 'item-1',
+    revision: 3,
+    sequence: 1,
+    observedAt: 1,
+    body: {
+      kind: 'question',
+      question: 'Edit the draft',
+      options: [],
+      freeTextQuestionId: 'q1',
+      ...(freeTextInput ? { freeTextInput } : {}),
+      resolution: { state: 'pending', selectedOptionId: null, resolvedBy: null, resolvedAt: null }
+    }
+  }
+}
+
+describe('mobile structured free-text questions', () => {
+  it('projects editor input metadata onto the existing question card', () => {
+    const freeTextInput = {
+      allowEmpty: true,
+      multiline: true,
+      initialValue: 'draft',
+      placeholder: 'Edit here'
+    }
+    expect(projectStructuredQuestion(prompt(freeTextInput))?.freeTextInput).toEqual(freeTextInput)
+    expect(projectStructuredQuestion(prompt())?.freeTextInput).toBeUndefined()
+  })
+
+  it('accepts empty and whitespace text only for the matching allowed prompt', () => {
+    const current = prompt({ allowEmpty: true })
+    const projected = projectStructuredQuestion(current)!
+    for (const answer of ['', '  \n ']) {
+      const response = formatQuestionFreeTextAnswer(projected, answer)
+      expect(structuredQuestionResponseTarget(response, current)).toEqual({
+        itemId: 'item-1',
+        expectedRevision: 3,
+        answer: { questionId: 'q1', optionIds: [], other: answer }
+      })
+      expect(structuredQuestionResponseTarget(response, prompt())).toBeNull()
+    }
+    expect(
+      structuredQuestionResponseTarget(formatQuestionFreeTextAnswer(projected, ''), {
+        ...current,
+        revision: 4
+      })
+    ).toBeNull()
+  })
+
+  it('keeps legacy trimming for ordinary free-text answers', () => {
+    const current = prompt()
+    const projected = projectStructuredQuestion(current)!
+    expect(
+      structuredQuestionResponseTarget(
+        formatQuestionFreeTextAnswer(projected, '  draft  '),
+        current
+      )
+    ).toMatchObject({ answer: { other: 'draft' } })
+    expect(structuredQuestionResponseTarget('', current)).toBeNull()
+  })
+})