@sqdr2/dsh-fusion 0.3.0 → 0.3.3

package/src/host/native-role-sandbox.ts

@@ -3,11 +3,11 @@ import type { Agent } from '@deepseek-ai/dsh-agent'
 import { SessionId as NativeSessionId } from '@deepseek-ai/dsh-session'
 import type { Session } from '@deepseek-ai/dsh-session'
 import type { ToolExecution } from '@deepseek-ai/dsh-tools'
-import type { Role } from '../contracts.js'
+import type { Role, SandboxMode } from '../contracts.js'
 import type { SqliteFusionStore } from '../task/sqlite-store.js'
 import type { SessionBinding } from './bindings.js'
 
-type Mode = 'read-only' | 'workspace-write' | 'danger-full-access'
+type Mode = SandboxMode
 
 // Mirrors the Host sandbox-policy augmentation (a type-only declaration; the Host
 // registers the event at runtime). The plugin does not depend on that package.
@@ -36,6 +36,19 @@ interface Intent {
 
 export const roleSeparated = (binding: SessionBinding) => binding.profile.workflowPolicy === 'enforced-v3'
 
+const intentId = (sessionId: string) => `sandbox-intent:${sessionId}`
+
+/**
+ * The mode the user chose for a confined Fusion conversation, which is the mode
+ * the Sidekick runs under. Undefined until Fusion has confined the Lead, or after
+ * the conversation left Fusion and its own mode was restored.
+ */
+export function readSandboxIntent(store: SqliteFusionStore, sessionId: string): { mode: Mode } | undefined {
+  const intent = store.readDocument(intentId(sessionId))?.value as Intent | undefined
+  if (!intent || intent.schemaVersion !== 1 || !intent.active) return undefined
+  return { mode: intent.mode }
+}
+
 /**
  * Role separation enforced below the prompt: the Lead's session runs under the
  * Host's own read-only sandbox (bash and filesystem are refused by the OS
@@ -53,13 +66,12 @@ export class NativeRoleSandbox {
     return (this.ctx as unknown as { get(name: string): unknown }).get('sandboxPolicy') as SandboxPolicy | undefined
   }
 
-  #id(sessionId: string) { return `sandbox-intent:${sessionId}` }
   #intent(sessionId: string): Intent | undefined {
-    return this.store.readDocument(this.#id(sessionId))?.value as Intent | undefined
+    return this.store.readDocument(intentId(sessionId))?.value as Intent | undefined
   }
   #save(intent: Intent) {
-    const prior = this.store.readDocument(this.#id(intent.sessionId))
-    this.store.writeDocument(this.#id(intent.sessionId), prior?.revision ?? 0, { ...intent, ownSeqs: intent.ownSeqs.slice(-32) })
+    const prior = this.store.readDocument(intentId(intent.sessionId))
+    this.store.writeDocument(intentId(intent.sessionId), prior?.revision ?? 0, { ...intent, ownSeqs: intent.ownSeqs.slice(-32) })
   }
   // Session listeners run synchronously inside append, before the seq is known here.
   #writing = false

package/src/host/native-scopes.ts

@@ -7,7 +7,7 @@ import { requestOutputReservation } from '../context/guard.js'
 import type { PhysicalRoute, Role } from '../contracts.js'
 import type { SessionBinding } from './bindings.js'
 import { digestOf } from '../digest.js'
-import { FUSION_SELECTION_LABELS } from '../identity.js'
+import { isFusionSelectionLabel } from '../identity.js'
 import { fusionToolDiagnostic, projectRoleTools } from './tool-table.js'
 
 export interface FusionScopeCallbacks {
@@ -122,7 +122,7 @@ export class NativeFusionScopes {
       return { ...decision, messages: [...decision.messages.filter(message => {
         const source = message.source
         return !(source?.kind === 'model-selection' && source.form === 'notice'
-          && FUSION_SELECTION_LABELS.some(label => source.summary.endsWith(label)))
+          && isFusionSelectionLabel(source.summary))
       }).map(message =>
         this.callbacks.projectMessage?.(agent, entry.binding, role, message) ?? message), ...(taskContext ? [taskContext] : [])] }
     }, { prepend: true }))

package/src/host/native-selection.ts

@@ -5,30 +5,47 @@ import type { GenerateOptions, LlmModelInfo, LlmResolvedModelInfo, ModelModality
 import { SessionId } from '@deepseek-ai/dsh-session'
 import type {} from '@deepseek-ai/dsh-api-session-controller/types'
 import type { PhysicalRoute } from '../contracts.js'
-import { FUSION_MODEL, FUSION_PROVIDER, isCurrentFusionSelection, isFusionSelection } from '../identity.js'
+import { FUSION_MODEL, FUSION_PROVIDER, isCurrentFusionSelection, isFusionModel, isFusionSelection } from '../identity.js'
+import { modelOfProfileId } from './pairs.js'
 import type { ResolvedProfile } from '../profile/resolve.js'
 import type { FusionCoordinator } from './coordinator.js'
 
 export { FUSION_MODEL, FUSION_PROVIDER, isFusionSelection }
 
-/** Resolves the configured Lead's declared input modalities; undefined means unconfigured or unverifiable. */
-export type LeadInputModalities = () => Promise<readonly ModelModality[] | undefined>
+/** One combo as the native menu needs it: its id, its label and its Lead's modalities. */
+export interface FusionModelEntry {
+  readonly id: string
+  readonly name: string
+  readonly description?: string
+  readonly inputModalities: readonly ModelModality[]
+}
+
+/** Read every combo this Host currently advertises; empty means unconfigured. */
+export type FusionModels = () => Promise<readonly FusionModelEntry[]>
+
+const textOnly = [...new Set<ModelModality>(['text'])]
 
 /** Catalog-only local adapter; the native request is physically routed before dispatch. */
 export class FusionCatalogAdapter extends LlmAdapter {
-  constructor(private readonly leadInputModalities?: LeadInputModalities) { super() }
+  constructor(private readonly models?: FusionModels) { super() }
   override providerInfo(provider: string) { return { id: provider, name: 'Fusion' } }
   override async listModels(provider: string): Promise<readonly LlmModelInfo[]> {
-    // The Lead is the only role that reads user content, so the entry admits
-    // exactly what the configured Lead admits; text-only until it resolves.
-    const lead = (await this.leadInputModalities?.()) ?? []
-    return [{ provider, id: FUSION_MODEL, name: 'Fusion · 自动',
-      description: 'Lead 与 Worker 协作。在设置 → Fusion 中配置模型。',
-      inputModalities: [...new Set<ModelModality>(['text', ...lead])] }]
+    const declared = await this.models?.().catch(() => []) ?? []
+    // The Lead is the only role that reads user content, so an entry admits
+    // exactly what its own Lead admits; text-only until it resolves. An
+    // installation with no combo yet still offers the historical entry, so the
+    // menu can explain what to configure instead of hiding Fusion entirely.
+    const entries = declared.length ? declared
+      : [{ id: FUSION_MODEL, name: 'Fusion · 自动', inputModalities: textOnly }]
+    return entries.map(entry => ({ provider, id: entry.id, name: entry.name,
+      description: entry.description ?? 'Lead 与 Worker 协作。在设置 → Fusion 中配置模型。',
+      inputModalities: [...new Set<ModelModality>(['text', ...entry.inputModalities])] }))
   }
   override async resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo> {
-    if (provider !== FUSION_PROVIDER || model !== FUSION_MODEL) throw new Error('Unknown local Fusion selection')
-    return (await this.listModels(provider))[0]!
+    if (provider !== FUSION_PROVIDER || !isFusionModel(model)) throw new Error('Unknown local Fusion selection')
+    const declared = (await this.listModels(provider)).find(entry => entry.id === model)
+    if (!declared) throw new Error('Unknown local Fusion selection')
+    return declared
   }
   override async *stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
     throw new Error('Fusion 尚未就绪。请前往设置 → Fusion 配置 Lead 和 Worker。')
@@ -38,30 +55,57 @@ export class FusionCatalogAdapter extends LlmAdapter {
 /** Public native lifecycle integration. No model-menu replacement or Host patch. */
 export function installNativeFusionSelection(ctx: Context, input: {
   coordinator(): FusionCoordinator | undefined
-  profile(): ResolvedProfile | undefined
+  /** The frozen profile of one combo, or undefined when it cannot be used yet. */
+  profile(model: string): ResolvedProfile | undefined
+  /** Why one combo cannot run, for the message a blocked session shows. */
+  reason?(model: string): string | undefined
   selection(agent: Agent): PhysicalRoute | undefined
 }): () => void {
   const pending = new Map<string, Promise<void>>()
   const failures = new Map<string, string>()
   const desired = new Map<string, PhysicalRoute>()
   const selection = (agent: Agent) => desired.get(agent.id) ?? input.selection(agent)
-  const selected = (agent: Agent) => input.coordinator()?.bindings.read(agent.id)?.binding.selected === true
+  const binding = (agent: Agent) => input.coordinator()?.bindings.read(agent.id)?.binding
+  const selected = (agent: Agent) => binding(agent)?.selected === true
+  /** The combo a selected session is frozen to, or undefined when it runs no Fusion task. */
+  const runningCombo = (agent: Agent): string | undefined => {
+    const current = binding(agent)
+    return current?.selected ? modelOfProfileId(current.profile.id) ?? FUSION_MODEL : undefined
+  }
+  const blocked = (model: string) => input.reason?.(model) ?? '请先在设置 → Fusion 配置 Lead 和 Worker，再继续此会话。'
   const change = (agent: Agent) => {
     if (agent.session.header.parentSession || pending.has(agent.id)) return
-    const coordinator = input.coordinator(), profile = input.profile(), route = selection(agent)
+    const coordinator = input.coordinator(), route = selection(agent)
     if (!coordinator) return
     if (isFusionSelection(route)) {
-      if (!selected(agent) && profile) coordinator.selectBeforeAssembly(agent, profile)
+      const model = route?.model ?? FUSION_MODEL
+      const profile = input.profile(model), running = runningCombo(agent)
+      if (running !== undefined && running !== model) {
+        // Another combo was picked inside this conversation. Each combo freezes
+        // its own pair, so the drain is the same as leaving Fusion: the next
+        // turn starts a new task under the newly chosen combo.
+        const transition = (async () => {
+          if (agent.status !== 'idle') await coordinator.pause(agent)
+          await coordinator.clear(agent)
+          if (profile) coordinator.selectBeforeAssembly(agent, profile)
+          else failures.set(agent.id, blocked(model))
+        })().catch(error => { failures.set(agent.id, String(error)) }).finally(() => { pending.delete(agent.id) })
+        pending.set(agent.id, transition)
+        return
+      }
+      if (running === undefined) {
+        if (profile) coordinator.selectBeforeAssembly(agent, profile)
+        else failures.set(agent.id, blocked(model))
+      }
       if (selected(agent)) {
         // A saved Host default need not emit model/selection. Persist that
         // already-chosen intent before physical headers reach the native menu's
         // projection, otherwise it starts displaying the Lead as the selection.
-        // A session that named the entry before the rename keeps its task, but
-        // the route it stored no longer has an adapter; rewrite the intent so
-        // the next assembly dispatches under the registered name.
+        // A session that named the combo before a rename keeps its task, but the
+        // route it stored no longer has an adapter; rewrite the spelling only.
         const intent = agent.session.snapshotEvents().findLast(event => event.type === 'model/selection')
         if (!isCurrentFusionSelection(intent?.data)) agent.session.append('model/selection', {
-          provider: FUSION_PROVIDER, model: FUSION_MODEL,
+          provider: FUSION_PROVIDER, model,
         })
         failures.delete(agent.id)
       }
@@ -101,7 +145,7 @@ export function installNativeFusionSelection(ctx: Context, input: {
         // A newly installed exact-Agent interceptor can wrap this listener;
         // its physical route is applied after this continuation returns.
         // The catalog adapter itself cannot dispatch any upstream request.
-        if (!selected(agent)) throw new Error('请先在设置 → Fusion 配置 Lead 和 Worker，再继续此会话。')
+        if (!selected(agent)) throw new Error(blocked(route?.model ?? FUSION_MODEL))
       } else if (selected(agent)) throw new Error('先停止当前 Fusion 任务，再切换模型。')
       return config
     }, { prepend: true }),

package/src/host/native-worker-brief.ts

@@ -109,12 +109,25 @@ export function workerToolBriefProblem(store: SqliteFusionStore, taskId: TaskId,
   const message = native ?? (transport === undefined ? undefined
     : events?.findLast(event => event.type === 'assistant/message'
       && event.data.message.content.some(block => block.type === 'tool-call' && block.name === transport)))
-  if (!message || message.type !== 'assistant/message' || message.data.interrupted) return 'Worker tool requires a complete native model request'
-  const row = store.readDocument(`worker-request:${exec.agent!.id}:${message.data.turn}:${message.data.step}`)?.value as {
+  type WorkerRequestRow = {
     schemaVersion?: number; taskId?: string; sessionId?: string; turn?: number; step?: number; briefRevision?: number; workOrderId?: string
-  } | undefined
-  if (row?.schemaVersion !== 1 || row.taskId !== taskId || row.sessionId !== exec.agent!.id
-    || row.turn !== message.data.turn || row.step !== message.data.step) return 'Worker tool has no captured brief identity'
+  }
+  let row: WorkerRequestRow | undefined
+  if (message && message.type === 'assistant/message' && !message.data.interrupted) {
+    row = store.readDocument(`worker-request:${exec.agent!.id}:${message.data.turn}:${message.data.step}`)?.value as WorkerRequestRow | undefined
+    if (row?.schemaVersion !== 1 || row.taskId !== taskId || row.sessionId !== exec.agent!.id
+      || row.turn !== message.data.turn || row.step !== message.data.step) return 'Worker tool has no captured brief identity'
+  } else if (transport !== undefined) {
+    const ids = store.listDocumentIds(`worker-request:${exec.agent!.id}:`)
+    const rows = ids
+      .map(id => store.readDocument(id)?.value as WorkerRequestRow | undefined)
+      .filter((r): r is NonNullable<WorkerRequestRow> => Boolean(r && r.schemaVersion === 1 && r.taskId === taskId && r.sessionId === exec.agent!.id))
+    rows.sort((a, b) => (a.turn ?? 0) - (b.turn ?? 0) || (a.step ?? 0) - (b.step ?? 0))
+    row = rows.at(-1)
+    if (!row) return 'Worker tool has no captured brief identity'
+  } else {
+    return 'Worker tool requires a complete native model request'
+  }
   if (row.briefRevision !== revision) return 'A newer Lead brief superseded this request; process it before further tools or a report'
   const order = store.load(taskId)?.currentWorkOrder
   if (row.workOrderId !== order?.id && (row.workOrderId || order?.mode)) return 'A newer work order superseded this request; process its plan before further tools'

package/src/host/pairs.ts

@@ -0,0 +1,178 @@
+import { randomUUID } from 'node:crypto'
+import { bi } from '../bilingual.js'
+import { FUSION_MODEL, isFusionModel } from '../identity.js'
+import { keepaliveChoice } from '../profile/keepalive.js'
+import { compactorChoice } from '../profile/compactor.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import type { PairChoice, SettingsCatalog } from './settings.js'
+import { modelProfileFromChoice, validatePairChoice } from './settings.js'
+
+/**
+ * One saved combo: the model id the native menu advertises, the label beside
+ * it, and the pair that id freezes. The id is the durable identity — a session
+ * that selected it keeps its own frozen copy — so renaming never moves a combo.
+ */
+export interface PairEntry {
+  readonly id: string
+  readonly name: string
+  readonly pair: PairChoice
+}
+
+/** The saved combos, in menu order. `auto` is the historical first combo. */
+export interface PairsSnapshot {
+  readonly revision: number
+  readonly pairs: readonly PairEntry[]
+  /** True when these came from a pre-combo `settings:profile` document. */
+  readonly migrated: boolean
+}
+
+/** Where the combo list lives; `settings:profile` stays readable for migration. */
+export const PAIRS_DOCUMENT = 'settings:pairs'
+const LEGACY_PROFILE_DOCUMENT = 'settings:profile'
+
+/** Every menu entry costs one row in the native picker, so the list stays short. */
+export const MAX_PAIRS = 6
+export const MAX_PAIR_NAME = 40
+/** The migrated first combo keeps the label the historical entry had. */
+export const DEFAULT_PAIR_NAME = '自动'
+
+export const profileIdOf = (model: string): string => `fusion-${model}`
+
+/** The combo a frozen profile belongs to, or undefined for a non-combo profile. */
+export function modelOfProfileId(id: string): string | undefined {
+  const model = id.startsWith('fusion-') ? id.slice('fusion-'.length) : undefined
+  return isFusionModel(model) ? model : undefined
+}
+
+const newModel = (taken: readonly string[]): string => {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const model = `pair-${randomUUID().replace(/-/g, '').slice(0, 8)}`
+    if (!taken.includes(model)) return model
+  }
+  throw new Error(bi('无法生成新的组合标识', 'Could not allocate a new combo id'))
+}
+
+function object(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined
+}
+
+function route(value: unknown): PairChoice['lead'] | undefined {
+  const item = object(value)
+  if (!item || typeof item.provider !== 'string' || !item.provider.trim() || typeof item.model !== 'string' || !item.model.trim()) return undefined
+  return { provider: item.provider, model: item.model,
+    ...(typeof item.reasoningEffort === 'string' && item.reasoningEffort.trim() ? { reasoningEffort: item.reasoningEffort } : {}) }
+}
+
+/**
+ * Read one stored pair without the Host catalog: a combo whose model has since
+ * been retired must stay visible (and editable) instead of hiding the list.
+ */
+function structuralPair(value: unknown): PairChoice | undefined {
+  const raw = object(value)
+  const lead = route(raw?.lead), worker = route(raw?.worker)
+  if (!raw || !lead || !worker) return undefined
+  const compactorRoute = route(object(raw.compactor)?.route)
+  const maxOutputTokens = object(raw.compactor)?.maxOutputTokens
+  let cacheKeepalive: PairChoice['cacheKeepalive']
+  try { cacheKeepalive = keepaliveChoice(raw.cacheKeepalive) } catch { cacheKeepalive = undefined }
+  let compactor: PairChoice['compactor']
+  try { compactor = compactorRoute ? compactorChoice({ route: compactorRoute, maxOutputTokens }) : undefined } catch { compactor = undefined }
+  return { lead, worker, ...(compactor === undefined ? {} : { compactor }), ...(cacheKeepalive === undefined ? {} : { cacheKeepalive }) }
+}
+
+/** A pre-combo profile document as the choice it was saved from. */
+export function choiceFromStoredProfile(value: unknown): PairChoice | undefined {
+  const raw = object(value)
+  const pair = structuralPair(raw)
+  if (!raw || !pair) return undefined
+  if (raw.interactionMode === 'model-like') return pair
+  // Legacy profiles keep explicit per-role output limits in `context`.
+  const context = object(raw.context)
+  const outputTokens = Object.fromEntries((['lead', 'worker'] as const)
+    .map(role => [role, object(context?.[role])?.reserveOutputTokens] as const)
+    .filter(([, tokens]) => Number.isSafeInteger(tokens) && Number(tokens) > 0 && Number(tokens) !== 8_000)
+    .map(([role, tokens]) => [role, Number(tokens)]))
+  return Object.keys(outputTokens).length ? { ...pair, outputTokens } : pair
+}
+
+function parsePairs(value: unknown): PairEntry[] | undefined {
+  const raw = object(value)
+  if (!raw || raw.schemaVersion !== 1 || !Array.isArray(raw.pairs)) return undefined
+  const seen = new Set<string>()
+  return raw.pairs.flatMap((item): PairEntry[] => {
+    const entry = object(item)
+    const pair = structuralPair(entry?.pair)
+    if (!entry || !pair || typeof entry.id !== 'string' || !isFusionModel(entry.id) || seen.has(entry.id)) return []
+    if (typeof entry.name !== 'string' || !entry.name.trim() || entry.name.length > MAX_PAIR_NAME) return []
+    seen.add(entry.id)
+    return [{ id: entry.id, name: entry.name, pair }]
+  })
+}
+
+/** The saved combos; a pre-combo installation migrates to one `auto` combo on read. */
+export function readPairs(store: SqliteFusionStore): PairsSnapshot {
+  const document = store.readDocument(PAIRS_DOCUMENT)
+  if (document) {
+    const pairs = parsePairs(document.value)
+    if (!pairs?.length) throw new Error(bi('组合配置已损坏，请在 Fusion 页面重新保存', 'The combo list is unreadable; save it again from the Fusion page'))
+    return { revision: document.revision, pairs, migrated: false }
+  }
+  const legacy = choiceFromStoredProfile(store.readDocument(LEGACY_PROFILE_DOCUMENT)?.value)
+  // Revision 0 lets the first save create the document without a conflict.
+  return legacy ? { revision: 0, pairs: [{ id: FUSION_MODEL, name: DEFAULT_PAIR_NAME, pair: legacy }], migrated: true }
+    : { revision: 0, pairs: [], migrated: false }
+}
+
+export function pairName(value: unknown, fallback: string): string {
+  if (typeof value !== 'string') return fallback
+  const name = value.trim()
+  if (!name) return fallback
+  if (name.length > MAX_PAIR_NAME) throw new Error(bi(`组合名称最多 ${MAX_PAIR_NAME} 个字符`, `A combo name is at most ${MAX_PAIR_NAME} characters`))
+  return name
+}
+
+/**
+ * Validate the list a settings action proposes. Ids are assigned here, never by
+ * the client, so a stale tab cannot name a combo that is already frozen
+ * elsewhere; reordering only moves the menu rows.
+ */
+export function validatePairs(value: unknown, catalog: SettingsCatalog, existing: readonly PairEntry[]): PairEntry[] {
+  if (!Array.isArray(value) || !value.length) throw new Error(bi('请至少保留一个组合', 'Keep at least one combo'))
+  if (value.length > MAX_PAIRS) throw new Error(bi(`最多保存 ${MAX_PAIRS} 个组合`, `At most ${MAX_PAIRS} combos can be saved`))
+  const known = new Set(existing.map(pair => pair.id))
+  const taken = new Set<string>()
+  const names = new Set<string>()
+  return value.map((item, index) => {
+    const raw = object(item)
+    if (!raw) throw new Error(bi('组合配置无效', 'Invalid combo entry'))
+    // A frozen session keeps its own copy, so an id may be renamed or reordered
+    // freely; a new row (or a duplicate) gets an id this Host has never issued.
+    // `auto` is the reserved historical id, so the first combo may claim it even
+    // on a fresh installation: selections made before combos existed still name it.
+    const requested = typeof raw.id === 'string' ? raw.id : ''
+    const id = (known.has(requested) || requested === FUSION_MODEL) && !taken.has(requested) ? requested : newModel([...taken])
+    taken.add(id)
+    const name = pairName(raw.name, index === 0 ? DEFAULT_PAIR_NAME : `组合 ${index + 1}`)
+    if (names.has(name)) throw new Error(bi(`组合名称 "${name}" 重复`, `The combo name "${name}" is used twice`))
+    names.add(name)
+    return { id, name, pair: validatePairChoice(raw.pair, catalog) }
+  })
+}
+
+export function pairsDocument(pairs: readonly PairEntry[]): Record<string, unknown> {
+  return { schemaVersion: 1, pairs: pairs.map(({ id, name, pair }) => ({ id, name, pair })) }
+}
+
+/**
+ * Persist the list under one compare-and-swap revision. The first combo is
+ * mirrored into the pre-combo `settings:profile` document so an older tab (or a
+ * downgrade) still finds the pair it knows about.
+ */
+export function writePairs(store: SqliteFusionStore, expectedRevision: number, pairs: readonly PairEntry[]): number {
+  const mirror = pairs.find(pair => pair.id === FUSION_MODEL) ?? pairs[0]!
+  const legacy = store.readDocument(LEGACY_PROFILE_DOCUMENT)
+  return store.writeDocuments([
+    { id: PAIRS_DOCUMENT, expectedRevision, value: pairsDocument(pairs) },
+    { id: LEGACY_PROFILE_DOCUMENT, expectedRevision: legacy?.revision ?? 0, value: modelProfileFromChoice(mirror.pair, profileIdOf(mirror.id)) },
+  ])[0]!
+}

package/src/host/settings.ts

@@ -66,19 +66,23 @@ export function validatePairChoice(value: unknown, catalog: SettingsCatalog): Pa
 /** New sessions can opt into this Worker cap. Frozen sessions keep their saved profile. */
 export const WORKER_IMPLEMENTATION_OUTPUT_TOKENS = 128_000
 
-export function profileFromChoice(pair: PairChoice): Record<string, unknown> {
+export function profileFromChoice(pair: PairChoice, id = 'fusion-auto'): Record<string, unknown> {
   const { outputTokens, ...routes } = pair
   const version = outputTokens?.worker === WORKER_IMPLEMENTATION_OUTPUT_TOKENS ? '0.1.0-worker-128k' : '0.1.0-faithful'
-  return { schemaVersion: 1, id: 'fusion-auto', version, enabled: true, quality: 'experimental',
+  return { schemaVersion: 1, id, version, enabled: true, quality: 'experimental',
     ...routes, workerUpgradePath: [], dataPolicyId: 'native-host-workspace-policy', evidenceCampaignIds: [],
     ...(outputTokens === undefined ? {} : { context: Object.fromEntries(Object.entries(outputTokens)
       .map(([role, reserveOutputTokens]) => [role, { reserveOutputTokens }])) }) }
 }
 
-/** Product defaults; explicit legacy/benchmark profiles retain their old contract. */
-export function modelProfileFromChoice(pair: PairChoice): Record<string, unknown> {
+/**
+ * Product defaults; explicit legacy/benchmark profiles retain their old contract.
+ * `id` names the combo; the first one keeps the historical `fusion-auto` so a
+ * profile frozen before combos existed keeps its identity.
+ */
+export function modelProfileFromChoice(pair: PairChoice, id = 'fusion-auto'): Record<string, unknown> {
   const { outputTokens: _output, ...native } = pair
-  return { ...profileFromChoice(native), version: '0.2.0-enforced-v3', interactionMode: 'model-like', workflowPolicy: 'enforced-v3' }
+  return { ...profileFromChoice(native, id), version: '0.2.0-enforced-v3', interactionMode: 'model-like', workflowPolicy: 'enforced-v3' }
 }
 
 /** Keep existing default settings stable; expose explicit larger/smaller limits on reload. */

package/src/host/status.ts

@@ -1,4 +1,6 @@
 import { readModelControl } from './native-model-control.js'
+import { readSandboxIntent, roleSeparated } from './native-role-sandbox.js'
+import type { Phase, Role } from '../contracts.js'
 import type { TaskState } from '../task/state.js'
 import type { SqliteFusionStore } from '../task/sqlite-store.js'
 import type { StatusIndex } from '../task/status-index.js'
@@ -27,6 +29,18 @@ const EN: Record<string, string> = {
 }
 const english = (text: string | null | undefined) => text == null ? text : EN[text] ?? text
 
+/**
+ * The role working right now: an in-flight request names it exactly (requests read
+ * newest first), and between requests the phase does ('DIRECT' is the Lead writing).
+ */
+function activeRole(requests: readonly { role: Role; purpose: string; outcome: string }[], phase: Phase): Role | null {
+  const running = requests.find(request => request.purpose === 'conversation' && request.outcome === 'entered')
+  if (running) return running.role
+  if (phase === 'WORKER_RUNNING' || phase === 'REWORK') return 'worker'
+  if (phase === 'PLANNING' || phase === 'REVIEWING' || phase === 'DIRECT') return 'lead'
+  return null
+}
+
 export function taskStage(state: TaskState, checking: boolean, workerStepLimitReached = false, workerQuotaExhausted = false): Pick<NonNullable<FusionStatus['task']>, 'stage' | 'detail' | 'attention'> {
   const control = state.control
   const value = (stage: string, detail: string | null = null, attention = false) => ({ stage, detail, attention })
@@ -81,7 +95,8 @@ function readStatus(store: SqliteFusionStore, sessionId: string, index: StatusIn
   const { checking, ...facts } = index.read(taskId)
   const runtime = store.readDocument(`runtime:${taskId}`)?.value as { schemaVersion?: number; taskId?: string;
     workerStepStop?: { workOrderId?: string; requests: number; limit: number };
-    workerFailure?: { workOrderId?: string; childId?: string; category?: string } } | undefined
+    workerFailure?: { workOrderId?: string; childId?: string; category?: string };
+    takeover?: boolean } | undefined
   const stop = runtime?.workerStepStop
   const workerStepLimitReached = runtime?.schemaVersion === 1 && runtime.taskId === taskId && Boolean(stop
     && state.currentWorkOrder && stop.workOrderId === state.currentWorkOrder.id && stop.limit > 0 && stop.requests >= stop.limit)
@@ -98,10 +113,18 @@ function readStatus(store: SqliteFusionStore, sessionId: string, index: StatusIn
   const pendingDelivery = modelControl?.operation && ['prepared', 'dispatching'].includes(modelControl.operation.state)
     ? { stage: '等待检查', detail: '继续消息的投递结果尚未确认。检查会话后使用 /fusion recover 提交检查记录。', attention: true } : {}
   const stage = { ...taskStage(state, checking, workerStepLimitReached, workerQuotaExhausted), ...modelStage, ...pendingDelivery }
+  // The composer's own permission control follows the conversation (Lead) session,
+  // where Fusion's read-only confinement matches no configured preset. Report the
+  // per-role modes so the UI can name the permission of the role that is working.
+  const intent = roleSeparated(binding) ? readSandboxIntent(store, sessionId) : undefined
+  const takeover = runtime?.schemaVersion === 1 && runtime.taskId === taskId && runtime.takeover === true
+  const permissions = intent && { lead: takeover ? intent.mode : 'read-only' as const,
+    worker: intent.mode, active: activeRole(facts.requests, state.phase) }
   return { ...base, task: { id: taskId, revision: state.revision, ...stage, stageEn: english(stage.stage)!,
     detailEn: 'detailEn' in stage && stage.detailEn ? stage.detailEn : english(stage.detail) ?? null, ...(modelControl ? { modelControl } : {}), verification: state.verification,
     workerId: state.acceptedChild ?? binding.workerId ?? null,
     models: { lead: modelControl?.routes.lead ?? binding.profile.lead, worker: modelControl?.routes.worker ?? binding.profile.worker, compactor: binding.profile.compactor?.route ?? null },
+    ...(permissions ? { permissions } : {}),
     ...facts,
     automatedChecks: Array.isArray((runtime as { checks?: unknown[] } | undefined)?.checks) && runtime?.taskId === taskId
       ? (runtime as { checks: unknown[] }).checks.length : null,

package/src/identity.ts

@@ -33,12 +33,30 @@ export const PLUGIN_NAME = 'dsh-fusion'
 /** The plugin id and package name this project used before the rename. */
 export const LEGACY_PLUGIN_NAME = 'dsh-model-fusion'
 
-/** Registered provider route for the Fusion model entry. */
+/** Registered provider route for the Fusion model entries. */
 export const FUSION_PROVIDER = 'dsh-fusion'
 
-/** The single model id the Fusion entry advertises. */
+/**
+ * The model id of the combo every installation starts with.
+ *
+ * It is a pair id like any other; keeping this exact spelling for the first
+ * combo means a durable `model/selection` written before combos existed still
+ * names a combo that exists.
+ */
 export const FUSION_MODEL = 'auto'
 
+/**
+ * The model ids this provider advertises: `auto` plus one generated
+ * `pair-xxxxxxxx` per additional combo. The browser bundle inlines this module,
+ * so the namespace shape is fixed here rather than read from a settings
+ * document at import time.
+ */
+const FUSION_MODEL_PATTERN = /^(?:auto|pair-[a-z0-9]{6,12})$/
+
+/** Whether a model id names a Fusion combo on this provider. */
+export const isFusionModel = (model: string | undefined): boolean =>
+  typeof model === 'string' && FUSION_MODEL_PATTERN.test(model)
+
 /**
  * The provider route this plugin registered before it was renamed from
  * `dsh-model-fusion`. Sessions created then still name it in their durable
@@ -51,26 +69,31 @@ export const LEGACY_FUSION_PROVIDER = 'dsh-model-fusion'
 export const isFusionProvider = (provider: string | undefined): boolean =>
   provider === FUSION_PROVIDER || provider === LEGACY_FUSION_PROVIDER
 
-/** Whether a route names the Fusion entry, under either name. */
+/** Whether a route names a Fusion combo, under either provider spelling. */
 export const isFusionSelection = (route: { provider?: string; model?: string } | undefined): boolean =>
-  isFusionProvider(route?.provider) && route?.model === FUSION_MODEL
+  isFusionProvider(route?.provider) && isFusionModel(route?.model)
 
 /**
- * How a native model-switch notice names this entry (`provider/model`).
+ * How a native model-switch notice names a combo: `provider/model`, or the bare
+ * model when both sides share this provider (switching from one combo to
+ * another).
  *
- * Both spellings are listed: a session that switched to Fusion before the
- * rename carries the old one in its durable log, and the notice is the same
- * non-change on every Fusion step either way.
+ * The notice is a pseudo-change: it compares the virtual menu route with the
+ * physical Lead route that actually dispatches, so it would otherwise repeat on
+ * every Fusion step. Both provider spellings are accepted because a session
+ * that switched to Fusion before the rename carries the old one in its durable
+ * log; any combo id matches, since combos are not physical models.
  */
-export const FUSION_SELECTION_LABELS = [
-  `${FUSION_PROVIDER}/${FUSION_MODEL}`,
-  `${LEGACY_FUSION_PROVIDER}/${FUSION_MODEL}`,
-] as const
+const FUSION_SELECTION_LABEL_PATTERN = /(?:(?:dsh-fusion|dsh-model-fusion)\/|→ )(?:auto|pair-[a-z0-9]{6,12})$/
+
+/** Whether a switch-notice summary describes a Fusion combo as either side. */
+export const isFusionSelectionLabel = (summary: string | undefined): boolean =>
+  typeof summary === 'string' && FUSION_SELECTION_LABEL_PATTERN.test(summary)
 
 /**
- * Whether a route already names the entry under its current name. A durable
- * intent that fails this is rewritten before the next request is assembled;
- * the legacy spelling is a read-side alias, not a route that still dispatches.
+ * Whether a route already names a combo under its current provider spelling. A
+ * durable intent that fails this is rewritten before the next request is
+ * assembled; the legacy spelling is a read-side alias, not a dispatching route.
  */
 export const isCurrentFusionSelection = (route: { provider?: string; model?: string } | undefined): boolean =>
-  route?.provider === FUSION_PROVIDER && route.model === FUSION_MODEL
+  route?.provider === FUSION_PROVIDER && isFusionModel(route.model)

package/src/status.ts

@@ -1,5 +1,5 @@
 import type { ControlView } from './host/native-model-control.js'
-import type { PhysicalRoute, Role, TokenMeasurement, VerificationLevel } from './contracts.js'
+import type { PhysicalRoute, Role, SandboxMode, TokenMeasurement, VerificationLevel } from './contracts.js'
 
 /** Bounded, read-only UI projection. No prompts, tool arguments or credentials. */
 export interface FusionStatus {
@@ -20,6 +20,22 @@ export interface FusionStatus {
     workerId: string | null
     modelControl?: ControlView
     models: { lead: PhysicalRoute; worker: PhysicalRoute; compactor: PhysicalRoute | null }
+    /**
+     * Role-separated sandbox modes, present while Fusion confines the Lead. The
+     * composer's own permission control follows the conversation (Lead) session,
+     * so the UI shows these instead of the derived preset name.
+     */
+    permissions?: {
+      /**
+       * What the Lead's own work is confined to. The session is widened only for the
+       * checks Fusion runs itself and for the Lead during a Host-unlocked takeover.
+       */
+      lead: SandboxMode
+      /** What the Sidekick runs under: the mode the user chose for this conversation. */
+      worker: SandboxMode
+      /** The role working right now; null while the task waits. */
+      active: Role | null
+    }
     usage: {
       calls: number
       finalCalls: number