refactor(web): drop the permission RPC pair and turn-anchoring machinery

The session.permissions/setPermission unary pair, the PermissionOption wire
DTO, the client Session wrappers, and the fixture/fake mirrors all leave the
wire: the read side moves to the 'permissions' session projection and the
write side moves to the /permission command in follow-up commits, so the
web protocol gains no permission methods at all.

The pendingSwitches + prompt-submit flush + hasOpenTurn move also goes.
Knob events no longer need turn enclosure: the persistence scanner keeps
standalone events after the last turn/end as part of the preserved prefix
(remove-synthetic-log-only-turns), none of the three knob invariants demand
an open turn, and the setters append bare events. An idle switch commits
immediately; hasOpenTurn stays a user-approval private fold (its audit pair
is the one contract that still requires enclosure).

The old PermissionSelect chip and its mount-time fetch die with the RPCs
(the resident composer broke the mount-once assumption); the projection-fed
replacement lands with the Access seat swap.

packages/client/connection/src/client/api.ts

@@ -7,7 +7,7 @@
 
 export type {
   ApiProxy, SessionsApi, SessionSummary, HostApi, EventsApi, MuxFrame, HostFrame,
-  ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, PermissionOption, ToolEventView,
+  ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView,
   WorkspaceApi, WorkspaceId, WorkspaceView,
   CommandsApi, CommandDescriptor, SkillsApi, SkillEntry,
   ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning,

packages/client/connection/src/client/fixture.ts

@@ -483,12 +483,6 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
   let approvalPending = true
   const pendingQuestionRpcId = mint()
   let questionPending = true
-  /** Per-session permission preset (fixture mirror of the host permission select). */
-  const permissionValues = new Map<SessionId, string>()
-  const PERMISSION_OPTIONS = [
-    { value: 'workspace-write', name: 'workspace-write', description: 'Write inside the workspace and permitted temporary directories; wider retries require approval.' },
-    { value: 'danger-full-access', name: 'danger-full-access', description: 'Full file access without approval prompts.' },
-  ]
   const fixtureQuestions: Extract<MuxFrame, { type: 'question/requested' }>['questions'] = [
     {
       id: 'harness-profile',
@@ -839,24 +833,6 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
         }
         return ok(request, { accepted: true as const })
       },
-      permissions: (request) => {
-        const { sessionId: id } = request.payload
-        if (summaryOf(id) === undefined) {
-          return err(request, { code: 'session-not-found', message: `no session ${id}`, details: { sessionId: id } })
-        }
-        return ok(request, { options: PERMISSION_OPTIONS, currentValue: permissionValues.get(id) ?? 'workspace-write' })
-      },
-      setPermission: (request) => {
-        const { sessionId: id, value } = request.payload
-        if (summaryOf(id) === undefined) {
-          return err(request, { code: 'session-not-found', message: `no session ${id}`, details: { sessionId: id } })
-        }
-        if (!PERMISSION_OPTIONS.some(option => option.value === value)) {
-          return err(request, { code: 'bad-request', message: `unknown permission value ${JSON.stringify(value)}`, details: { issues: [] } })
-        }
-        permissionValues.set(id, value)
-        return ok(request, { currentValue: value })
-      },
     },
     host: {
       describe: request => ok(request, { version: '0.0.0-fixture', cwd: '/tmp/fixture', attachedSessions }),
@@ -1134,8 +1110,6 @@ export class FixtureApiClient extends AbstractApiClient {
       case 'session.selectModel': return this.api.sessions.selectModel(request)
       case 'session.prompt': return this.api.sessions.prompt(request)
       case 'session.cancel': return this.api.sessions.cancel(request)
-      case 'session.permissions': return this.api.sessions.permissions(request)
-      case 'session.setPermission': return this.api.sessions.setPermission(request)
       case 'host.describe': return this.api.host.describe(request)
       case 'host.pickDirectory': return this.api.host.pickDirectory(request, new AbortController().signal)
       case 'host.openPath': return this.api.host.openPath(request, new AbortController().signal)

packages/client/connection/src/client/index.ts

@@ -12,7 +12,7 @@ import { WebApiClient } from './web-api-client.ts'
 // ---- Contract re-exports (browser-safe apiproxy channels + core types) ----
 export type {
   ApiProxy, SessionsApi, SessionSummary, HostApi, EventsApi, MuxFrame, HostFrame,
-  ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, PermissionOption, ToolEventView,
+  ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView,
   ToolCallView, ToolResultView, WorkspaceApi, WorkspaceId, WorkspaceView,
   CommandsApi, CommandDescriptor, SkillsApi, SkillEntry,
   ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning,

packages/client/connection/tests/fake-api.ts

@@ -63,12 +63,6 @@ export class FakeApiClient implements IApiClient {
     payload => Promise.resolve(ok({ selected: { provider: payload.provider, model: payload.model } }))
   onPrompt: (payload: unknown) => Promise<RpcResponse<{ accepted: true }>> = () => Promise.resolve(ok({ accepted: true as const }))
   onCancel: (payload: unknown) => Promise<RpcResponse<{ accepted: true }>> = () => Promise.resolve(ok({ accepted: true as const }))
-  onPermissions: (payload: unknown) =>
-  Promise<RpcResponse<{ options: { value: string; name: string; description?: string }[]; currentValue: string }>> =
-    () => Promise.resolve(ok({ options: [], currentValue: 'custom' }))
-
-  onSetPermission: (payload: { sessionId: SessionId; value: string }) => Promise<RpcResponse<{ currentValue: string }>> =
-    payload => Promise.resolve(ok({ currentValue: payload.value }))
   onDescribe: (payload: unknown) => Promise<RpcResponse<{ version: string; cwd: string; attachedSessions: number }>> =
     () => Promise.resolve(ok({ version: '0-fake', cwd: '/f', attachedSessions: 0 }))
   onPickDirectory: (payload: unknown) => Promise<RpcResponse<{ path: string | null }>> =
@@ -92,8 +86,6 @@ export class FakeApiClient implements IApiClient {
       this.record('session.selectModel', payload, this.onSelectModel(payload)),
     prompt: (payload: unknown) => this.record('session.prompt', payload, this.onPrompt(payload)),
     cancel: (payload: unknown) => this.record('session.cancel', payload, this.onCancel(payload)),
-    permissions: (payload: unknown) => this.record('session.permissions', payload, this.onPermissions(payload)),
-    setPermission: (payload: { sessionId: SessionId; value: string }) => this.record('session.setPermission', payload, this.onSetPermission(payload)),
   }
 
   readonly host: IApiClient['host'] = {

packages/client/connection/tests/fixture.spec.ts

@@ -345,23 +345,6 @@ describe('createFixtureApi', () => {
     expect(replayed.some(f => f.type === 'approval/requested')).toBe(false)
   })
 
-  it('permissions/setPermission mirror the host select: read, switch, validation', async () => {
-    const api = createFixtureApi()
-    const read = await api.sessions.permissions(req({ sessionId: sid('fx-alpha') }))
-    expect(read.result).toMatchObject({ ok: true, value: { currentValue: 'workspace-write' } })
-    const switched = await api.sessions.setPermission(req({ sessionId: sid('fx-alpha'), value: 'danger-full-access' }))
-    expect(switched.result).toMatchObject({ ok: true, value: { currentValue: 'danger-full-access' } })
-    const reread = await api.sessions.permissions(req({ sessionId: sid('fx-alpha') }))
-    expect(reread.result).toMatchObject({ ok: true, value: { currentValue: 'danger-full-access' } })
-    // Validation: ghost session and unknown value.
-    const ghostRead = await api.sessions.permissions(req({ sessionId: sid('fx-ghost') }))
-    expect(ghostRead.result.ok).toBe(false)
-    const ghostSwitch = await api.sessions.setPermission(req({ sessionId: sid('fx-ghost'), value: 'workspace-write' }))
-    expect(ghostSwitch.result.ok).toBe(false)
-    const unknown = await api.sessions.setPermission(req({ sessionId: sid('fx-alpha'), value: 'nope' }))
-    expect(unknown.result.ok).toBe(false)
-  })
-
   it('describe answers the fixture identity', async () => {
     const api = createFixtureApi()
     const response = await api.host.describe(req({}))
@@ -739,8 +722,6 @@ describe('FixtureApiClient (protocol-level fake carrier)', () => {
     expect((await client.sessions.history({ sessionId: id })).result.ok).toBe(true)
     expect((await client.sessions.prompt({ sessionId: id, mode: 'queue', content: [{ type: 'text', text: '嗨' }] })).result.ok).toBe(true)
     expect((await client.sessions.cancel({ sessionId: id })).result.ok).toBe(true)
-    expect((await client.sessions.permissions({ sessionId: id })).result.ok).toBe(true)
-    expect((await client.sessions.setPermission({ sessionId: id, value: 'danger-full-access' })).result.ok).toBe(true)
     expect((await client.host.describe({})).result.ok).toBe(true)
     expect((await client.workspace.list({})).result.ok).toBe(true)
     const workspace = await client.workspace.create({ name: 'via-client' })