@harness-mix/cli 0.1.3

package/src/native-ui/renderer-extension/src/agent-selection-state.ts

@@ -0,0 +1,627 @@
+import type {
+  HarnessModelRef,
+  HarnessPermissionModeId,
+  HarnessThinkingOptionId,
+} from "@codexhost/shared-contracts";
+
+export const KNOWN_RENDERER_AGENTS = [
+  "codex",
+  "pi",
+  "claude-code",
+  "deepseek-harness",
+  "opencode",
+  "grok",
+  "omp",
+  "antigravity",
+  "kiro-cli",
+  "openclaw",
+  "hermes",
+  "qoder",
+  "codebuddy",
+  "zcode",
+  "trae",
+  "cursor-cli",
+  "codex-harness",
+] as const;
+export const DEFAULT_RENDERER_AGENTS = [
+  'codex',
+  'pi',
+  'omp',
+  'claude-code',
+  'deepseek-harness',
+  'antigravity',
+  'opencode',
+  'grok',
+  'openclaw',
+  'hermes',
+  'qoder',
+  'codebuddy',
+  'zcode',
+  'trae',
+  'cursor-cli',
+  'kiro-cli',
+  'codex-harness',
+] as const;
+export type RendererAgent = (typeof KNOWN_RENDERER_AGENTS)[number];
+export type ExternalRendererAgent = Exclude<RendererAgent, "codex">;
+export type RendererAgentAvailability =
+  "checking" | "ready" | "notInstalled" | "unavailable" | "error";
+export type ComposerAgentPhase = "draft" | "locked";
+
+export interface DraftComposerState {
+  agent: RendererAgent;
+  phase: ComposerAgentPhase;
+  composerId: string;
+  codexAccountId?: string;
+  piModel?: HarnessModelRef;
+  piThinkingOptionId?: HarnessThinkingOptionId;
+  claudeModel?: HarnessModelRef;
+  claudeThinkingOptionId?: HarnessThinkingOptionId;
+  deepSeekHarnessModel?: HarnessModelRef;
+  openCodeModel?: HarnessModelRef;
+  openCodeThinkingOptionId?: HarnessThinkingOptionId;
+  grokModel?: HarnessModelRef;
+  grokThinkingOptionId?: HarnessThinkingOptionId;
+  ompModel?: HarnessModelRef;
+  ompThinkingOptionId?: HarnessThinkingOptionId;
+  antigravityModel?: HarnessModelRef;
+  antigravityThinkingOptionId?: HarnessThinkingOptionId;
+  kiroCliModel?: HarnessModelRef;
+  kiroCliThinkingOptionId?: HarnessThinkingOptionId;
+  openclawModel?: HarnessModelRef;
+  openclawThinkingOptionId?: HarnessThinkingOptionId;
+  hermesModel?: HarnessModelRef;
+  hermesThinkingOptionId?: HarnessThinkingOptionId;
+  qoderModel?: HarnessModelRef;
+  qoderThinkingOptionId?: HarnessThinkingOptionId;
+  codebuddyModel?: HarnessModelRef;
+  codebuddyThinkingOptionId?: HarnessThinkingOptionId;
+  zcodeModel?: HarnessModelRef;
+  zcodeThinkingOptionId?: HarnessThinkingOptionId;
+  traeModel?: HarnessModelRef;
+  cursorModel?: HarnessModelRef;
+  traeThinkingOptionId?: HarnessThinkingOptionId;
+  cursorThinkingOptionId?: HarnessThinkingOptionId;
+  codexHarnessModel?: HarnessModelRef;
+  codexHarnessThinkingOptionId?: HarnessThinkingOptionId;
+  permissionModeByAgent?: Partial<Record<ExternalRendererAgent, HarnessPermissionModeId>>;
+}
+
+type MutableComposerState = DraftComposerState;
+
+interface ConversationState {
+  target: readonly unknown[];
+  state: MutableComposerState;
+}
+
+export interface DraftAgentControllerOptions {
+  idFactory?: (sequence: number) => string;
+  enabledAgents?: readonly RendererAgent[];
+  defaultAgent?: RendererAgent;
+}
+
+export interface DraftAgentSwitchOperations {
+  applyAgent(agent: RendererAgent): boolean;
+  clearPrewarm(): Promise<void>;
+}
+
+function defaultIdFactory(sequence: number): string {
+  return `codexhost-composer-${Date.now().toString(36)}-${sequence.toString(36)}`;
+}
+
+function isDefaultTarget(target: readonly unknown[] | null): target is readonly unknown[] {
+  return target?.[0] === "default";
+}
+
+function isConversationTarget(target: readonly unknown[] | null): target is readonly unknown[] {
+  return target?.[0] === "conversation";
+}
+
+function sameTarget(left: readonly unknown[], right: readonly unknown[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+export class DraftAgentController<Composer extends object> {
+  readonly #idFactory: (sequence: number) => string;
+  readonly #defaultAgent: RendererAgent;
+  readonly #enabledAgents: ReadonlySet<RendererAgent>;
+  readonly #conversationStates: ConversationState[] = [];
+  readonly #modelRequestGenerations = new WeakMap<MutableComposerState, number>();
+  readonly #ownershipRequestGenerations = new WeakMap<MutableComposerState, number>();
+  readonly #states = new WeakMap<Composer, MutableComposerState>();
+  readonly #switching = new Set<MutableComposerState>();
+  readonly #pendingSubmissions = new Set<MutableComposerState>();
+  #composerSequence = 0;
+  #modelRequestSequence = 0;
+  #ownershipRequestSequence = 0;
+  #lastSubmittedAgent: RendererAgent;
+
+  constructor(options: DraftAgentControllerOptions = {}) {
+    this.#idFactory = options.idFactory ?? defaultIdFactory;
+    this.#enabledAgents = new Set(options.enabledAgents ?? DEFAULT_RENDERER_AGENTS);
+    if (!this.#enabledAgents.has("codex")) {
+      throw new Error("Renderer enabled Agents must include Codex");
+    }
+    this.#defaultAgent = options.defaultAgent ?? "codex";
+    if (!this.#enabledAgents.has(this.#defaultAgent)) {
+      throw new Error("Renderer default Agent must be enabled");
+    }
+    this.#lastSubmittedAgent = this.#defaultAgent;
+  }
+
+  get(composer: Composer): Readonly<DraftComposerState> {
+    return this.#state(composer);
+  }
+
+  mount(
+    composer: Composer,
+    target: readonly unknown[] | null,
+    preferredNewThreadAgent?: RendererAgent,
+  ): Readonly<DraftComposerState> {
+    const bound = this.#conversationState(target);
+    if (bound) {
+      this.#states.set(composer, bound);
+      return bound;
+    }
+    const preferredAgent =
+      preferredNewThreadAgent && this.#enabledAgents.has(preferredNewThreadAgent)
+        ? preferredNewThreadAgent
+        : this.#lastSubmittedAgent;
+    const state = this.#state(composer, isDefaultTarget(target) ? preferredAgent : "codex");
+    if (isConversationTarget(target)) {
+      this.#conversationStates.push({ target, state });
+    }
+    return state;
+  }
+
+  isSwitching(composer: Composer): boolean {
+    return this.#switching.has(this.#state(composer));
+  }
+
+  beginModelRequest(composer: Composer): number {
+    const state = this.#state(composer);
+    const generation = ++this.#modelRequestSequence;
+    this.#modelRequestGenerations.set(state, generation);
+    return generation;
+  }
+
+  invalidateModelRequests(composer: Composer): void {
+    this.beginModelRequest(composer);
+  }
+
+  isCurrentModelRequest(composer: Composer, generation: number): boolean {
+    return (this.#modelRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
+  }
+
+  beginOwnershipRequest(composer: Composer): number {
+    const state = this.#state(composer);
+    const generation = ++this.#ownershipRequestSequence;
+    this.#ownershipRequestGenerations.set(state, generation);
+    return generation;
+  }
+
+  isCurrentOwnershipRequest(composer: Composer, generation: number): boolean {
+    return (this.#ownershipRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
+  }
+
+  rebindConversation(
+    composer: Composer,
+    target: readonly unknown[] | null,
+  ): Readonly<DraftComposerState> | null {
+    if (!isConversationTarget(target)) return null;
+    const previous = this.#state(composer);
+    this.#pendingSubmissions.delete(previous);
+    this.#modelRequestGenerations.set(previous, ++this.#modelRequestSequence);
+    this.#ownershipRequestGenerations.set(previous, ++this.#ownershipRequestSequence);
+
+    let state = this.#conversationState(target);
+    if (!state) {
+      state = {
+        agent: "codex",
+        phase: "draft",
+        composerId: this.#idFactory(++this.#composerSequence),
+      };
+      this.#conversationStates.push({ target, state });
+    }
+    this.#states.set(composer, state);
+    this.#modelRequestGenerations.set(state, ++this.#modelRequestSequence);
+    this.#ownershipRequestGenerations.set(state, ++this.#ownershipRequestSequence);
+    return state;
+  }
+
+  restore(
+    composer: Composer,
+    agent: RendererAgent,
+    model?: HarnessModelRef,
+    thinkingOptionId?: HarnessThinkingOptionId,
+    permissionModeId?: HarnessPermissionModeId,
+    codexAccountId?: string,
+  ): Readonly<DraftComposerState> | null {
+    if (!this.#enabledAgents.has(agent)) return null;
+    const state = this.#state(composer);
+    this.#pendingSubmissions.delete(state);
+    state.agent = agent;
+    state.phase = "locked";
+    if (agent === "codex" && codexAccountId) state.codexAccountId = codexAccountId;
+    else delete state.codexAccountId;
+    if (agent === "pi" && model) state.piModel = model;
+    if (agent === "claude-code" && model) state.claudeModel = model;
+    if (agent === "deepseek-harness" && model) state.deepSeekHarnessModel = model;
+    if (agent === "opencode" && model) state.openCodeModel = model;
+    if (agent === "grok" && model) state.grokModel = model;
+    if (agent === "omp" && model) state.ompModel = model;
+    if (agent === "antigravity" && model) state.antigravityModel = model;
+    if (agent === "kiro-cli" && model) state.kiroCliModel = model;
+    if (agent === "openclaw" && model) state.openclawModel = model;
+    if (agent === "hermes" && model) state.hermesModel = model;
+    if (agent === "qoder" && model) state.qoderModel = model;
+    if (agent === "codebuddy" && model) state.codebuddyModel = model;
+    if (agent === "zcode" && model) state.zcodeModel = model;
+    if (agent === "trae" && model) state.traeModel = model;
+    if (agent === "cursor-cli" && model) state.cursorModel = model;
+    if (agent === "codex-harness" && model) state.codexHarnessModel = model;
+    if (agent === "pi" && thinkingOptionId) state.piThinkingOptionId = thinkingOptionId;
+    else if (agent === "pi") delete state.piThinkingOptionId;
+    if (agent === "claude-code" && thinkingOptionId) {
+      state.claudeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "claude-code") delete state.claudeThinkingOptionId;
+    if (agent === "grok" && thinkingOptionId) state.grokThinkingOptionId = thinkingOptionId;
+    else if (agent === "grok") delete state.grokThinkingOptionId;
+    if (agent === "opencode" && thinkingOptionId) {
+      state.openCodeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "opencode") delete state.openCodeThinkingOptionId;
+    if (agent === "omp" && thinkingOptionId) state.ompThinkingOptionId = thinkingOptionId;
+    else if (agent === "omp") delete state.ompThinkingOptionId;
+    if (agent === "antigravity" && thinkingOptionId) {
+      state.antigravityThinkingOptionId = thinkingOptionId;
+    } else if (agent === "antigravity") delete state.antigravityThinkingOptionId;
+    if (agent === "kiro-cli" && thinkingOptionId) {
+      state.kiroCliThinkingOptionId = thinkingOptionId;
+    } else if (agent === "kiro-cli") delete state.kiroCliThinkingOptionId;
+    if (agent === "openclaw" && thinkingOptionId) {
+      state.openclawThinkingOptionId = thinkingOptionId;
+    } else if (agent === "openclaw") delete state.openclawThinkingOptionId;
+    if (agent === "hermes" && thinkingOptionId) {
+      state.hermesThinkingOptionId = thinkingOptionId;
+    } else if (agent === "hermes") delete state.hermesThinkingOptionId;
+    if (agent === "qoder" && thinkingOptionId) {
+      state.qoderThinkingOptionId = thinkingOptionId;
+    } else if (agent === "qoder") delete state.qoderThinkingOptionId;
+    if (agent === "codebuddy" && thinkingOptionId) {
+      state.codebuddyThinkingOptionId = thinkingOptionId;
+    } else if (agent === "codebuddy") delete state.codebuddyThinkingOptionId;
+    if (agent === "zcode" && thinkingOptionId) {
+      state.zcodeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "zcode") delete state.zcodeThinkingOptionId;
+    if (agent === "trae" && thinkingOptionId) {
+      state.traeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "trae") delete state.traeThinkingOptionId;
+    if (agent === "cursor-cli" && thinkingOptionId) {
+      state.cursorThinkingOptionId = thinkingOptionId;
+    } else if (agent === "cursor-cli") delete state.cursorThinkingOptionId;
+    if (agent === 'codex-harness' && thinkingOptionId) state.codexHarnessThinkingOptionId = thinkingOptionId;
+    else if (agent === 'codex-harness') delete state.codexHarnessThinkingOptionId;
+    if (agent !== "codex") {
+      const permissionModeByAgent: NonNullable<DraftComposerState["permissionModeByAgent"]> = {};
+      for (const candidate of [
+        "pi",
+        "claude-code",
+        "deepseek-harness",
+        "opencode",
+        "grok",
+        "omp",
+        "antigravity",
+        "kiro-cli",
+        "openclaw",
+        "hermes",
+        "qoder",
+        "codebuddy",
+        "zcode",
+        "trae",
+        "cursor-cli",
+        "codex-harness",
+      ] as const) {
+        const current = state.permissionModeByAgent?.[candidate];
+        if (candidate !== agent && current) permissionModeByAgent[candidate] = current;
+      }
+      if (permissionModeId) permissionModeByAgent[agent] = permissionModeId;
+      if (Object.keys(permissionModeByAgent).length > 0) {
+        state.permissionModeByAgent = permissionModeByAgent;
+      } else {
+        delete state.permissionModeByAgent;
+      }
+    }
+    return state;
+  }
+
+  modelForAgent(composer: Composer, agent: RendererAgent): HarnessModelRef | undefined {
+    const state = this.#state(composer);
+    if (agent === "pi") return state.piModel;
+    if (agent === "claude-code") return state.claudeModel;
+    if (agent === "deepseek-harness") return state.deepSeekHarnessModel;
+    if (agent === "opencode") return state.openCodeModel;
+    if (agent === "grok") return state.grokModel;
+    if (agent === "omp") return state.ompModel;
+    if (agent === "antigravity") return state.antigravityModel;
+    if (agent === "kiro-cli") return state.kiroCliModel;
+    if (agent === "openclaw") return state.openclawModel;
+    if (agent === "hermes") return state.hermesModel;
+    if (agent === "qoder") return state.qoderModel;
+    if (agent === "codebuddy") return state.codebuddyModel;
+    if (agent === "zcode") return state.zcodeModel;
+    if (agent === "trae") return state.traeModel;
+    if (agent === "cursor-cli") return state.cursorModel;
+    if (agent === 'codex-harness') return state.codexHarnessModel;
+    return undefined;
+  }
+
+  thinkingOptionForAgent(
+    composer: Composer,
+    agent: ExternalRendererAgent,
+  ): HarnessThinkingOptionId | undefined {
+    const state = this.#state(composer);
+    if (agent === "pi") return state.piThinkingOptionId;
+    if (agent === "claude-code") return state.claudeThinkingOptionId;
+    if (agent === "grok") return state.grokThinkingOptionId;
+    if (agent === "opencode") return state.openCodeThinkingOptionId;
+    if (agent === "omp") return state.ompThinkingOptionId;
+    if (agent === "antigravity") return state.antigravityThinkingOptionId;
+    if (agent === "kiro-cli") return state.kiroCliThinkingOptionId;
+    if (agent === "openclaw") return state.openclawThinkingOptionId;
+    if (agent === "hermes") return state.hermesThinkingOptionId;
+    if (agent === "qoder") return state.qoderThinkingOptionId;
+    if (agent === "codebuddy") return state.codebuddyThinkingOptionId;
+    if (agent === "zcode") return state.zcodeThinkingOptionId;
+    if (agent === "trae") return state.traeThinkingOptionId;
+    if (agent === "cursor-cli") return state.cursorThinkingOptionId;
+    if (agent === 'codex-harness') return state.codexHarnessThinkingOptionId;
+    return undefined;
+  }
+
+  permissionModeForAgent(
+    composer: Composer,
+    agent: ExternalRendererAgent,
+  ): HarnessPermissionModeId | undefined {
+    return this.#state(composer).permissionModeByAgent?.[agent];
+  }
+
+  setExternalPermissionMode(
+    composer: Composer,
+    agent: ExternalRendererAgent,
+    permissionModeId: HarnessPermissionModeId,
+  ): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    state.permissionModeByAgent = {
+      ...state.permissionModeByAgent,
+      [agent]: permissionModeId,
+    };
+    return state;
+  }
+
+  setExternalModel(
+    composer: Composer,
+    agent: ExternalRendererAgent,
+    model: HarnessModelRef,
+  ): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    if (agent === "pi") state.piModel = model;
+    else if (agent === "claude-code") state.claudeModel = model;
+    else if (agent === "deepseek-harness") state.deepSeekHarnessModel = model;
+    else if (agent === "opencode") state.openCodeModel = model;
+    else if (agent === "grok") state.grokModel = model;
+    else if (agent === "omp") state.ompModel = model;
+    else if (agent === "antigravity") state.antigravityModel = model;
+    else if (agent === "kiro-cli") state.kiroCliModel = model;
+    else if (agent === "openclaw") state.openclawModel = model;
+    else if (agent === "hermes") state.hermesModel = model;
+    else if (agent === "qoder") state.qoderModel = model;
+    else if (agent === "codebuddy") state.codebuddyModel = model;
+    else if (agent === "zcode") state.zcodeModel = model;
+    else if (agent === "trae") state.traeModel = model;
+    else if (agent === "cursor-cli") state.cursorModel = model;
+    else if (agent === 'codex-harness') state.codexHarnessModel = model;
+    return state;
+  }
+
+  setPiConfiguration(
+    composer: Composer,
+    model: HarnessModelRef,
+    thinkingOptionId?: HarnessThinkingOptionId,
+  ): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    state.piModel = model;
+    if (thinkingOptionId) state.piThinkingOptionId = thinkingOptionId;
+    else delete state.piThinkingOptionId;
+    return state;
+  }
+
+  setPiModel(composer: Composer, model: HarnessModelRef): Readonly<DraftComposerState> {
+    return this.setExternalModel(composer, "pi", model);
+  }
+
+  setExternalThinkingOption(
+    composer: Composer,
+    agent: ExternalRendererAgent,
+    thinkingOptionId?: HarnessThinkingOptionId,
+  ): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    if (agent === "pi" && thinkingOptionId) state.piThinkingOptionId = thinkingOptionId;
+    else if (agent === "pi") delete state.piThinkingOptionId;
+    else if (agent === "claude-code" && thinkingOptionId) {
+      state.claudeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "claude-code") {
+      delete state.claudeThinkingOptionId;
+    } else if (agent === "grok" && thinkingOptionId) {
+      state.grokThinkingOptionId = thinkingOptionId;
+    } else if (agent === "grok") {
+      delete state.grokThinkingOptionId;
+    } else if (agent === "opencode" && thinkingOptionId) {
+      state.openCodeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "opencode") {
+      delete state.openCodeThinkingOptionId;
+    } else if (agent === "omp" && thinkingOptionId) {
+      state.ompThinkingOptionId = thinkingOptionId;
+    } else if (agent === "omp") {
+      delete state.ompThinkingOptionId;
+    } else if (agent === "antigravity" && thinkingOptionId) {
+      state.antigravityThinkingOptionId = thinkingOptionId;
+    } else if (agent === "antigravity") {
+      delete state.antigravityThinkingOptionId;
+    } else if (agent === "kiro-cli" && thinkingOptionId) {
+      state.kiroCliThinkingOptionId = thinkingOptionId;
+    } else if (agent === "kiro-cli") {
+      delete state.kiroCliThinkingOptionId;
+    } else if (agent === "openclaw" && thinkingOptionId) {
+      state.openclawThinkingOptionId = thinkingOptionId;
+    } else if (agent === "openclaw") {
+      delete state.openclawThinkingOptionId;
+    } else if (agent === "hermes" && thinkingOptionId) {
+      state.hermesThinkingOptionId = thinkingOptionId;
+    } else if (agent === "hermes") {
+      delete state.hermesThinkingOptionId;
+    } else if (agent === "qoder" && thinkingOptionId) {
+      state.qoderThinkingOptionId = thinkingOptionId;
+    } else if (agent === "qoder") {
+      delete state.qoderThinkingOptionId;
+    } else if (agent === "codebuddy" && thinkingOptionId) {
+      state.codebuddyThinkingOptionId = thinkingOptionId;
+    } else if (agent === "codebuddy") {
+      delete state.codebuddyThinkingOptionId;
+    } else if (agent === "zcode" && thinkingOptionId) {
+      state.zcodeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "zcode") {
+      delete state.zcodeThinkingOptionId;
+    } else if (agent === "trae" && thinkingOptionId) {
+      state.traeThinkingOptionId = thinkingOptionId;
+    } else if (agent === "trae") {
+      delete state.traeThinkingOptionId;
+    } else if (agent === "cursor-cli" && thinkingOptionId) {
+      state.cursorThinkingOptionId = thinkingOptionId;
+    } else if (agent === "cursor-cli") {
+      delete state.cursorThinkingOptionId;
+    } else if (agent === 'codex-harness' && thinkingOptionId) {
+      state.codexHarnessThinkingOptionId = thinkingOptionId;
+    } else if (agent === 'codex-harness') {
+      delete state.codexHarnessThinkingOptionId;
+    }
+    return state;
+  }
+
+  setPiThinkingOption(
+    composer: Composer,
+    thinkingOptionId: HarnessThinkingOptionId,
+  ): Readonly<DraftComposerState> {
+    return this.setExternalThinkingOption(composer, "pi", thinkingOptionId);
+  }
+
+  lock(composer: Composer): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    this.#pendingSubmissions.delete(state);
+    state.phase = "locked";
+    return state;
+  }
+
+  markSubmissionPending(composer: Composer): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    if (state.phase === "draft") this.#pendingSubmissions.add(state);
+    return state;
+  }
+
+  isSubmissionPending(composer: Composer): boolean {
+    return this.#pendingSubmissions.has(this.#state(composer));
+  }
+
+  clearPendingSubmission(composer: Composer): void {
+    const state = this.#state(composer);
+    this.#pendingSubmissions.delete(state);
+    if (state.phase === "draft") delete state.codexAccountId;
+  }
+
+  recordSubmission(composer: Composer, codexAccountId?: string): Readonly<DraftComposerState> {
+    const state = this.#state(composer);
+    if (
+      state.agent === "codex" &&
+      state.phase === "draft" &&
+      !state.codexAccountId &&
+      codexAccountId
+    ) {
+      state.codexAccountId = codexAccountId;
+    }
+    this.#lastSubmittedAgent = state.agent;
+    return state;
+  }
+
+  transfer(
+    source: Composer,
+    replacement: Composer,
+    target: readonly unknown[] | null = null,
+  ): boolean {
+    const state = this.#states.get(source);
+    if (!state) return false;
+    const bound = this.#conversationState(target);
+    if (bound && bound !== state) return false;
+    if (source !== replacement) {
+      if (this.#states.has(replacement)) return false;
+      this.#states.set(replacement, state);
+    }
+    if (isConversationTarget(target) && !bound) {
+      this.#conversationStates.push({ target, state });
+    }
+    if (isConversationTarget(target) && this.#pendingSubmissions.delete(state)) {
+      state.phase = "locked";
+    }
+    return true;
+  }
+
+  async switchAgent(
+    composer: Composer,
+    nextAgent: RendererAgent,
+    operations: DraftAgentSwitchOperations,
+  ): Promise<boolean> {
+    const state = this.#state(composer);
+    if (!this.#enabledAgents.has(nextAgent)) return false;
+    if (state.phase !== "draft" || this.#switching.has(state)) return false;
+    if (state.agent === nextAgent) return true;
+
+    this.#pendingSubmissions.delete(state);
+
+    this.#switching.add(state);
+    try {
+      if (!operations.applyAgent(nextAgent)) return false;
+      try {
+        await operations.clearPrewarm();
+      } catch (error) {
+        if (!operations.applyAgent(state.agent)) {
+          throw new Error("Draft Agent switch could not restore the prior Agent", {
+            cause: error,
+          });
+        }
+        return false;
+      }
+      state.agent = nextAgent;
+      return true;
+    } finally {
+      this.#switching.delete(state);
+    }
+  }
+
+  #conversationState(target: readonly unknown[] | null): MutableComposerState | null {
+    if (!isConversationTarget(target)) return null;
+    return (
+      this.#conversationStates.find((candidate) => sameTarget(candidate.target, target))?.state ??
+      null
+    );
+  }
+
+  #state(composer: Composer, initialAgent?: RendererAgent): MutableComposerState {
+    const existing = this.#states.get(composer);
+    if (existing) return existing;
+    const created: MutableComposerState = {
+      agent: initialAgent ?? this.#defaultAgent,
+      phase: "draft",
+      composerId: this.#idFactory(++this.#composerSequence),
+    };
+    this.#states.set(composer, created);
+    return created;
+  }
+}

package/src/native-ui/renderer-extension/src/assets/README.md

@@ -0,0 +1,13 @@
+# Renderer brand assets
+
+Bundled Agent brand marks used by `renderer-agent-icon.ts`:
+
+- `codex-agent.png`: Codex App GA mark distributed with OpenAI's official `openai.chatgpt` VS Code extension.
+- `omp-agent.svg`: Official OMP favicon mark from Oh My Pi repository (`packages/collab-web/public/favicon.svg`).
+- `opencode-agent.png`: OpenCode square mark with dark outer plate.
+- `kiro-agent.svg`: Official Kiro icon from `https://kiro.dev/icon.svg`.
+- `antigravity-agent.svg`: Google Antigravity mark.
+- `grok-agent.png`: Grok mark served by `grok.com`, provided from captured asset with transparent rounded corners.
+
+All assets are bundled locally as data URLs so the Renderer does not depend on network requests or external extension paths. Product names and marks remain trademarks of their respective owners.
+

package/src/native-ui/renderer-extension/src/assets/antigravity-agent.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -1 28 28"><path d="M21.751 22.607c1.34 1.005 3.35.335 1.508-1.508C17.73 15.74 18.904 1 12.037 1 5.17 1 6.342 15.74.815 21.1c-2.01 2.009.167 2.511 1.507 1.506 5.192-3.517 4.857-9.714 9.715-9.714 4.857 0 4.522 6.197 9.714 9.715z" fill="url(#ag)"/><defs><linearGradient id="ag" x1="2" y1="12" x2="22" y2="12" gradientUnits="userSpaceOnUse"><stop stop-color="#4285F4"/><stop offset=".33" stop-color="#EA4335"/><stop offset=".66" stop-color="#FBBC04"/><stop offset="1" stop-color="#34A853"/></linearGradient></defs></svg>

package/src/native-ui/renderer-extension/src/assets/kiro-agent.svg

@@ -0,0 +1,11 @@
+<svg width="1200" height="1200" viewBox="0 0 1200 1200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="1200" height="1200" rx="260" fill="#9046FF"/>
+<mask id="mask0_1106_4856" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="272" y="202" width="655" height="796">
+<path d="M926.578 202.793H272.637V997.857H926.578V202.793Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_1106_4856)">
+<path d="M398.554 818.914C316.315 1001.03 491.477 1046.74 620.672 940.156C658.687 1059.66 801.052 970.473 852.234 877.795C964.787 673.567 919.318 465.357 907.64 422.374C827.637 129.443 427.623 128.946 358.8 423.865C342.651 475.544 342.402 534.18 333.458 595.051C328.986 625.86 325.507 645.488 313.83 677.785C306.873 696.424 297.68 712.819 282.773 740.645C259.915 783.881 269.604 867.113 387.87 823.883L399.051 818.914H398.554Z" fill="white"/>
+<path d="M636.123 549.353C603.328 549.353 598.359 510.097 598.359 486.742C598.359 465.623 602.086 448.977 609.293 438.293C615.504 428.852 624.697 424.131 636.123 424.131C647.555 424.131 657.492 428.852 664.447 438.541C672.398 449.474 676.623 466.12 676.623 486.742C676.623 525.998 661.471 549.353 636.375 549.353H636.123Z" fill="black"/>
+<path d="M771.24 549.353C738.445 549.353 733.477 510.097 733.477 486.742C733.477 465.623 737.203 448.977 744.41 438.293C750.621 428.852 759.814 424.131 771.24 424.131C782.672 424.131 792.609 428.852 799.564 438.541C807.516 449.474 811.74 466.12 811.74 486.742C811.74 525.998 796.588 549.353 771.492 549.353H771.24Z" fill="black"/>
+</g>
+</svg>

package/src/native-ui/renderer-extension/src/assets/omp-agent.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <linearGradient id="omp-gradient" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#ed4abf" />
+      <stop offset=".5" stop-color="#9b4dff" />
+      <stop offset="1" stop-color="#5ad8e6" />
+    </linearGradient>
+  </defs>
+  <path
+    fill="url(#omp-gradient)"
+    transform="translate(-14.4 -20.2) scale(1.45)"
+    d="M14 16h36v8H40v32h-8V24h-6v22h-8V24h-4z"
+  />
+</svg>