Unify Source Control action permissions and card layout

config/scripts/pr-unit-support-routing.test.mjs

@@ -6,7 +6,7 @@ import {
   collectUnitDependencyGraph,
   unitConsumers
 } from './ci-unit-dependency-graph.mjs'
-import { discoverUnitFiles } from './ci-unit-files.mjs'
+import { CROSS_VERSION_WIRE_DIR, discoverUnitFiles } from './ci-unit-files.mjs'
 import { planUnitSelection } from './ci-unit-selection.mjs'
 
 const harness = 'src/renderer/src/runtime/web-session-tabs-sync-test-harness.ts'
@@ -34,7 +34,11 @@ const supportBridges = new Set([
 
 function productConsumers(file, graph, unitFiles) {
   return [...unitConsumers([file], graph.reverse)].filter(
-    (consumer) => consumer !== file && !unitFiles.has(consumer) && !supportBridges.has(consumer)
+    (consumer) =>
+      consumer !== file &&
+      !unitFiles.has(consumer) &&
+      !(consumer.startsWith(CROSS_VERSION_WIRE_DIR) && consumer.endsWith('.unit.test.ts')) &&
+      !supportBridges.has(consumer)
   )
 }
 

mobile/src/session/mobile-existing-agent-launch.test.ts

@@ -209,19 +209,35 @@ describe('launchAgentInExistingWorkspace', () => {
   })
 
   it('treats a refusal of the first send as an unsupported host', async () => {
-    const { client } = scriptedClient(refused('agent_launch_replay_unsupported'))
-    await expect(launch(client)).resolves.toEqual({ kind: 'unsupported' })
+    const { client, sendRequest } = scriptedClient(refused('agent_launch_replay_unsupported'))
+    await expect(
+      launch(client, { chatOptions: { model: 'opus', fastMode: 'false' } })
+    ).resolves.toEqual({ kind: 'unsupported' })
+    expect(sendRequest.mock.calls[0]?.[1]).not.toHaveProperty('chatOptions')
   })
 
   it('never reads a refusal after a replay as unsupported: the first attempt may have run', async () => {
     const { client, sendRequest } = scriptedClient(
       { throws: markRpcDeliveryUnknown(new Error('Connection interrupted')) },
       refused('agent_launch_replay_unsupported')
     )
-    await expect(launch(client)).resolves.toEqual({
+    const chatOptions = { model: 'opus', fastMode: 'false' }
+    const capabilities = [...LAUNCH_CAPABILITIES, 'agent.launch.chat-options.v1']
+    const pending = launch(client, { hostCapabilities: capabilities, chatOptions })
+    chatOptions.model = 'changed-after-send'
+    capabilities.length = 0
+    await expect(pending).resolves.toEqual({
       kind: 'unknown',
       message: AGENT_LAUNCH_UNCONFIRMED_MESSAGE
     })
+    expect(sendRequest.mock.calls.map(([, params]) => requestParam(params, 'chatOptions'))).toEqual(
+      [
+        { model: 'opus', fastMode: 'false' },
+        { model: 'opus', fastMode: 'false' }
+      ]
+    )
+    expect(sendRequest.mock.calls[0]?.[1]).toBe(sendRequest.mock.calls[1]?.[1])
+    // The replay reuses the same operation id.
     expect(sendRequest.mock.calls.map(([, params]) => requestParam(params, 'operationId'))).toEqual(
       ['op-1', 'op-1']
     )

mobile/src/session/mobile-existing-agent-launch.ts

@@ -1,5 +1,6 @@
 // Send launch intent to the host, which selects terminal versus structured execution and prompt delivery.
 
+import { AGENT_LAUNCH_CHAT_OPTIONS_RUNTIME_CAPABILITY } from '../../../src/shared/agent-launch-runtime-capability'
 import type {
   AgentLaunchPlacement,
   AgentLaunchPrompt,
@@ -76,6 +77,9 @@ export async function launchAgentInExistingWorkspace(args: {
   worktreeId: string
   agent: TuiAgent
   prompt?: AgentLaunchPrompt
+  /** Model and effort the host applies on whichever route it picks. */
+  sessionOptions?: Readonly<Record<string, string>>
+  chatOptions?: Readonly<Record<string, string>>
   launchSource?: string
   reservation?: MobileAgentLaunchReservation
   placement?: AgentLaunchPlacement
@@ -89,6 +93,11 @@ export async function launchAgentInExistingWorkspace(args: {
     worktreeId: args.worktreeId,
     operationId: (args.mintOperationId ?? structuredSessionOperationId)(),
     ...(args.prompt ? { prompt: args.prompt } : {}),
+    ...(args.sessionOptions ? { sessionOptions: args.sessionOptions } : {}),
+    ...(args.chatOptions &&
+    args.hostCapabilities?.includes(AGENT_LAUNCH_CHAT_OPTIONS_RUNTIME_CAPABILITY)
+      ? { chatOptions: args.chatOptions }
+      : {}),
     ...(args.launchSource ? { launchSource: args.launchSource } : {}),
     ...(args.placement ? { placement: args.placement } : {}),
     ...(args.reservation

mobile/src/session/pr-ai-triage-launch.ts

@@ -11,6 +11,7 @@ import {
   loadMobileAgentLaunchContext
 } from './mobile-new-tab-agent-loader'
 import { resolveMobileSourceControlLaunchAgent } from './mobile-source-control-launch-agent'
+import { resolveSourceControlActionSessionOptions } from '../../../src/shared/source-control-action-launch-preferences'
 
 // Have the host launch and deliver AI prompts; mobile must never type them into a shell.
 
@@ -68,11 +69,15 @@ export async function launchAgentWithPrompt(args: {
         "This action's saved prompt is empty. Update Source Control AI settings on your computer."
     }
   }
+  const sessionOptions = recipe
+    ? resolveSourceControlActionSessionOptions(recipe, resolved.agent)
+    : undefined
   const launched = await launchAgentInExistingWorkspace({
     client: args.client,
     hostCapabilities: args.hostCapabilities,
     worktreeId: args.worktreeId,
     agent: resolved.agent,
+    ...(sessionOptions ? { chatOptions: sessionOptions } : {}),
     // Leave agent arguments to host defaults because applicability depends on the host-selected route and shell.
     prompt: { text, delivery: 'submit' },
     launchSource: args.launchSource

mobile/src/tasks/agent-launch-request.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
   agentLaunchCreateParams,
+  agentLaunchExistingParams,
   isAgentLaunchUnsupportedRefusal,
   readAgentLaunchCreateOutcome
 } from './agent-launch-request'
@@ -36,6 +37,23 @@ describe('agentLaunchCreateParams', () => {
   })
 })
 
+describe('agentLaunchExistingParams', () => {
+  const launch = { agent: 'codex', worktreeId: 'wt-1', operationId: 'op-1' } as const
+
+  it("sends an action's model and effort as session options", () => {
+    expect(
+      agentLaunchExistingParams({
+        ...launch,
+        sessionOptions: { model: 'gpt-5.6-terra', effort: 'high' }
+      }).sessionOptions
+    ).toEqual({ model: 'gpt-5.6-terra', effort: 'high' })
+  })
+
+  it('omits session options when the action saved no model', () => {
+    expect(agentLaunchExistingParams(launch)).not.toHaveProperty('sessionOptions')
+  })
+})
+
 describe('readAgentLaunchCreateOutcome', () => {
   it.each([
     {

mobile/src/tasks/agent-launch-request.ts

@@ -61,12 +61,16 @@ export function agentLaunchExistingParams(args: {
   paneKey?: string
   sessionId?: string
   placement?: AgentLaunchPlacement
+  sessionOptions?: Readonly<Record<string, string>>
+  chatOptions?: Readonly<Record<string, string>>
 }): RpcSendParams<'agent.launchReplay'> {
   return {
     agent: args.agent,
     operationId: args.operationId,
     target: { kind: 'existing', worktree: `id:${args.worktreeId}` },
     ...(args.prompt ? { prompt: args.prompt } : {}),
+    ...(args.sessionOptions ? { sessionOptions: { ...args.sessionOptions } } : {}),
+    ...(args.chatOptions ? { chatOptions: { ...args.chatOptions } } : {}),
     ...(args.launchSource ? { launchSource: args.launchSource } : {}),
     ...(args.paneKey ? { paneKey: args.paneKey } : {}),
     ...(args.sessionId ? { sessionId: args.sessionId } : {}),

src/main/agent-launch/agent-launch-executor.test.ts

@@ -375,10 +375,17 @@ describe("a caller's chat default in place of the host's", () => {
 describe('a launch into a workspace that already exists', () => {
   it('opens a session without creating anything', async () => {
     const h = harness({})
-    const result = await h.run({ agent: 'codex', target: { kind: 'existing', worktree: 'wt-7' } })
+    const result = await h.run({
+      agent: 'codex',
+      target: { kind: 'existing', worktree: 'wt-7' },
+      chatOptions: { model: 'action-model', fastMode: 'false' }
+    })
     expect(h.calls).toEqual(['createSupport', 'createStructuredSession'])
     expect(h.createWorktree).not.toHaveBeenCalled()
     expect(result.worktreeId).toBe('wt-7')
+    expect(h.createStructuredSession).toHaveBeenCalledWith(
+      expect.objectContaining({ chatOptions: { model: 'action-model', fastMode: 'false' } })
+    )
   })
 
   it.each(['claude', 'grok'] as const)(
@@ -400,7 +407,16 @@ describe('a launch into a workspace that already exists', () => {
 describe('an agent with no structured session', () => {
   it('stays a terminal without asking the host', async () => {
     const h = harness({})
-    const result = await h.run({ agent: 'gemini', target: { kind: 'existing', worktree: 'wt-7' } })
+    const result = await h.run({
+      agent: 'gemini',
+      target: { kind: 'existing', worktree: 'wt-7' },
+      chatOptions: { model: 'action-model', fastMode: 'false' }
+    })
+    expect(h.createTerminalAgent.mock.calls[0]?.[0]).not.toHaveProperty('chatOptions')
+    // The saved choice reaches the terminal too; its converter keeps only what has a flag.
+    expect(h.createTerminalAgent.mock.calls[0]?.[0]).toMatchObject({
+      options: { model: 'action-model', fastMode: 'false' }
+    })
     expect(h.calls).toEqual(['createTerminalAgent'])
     expect(result.receipt).toMatchObject({ reason: 'agent_without_structured_session' })
   })

src/main/agent-launch/agent-launch-executor.ts

@@ -1,6 +1,7 @@
-/** Ask after workspace creation: the host needs resolved metadata to decide chat support. */
+import { decideAgentLaunchIntentMode } from './agent-launch-intent-mode'
+/** Structured launches create the workspace without an agent, then ask its host for chat support.
+ * The host needs the created workspace to answer; a definitive refusal starts a terminal agent. */
 
-import { assertOpenCodeModelLaunchPreferencesAbsent } from '../opencode/opencode-model-startup-plan'
 import { assertAgentPromptRequestActive } from '../runtime/orca-runtime-core'
 import { parsePaneKey } from '../../shared/stable-pane-id'
 import type { AgentLaunchResult } from '../../shared/agent-launch-intent'
@@ -18,11 +19,8 @@ import {
   settledAtCreation,
   settleLaunchPromptDisposal
 } from './agent-launch-prompt-delivery'
-import { workspaceKindForLaunchTarget } from '../../shared/workspace-launch-kind'
 import { isDefinitiveAgentSessionCreateRefusal } from '../../shared/agent-session-definitive-refusal'
 import {
-  decideAgentLaunchMode,
-  readAgentLaunchModeSettings,
   resolveAgentLaunchModeOnHost,
   type AgentLaunchModeReceipt,
   type AgentLaunchModeSettlement,
@@ -37,6 +35,7 @@ import {
 } from './agent-launch-legacy-host'
 import {
   AgentLaunchStructuredSessionRefusedError,
+  assertTerminalLaunchAdmissible,
   terminalLaunchInputs,
   type AgentLaunchStructuredSurface,
   type AgentLaunchWorkspaceFactory
@@ -53,31 +52,10 @@ export async function executeAgentLaunch(
   execution: AgentLaunchExecution
 ): Promise<AgentLaunchResult> {
   const { intent, runtime } = execution
-  if (intent.reuseTerminal || intent.target.kind === 'create-worktree') {
-    assertOpenCodeModelLaunchPreferencesAbsent(intent.agent, intent.sessionOptions)
-  }
   const vocabulary = execution.vocabulary ?? DEFAULT_LAUNCH_VOCABULARY
-  const preflight =
-    execution.decidedMode ??
-    decideAgentLaunchMode({
-      placement: {
-        agent: intent.agent,
-        workspaceKind: workspaceKindForLaunchTarget(intent.target),
-        ...(intent.reuseTerminal ? { terminal: intent.reuseTerminal.handle } : {}),
-        ...(intent.cwd ? { cwd: intent.cwd } : {}),
-        ...(intent.target.kind === 'existing' && intent.target.workspacePath
-          ? { workspacePath: intent.target.workspacePath }
-          : {}),
-        ...(execution.callerRendersStructured === false ? { callerRendersStructured: false } : {})
-      },
-      settings: execution.terminalOnly
-        ? undefined
-        : readAgentLaunchModeSettings(runtime, intent.nativeChatDefault),
-      ...(execution.terminalOnly ? { terminalOnly: true } : {}),
-      ...(intent.surface ? { surface: intent.surface } : {}),
-      vocabulary
-    })
-  // Intent preparation may have outlived the request.
+  const preflight = execution.decidedMode ?? decideAgentLaunchIntentMode(execution)
+  assertTerminalLaunchAdmissible(intent, preflight.mode)
+  // A caller's own preparation (intent resolution) may have outlived its request.
   assertAgentPromptRequestActive(execution.signal)
   if (execution.promptPolicy === 'legacy-host') {
     assertLegacyHostTarget(execution)
@@ -271,6 +249,7 @@ async function createSurface(
       worktreeId: workspace.worktreeId,
       agent: intent.agent,
       ...(intent.sessionOptions ? { options: intent.sessionOptions } : {}),
+      ...(intent.chatOptions ? { chatOptions: intent.chatOptions } : {}),
       ...(intent.sessionId ? { sessionId: intent.sessionId } : {}),
       ...(reservedTabId ? { tabId: reservedTabId } : {}),
       ...launchPromptCreateInputs(intent, execution.signal),

src/main/agent-launch/agent-launch-intent-mode.ts

@@ -0,0 +1,38 @@
+import type { AgentLaunchIntent } from '../../shared/agent-launch-intent'
+import { workspaceKindForLaunchTarget } from '../../shared/workspace-launch-kind'
+import {
+  decideAgentLaunchMode,
+  readAgentLaunchModeSettings,
+  DEFAULT_LAUNCH_VOCABULARY,
+  type AgentLaunchModeReceipt,
+  type AgentLaunchModeVocabulary
+} from './agent-launch-mode'
+
+/** The same preflight is used for admission and execution, before workspace creation. */
+export function decideAgentLaunchIntentMode(execution: {
+  intent: AgentLaunchIntent
+  runtime: Parameters<typeof readAgentLaunchModeSettings>[0]
+  terminalOnly?: boolean
+  callerRendersStructured?: boolean
+  vocabulary?: AgentLaunchModeVocabulary
+}): AgentLaunchModeReceipt {
+  const { intent, runtime } = execution
+  return decideAgentLaunchMode({
+    placement: {
+      agent: intent.agent,
+      workspaceKind: workspaceKindForLaunchTarget(intent.target),
+      ...(intent.reuseTerminal ? { terminal: intent.reuseTerminal.handle } : {}),
+      ...(intent.cwd ? { cwd: intent.cwd } : {}),
+      ...(intent.target.kind === 'existing' && intent.target.workspacePath
+        ? { workspacePath: intent.target.workspacePath }
+        : {}),
+      ...(execution.callerRendersStructured === false ? { callerRendersStructured: false } : {})
+    },
+    settings: execution.terminalOnly
+      ? undefined
+      : readAgentLaunchModeSettings(runtime, intent.nativeChatDefault),
+    ...(execution.terminalOnly ? { terminalOnly: true } : {}),
+    ...(intent.surface ? { surface: intent.surface } : {}),
+    vocabulary: execution.vocabulary ?? DEFAULT_LAUNCH_VOCABULARY
+  })
+}

src/main/agent-launch/agent-launch-opencode-model.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, it, vi } from 'vitest'
+import recordings from '../../shared/fixtures/source-control-launch-recordings.json'
 import type { AgentLaunchIntent } from '../../shared/agent-launch-intent'
 import { executeAgentLaunch } from './agent-launch-executor'
+import { toAgentLaunchPreferences } from '../../shared/agent-launch-preferences'
+import { assertOpenCodeModelLaunchPreferencesAbsent } from '../opencode/opencode-model-startup-plan'
+import { agentPermissionChoices } from '../../shared/tui-agent-permission-choice'
 
 function harness() {
   const readSettings = vi.fn(() => {
-    throw new Error('settings_not_needed_for_refusal')
+    throw new Error('settings_unavailable')
   })
   const createSupport = vi.fn(async () => {
     throw new Error('support_not_needed_for_refusal')
@@ -59,12 +63,39 @@ const creating: AgentLaunchIntent = {
 }
 
 describe('OpenCode model preferences on unsupported launch placements', () => {
+  it('keeps own selectable without projecting a meaningless permission into either terminal guard', async () => {
+    const sessionOptions = { permissionMode: 'own' }
+    const projected = toAgentLaunchPreferences(sessionOptions, 'opencode')
+    expect(agentPermissionChoices('opencode')).toContain('own')
+    expect(projected).toBeUndefined()
+    // Workspace creation consumes this projection through the same unchanged broad guard.
+    expect(() => assertOpenCodeModelLaunchPreferencesAbsent('opencode', projected)).not.toThrow()
+    for (const intent of [reused, creating]) {
+      const h = harness()
+      await expect(h.run({ ...intent, sessionOptions })).resolves.toBeDefined()
+    }
+  })
+
+  it('refuses the real OpenCode model readback on a reused terminal before prompt delivery', async () => {
+    const model = recordings.opencode.update.message.params.update.configOptions.find(
+      (option) => option.category === 'model'
+    )?.currentValue
+    expect(model).toBe('opencode/big-pickle')
+    const h = harness()
+    await expect(h.run({ ...reused, sessionOptions: { model } })).rejects.toMatchObject({
+      code: 'capability_unsupported'
+    })
+    expect(h.createTerminal).not.toHaveBeenCalled()
+    expect(h.createWorktree).not.toHaveBeenCalled()
+    expect(h.deliverPrompt).not.toHaveBeenCalled()
+  })
+
   it.each([reused, creating])(
-    'refuses before reading settings or creating or delivering',
+    'preserves definitive refusal without creating or delivering when the route settings read throws',
     async (intent) => {
       const h = harness()
       await expect(h.run(intent)).rejects.toMatchObject({ code: 'capability_unsupported' })
-      expect(h.readSettings).not.toHaveBeenCalled()
+      expect(h.readSettings).toHaveBeenCalledOnce()
       expect(h.createTerminal).not.toHaveBeenCalled()
       expect(h.createWorktree).not.toHaveBeenCalled()
       expect(h.deliverPrompt).not.toHaveBeenCalled()