Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

80.1 KB
Raw Blame
import { emojiCompletion } from "./emoji-completion";
import { composerInput, resizeComposerInput } from "./composer-input";
import { reportHandledError } from "./browser-errors.ts";
import { appEditSlug } from "./app-edit";
import { runtimeConfigKey, loadRuntimeConfig, saveRuntimeConfig, subscribeRuntimeConfig } from "./runtime-config-store";
import { getRuntimeConfig } from "./runtime-config-cache.ts";
import type { Agent, AgentMessage } from "@earendil-works/pi-agent-core";
import { createFileDragState } from "./file-drag";
import type { Attachment } from "@earendil-works/pi-web-ui";
import { FolderDropError, folderToZipFile, isFolderReadError, splitDropItems, type DropEntryLike } from "./folder-drop";
import { html, nothing, render, type TemplateResult } from "lit";
import { live } from "lit/directives/live.js";
import { repeat } from "lit/directives/repeat.js";
import { ArrowUp, Box, CornerDownRight, FileText, Paperclip, Square, X } from "lucide";
import {
  api,
  ApiError,
  editQueuedRun,
  approvalBlocksComposer,
  MAX_ATTACHMENT_BYTES,
  MAX_FILES_PER_MESSAGE,
  mintSendKey,
  oversizeAttachmentNote,
  PENDING_APPROVAL_REASON,
  queueTurn,
  tooManyFilesNote,
  uploadAttachments,
  userSendMessage,
  withdrawRun,
  type ApprovalDecision,
  type CoreAttachment,
  type PendingApproval,
  type QueuedRun,
  alwaysSteer,
  switchedDefault,
} from "./core-bridge";
import { errMessage } from "../../chassis/src/errors";
import { browserRenderableImage, fieldSelect } from "./ui";
import { icon } from "./icons";
import {
  defaultEffortForModel,
  defaultModelValue,
  getModelOptions,
  harnessSupportsFastMode,
  harnessSupportsSteer,
  type EffortLevel,
  type ModelOption,
  type ModelOptionValue,
} from "./model-options";
import { modelSupportsFastMode } from "./pi-models";
import type { ComposerSurface, ConvCtx } from "./conv-types";
import { bumpSessionActivity, dropPendingSession, renderList } from "./sessions";
import { appState } from "./shell";
import { base64ToText, bytesToBase64, insertIntoDraft, pasteChipLabel } from "./paste-text";
import { clearDraft, newChatDraftKey, saveDraft } from "./drafts";
import { tip } from "./tooltip";
import { isPhone } from "./viewport";
import {
  LOADOUT_CAP,
  isUltrafastModel,
  presetModelId,
  ultrafastChoice,
  loadLoadout,
  saveLoadout,
  reconcileLoadout,
  upsertLoadout,
  effortLevelsForHarness,
  compatibleHarnessOptions,
  modelLoadoutOptions,
  type LoadoutEntry,
} from "./composer-loadout";

import { createModelPicker } from "./model-picker";

export type ComposerMenu = "effort" | "model" | "settings" | "loadout";

const LEGACY_MODEL_STORAGE_KEY = "web-ui:model";
const THREAD_PICKS_STORAGE_KEY = "web-ui:model-picks";
const THREAD_PICKS_CAP = 50;
function loadThreadPicks(): Map<string, ModelOptionValue> {
  try {
    const raw: unknown = JSON.parse(localStorage.getItem(THREAD_PICKS_STORAGE_KEY) ?? "[]");
    if (Array.isArray(raw)) {
      const pairs = raw.filter(
        (p): p is [string, string] => Array.isArray(p) && typeof p[0] === "string" && typeof p[1] === "string",
      );
      return new Map(pairs.slice(-THREAD_PICKS_CAP));
    }
  } catch {
    void 0;
  }
  return new Map();
}

let threadModelPicks = loadThreadPicks();
function runtimeScopeKey(scopeId: string | null): string | null {
  if (scopeId) return scopeId;
  const user = appState.me?.user;
  return user ? `personal:${user}` : null;
}

if (typeof window !== "undefined") {
  window.addEventListener("storage", (e) => {
    if (e.key === THREAD_PICKS_STORAGE_KEY) threadModelPicks = loadThreadPicks();
  });
}

function rememberThreadPick(threadRef: string, value: ModelOptionValue): void {
  const merged = loadThreadPicks();
  for (const [ref, pick] of threadModelPicks) if (!merged.has(ref)) merged.set(ref, pick);
  merged.delete(threadRef);
  merged.set(threadRef, value);
  while (merged.size > THREAD_PICKS_CAP) merged.delete(merged.keys().next().value as string);
  threadModelPicks = merged;
  persistPreference(THREAD_PICKS_STORAGE_KEY, JSON.stringify([...merged]));
}

function forgetThreadPick(threadRef: string): void {
  threadModelPicks = loadThreadPicks();
  threadModelPicks.delete(threadRef);
  persistPreference(THREAD_PICKS_STORAGE_KEY, JSON.stringify([...threadModelPicks]));
}

function carryModelPick(fromThreadRef: string | null, toThreadRef: string): void {
  const pick = fromThreadRef ? threadModelPicks.get(fromThreadRef) : undefined;
  if (pick) rememberThreadPick(toThreadRef, pick);
}

function modelOptionFor(value: ModelOptionValue, scopeKey?: string | null): ModelOption | undefined {
  return getModelOptions(scopeKey).find((option) => option.value === value);
}

function persistPreference(key: string, value: string): void {
  try {
    localStorage.setItem(key, value);
  } catch {
    void 0;
  }
}

export interface SkillItem {
  id?: string;
  name: string;
  description: string;
  body?: string;
  scope: string;
  shadowed?: boolean;
  editable?: boolean;
  scopeId?: string;
  status?: string;
  version?: number;
  source?: "native" | "pack";
  pack?: { packId: string; commit: string; upstreamName: string };
  assetCount?: number;
  requiredCapabilities?: string[];
  createdBy?: string;
  files?: Array<{ path: string; executable?: boolean }>;
}
interface SkillMatch {
  skill: SkillItem;
  start: number;
  end: number;
}

let skillsCache: SkillItem[] | null = null;

export function clearSkillsCache(): void {
  skillsCache = null;
}

const SLASH_TOKEN = /(^|\s)\/([a-zA-Z0-9_-]*)$/;

function slashQuery(draft: string): string | null {
  const m = SLASH_TOKEN.exec(draft);
  return m ? (m[2] ?? "") : null;
}

export function resyncModelSelection(): void {
  try {
    localStorage.removeItem(LEGACY_MODEL_STORAGE_KEY);
  } catch {
    void 0;
  }
}

export interface ComposerSubmission {
  model: string;
  harness: string;
  thinkingLevel?: string;
  fastMode?: boolean;
  attachments?: CoreAttachment[];
}

export interface ComposerOptions {
  prepareSubmit?: () => (text: string, options: ComposerSubmission) => Promise<void>;
  placeholder?: string;
  preferenceKey?: string;
  runtimeAccount?: "company";
}

export function createComposerSurface(ctx: ConvCtx, options: ComposerOptions = {}): ComposerSurface {
  let submitting = false;
  const loadoutKey = options.preferenceKey ? `web-ui:loadout:${options.preferenceKey}` : undefined;
  const refreshAccount = () => {
    loadoutRestored = false;
    void refreshRuntimeSelection(ctx.chat.state.scopeId, ctx.chat.state.agent ?? undefined, true);
  };
  window.addEventListener("model-account-changed", refreshAccount);
  const revalidateRuntime = () => {
    if (document.visibilityState === "visible")
      void refreshRuntimeSelection(ctx.chat.state.scopeId, ctx.chat.state.agent ?? undefined, true);
  };
  document.addEventListener("visibilitychange", revalidateRuntime);
  let runtimeRequest = 0;
  let runtimeIdentity = "";
  let unsubscribeRuntime: (() => void) | undefined;
  let effortOverride: EffortLevel | undefined;
  let fastModeOverride: boolean | undefined;
  let restoredLoadout: LoadoutEntry | undefined;
  let loadoutRestored = false;
  let modelSelectionRevision = 0;
  let effortSelectionRevision = 0;
  let fastSelectionRevision = 0;

  function isUnsentNewChat(): boolean {
    return (
      !options.prepareSubmit &&
      ctx.chat.state.sessionId === null &&
      !(ctx.chat.state.agent?.state.messages ?? []).some((m) => !(m as { opener?: boolean }).opener)
    );
  }

  function persistDraft(): void {
    if (!ctx.chat.state.threadRef) return;
    saveDraft(ctx.chat.state.threadRef, composerState.draft);
    if (isUnsentNewChat()) saveDraft(newChatDraftKey(appState.me?.user), composerState.draft);
  }

  function clearActiveDraft(): void {
    if (ctx.chat.state.threadRef) clearDraft(ctx.chat.state.threadRef);
    if (!options.prepareSubmit && ctx.chat.state.sessionId === null) clearDraft(newChatDraftKey(appState.me?.user));
  }

  const composerState = {
    draft: "",
    attachments: [] as Attachment[],
    error: "",
    processingFiles: false,
    dragging: false,
    openMenu: null as ComposerMenu | null,
    menuQuery: "",
    slashDismissed: false,
    get effortLevel(): EffortLevel {
      const selected = currentModelOption();
      const effort =
        effortOverride ??
        (restoredLoadout?.value === selected?.value ? restoredLoadout?.effort : undefined) ??
        (getRuntimeConfig(scopeKey())?.effective.effortLevel as EffortLevel | undefined) ??
        defaultEffortForModel(selected?.model);
      const levels = effortLevelsForHarness(selected?.harnessId ?? "", selected?.model);
      return levels.some((level) => level.value === effort) ? effort : levels[0]!.value;
    },
    set effortLevel(value: EffortLevel) {
      ++effortSelectionRevision;
      effortOverride = value;
    },
    get fastMode(): boolean | undefined {
      const selected = currentModelOption();
      const fast =
        fastModeOverride ??
        (restoredLoadout?.value === selected?.value ? restoredLoadout?.fast : undefined) ??
        getRuntimeConfig(scopeKey())?.effective.fastMode === true;
      return (
        fast &&
        harnessSupportsFastMode(selected?.harnessId ?? "") &&
        modelSupportsFastMode(scopeKey(), selected?.model.id)
      );
    },
    set fastMode(value: boolean | undefined) {
      ++fastSelectionRevision;
      fastModeOverride = value;
    },
    pasteView: null as { id: string; text: string; initial: string; dirty: boolean } | null,
  };

  const pastedTextIds = new Set<string>();

  const queuedRuns = new Map<string, QueuedRun[]>();
  let queuedEdit: { runId: string; threadRef: string; original: string; text: string; saving: boolean } | null = null;

  function queuedRunsFor(threadRef: string | null): QueuedRun[] {
    return (threadRef ? queuedRuns.get(threadRef) : undefined) ?? [];
  }

  function setQueuedRuns(threadRef: string, runs: QueuedRun[]): void {
    if (runs.length) queuedRuns.set(threadRef, runs);
    else queuedRuns.delete(threadRef);
  }

  function forgetQueuedRun(threadRef: string, runId: string): void {
    setQueuedRuns(
      threadRef,
      queuedRunsFor(threadRef).filter((r) => r.runId !== runId),
    );
  }

  const steeringRuns = new Map<string, Array<QueuedRun & { ts: string }>>();

  function steeringRunsFor(threadRef: string | null, agent: Agent): QueuedRun[] {
    const steering = threadRef ? steeringRuns.get(threadRef) : undefined;
    if (!threadRef || !steering) return [];
    const settled = !agent.state.isStreaming && !ctx.chat.hasLiveRun();
    const intakes = new Set(
      agent.state.messages.flatMap((m) => {
        const { steered, ts } = m as { steered?: boolean; ts?: string };
        return steered && ts ? [ts] : [];
      }),
    );
    const waiting = settled ? [] : steering.filter((run) => !intakes.has(run.ts));
    if (waiting.length) steeringRuns.set(threadRef, waiting);
    else steeringRuns.delete(threadRef);
    return waiting;
  }

  const fileDrag = createFileDragState((dragging) => {
    composerState.dragging = dragging;
    ctx.chat.drawActiveChat();
  });
  let skillsLoading = false;
  let slashActiveIndex = 0;
  function effectiveFastMode(): boolean {
    return composerState.fastMode === true;
  }

  function resetComposer(): void {
    composerState.draft = "";
    composerState.attachments = [];
    composerState.pasteView = null;
    pastedTextIds.clear();
    composerState.error = "";
    composerState.processingFiles = false;
    composerState.openMenu = null;
    slashActiveIndex = 0;
    composerState.slashDismissed = false;
  }

  function scopeKey(): string | null {
    return runtimeConfigKey(runtimeScopeKey(ctx.chat.state.scopeId), options.runtimeAccount);
  }

  function currentModelOption(): ModelOption | undefined {
    const picked = ctx.chat.state.threadRef ? threadModelPicks.get(ctx.chat.state.threadRef) : undefined;
    return modelOptionFor(picked ?? defaultModelValue(scopeKey()), scopeKey());
  }

  function followsDefault(): boolean {
    const selected = currentModelOption();
    const threadRef = ctx.chat.state.threadRef;
    return (
      !!selected &&
      !(threadRef && threadModelPicks.has(threadRef)) &&
      effortOverride === undefined &&
      fastModeOverride === undefined &&
      restoredLoadout?.value !== selected.value
    );
  }

  async function refreshRuntimeSelection(scopeId: string | null, agent?: Agent, refresh = false): Promise<void> {
    const request = ++runtimeRequest;
    const actualScope = runtimeScopeKey(scopeId);
    const key = runtimeConfigKey(actualScope, options.runtimeAccount);
    const identity = `${key}:${ctx.chat.state.threadRef}`;
    const changedIdentity = identity !== runtimeIdentity;
    if (changedIdentity) {
      effortOverride = undefined;
      fastModeOverride = undefined;
      restoredLoadout = undefined;
      loadoutRestored = false;
      runtimeIdentity = identity;
    }
    unsubscribeRuntime?.();
    let defaults = getRuntimeConfig(key)?.effective;
    unsubscribeRuntime =
      key === null
        ? undefined
        : subscribeRuntimeConfig(key, () => {
            if (key !== scopeKey()) return;
            const next = getRuntimeConfig(key)?.effective;
            if (
              (["harnessId", "modelId", "effortLevel", "fastMode"] as const).some(
                (field) => defaults?.[field] !== next?.[field],
              )
            ) {
              restoredLoadout = undefined;
              followDefault(defaults);
            }
            defaults = next;
            syncRuntimeSelection(ctx.chat.state.agent ?? undefined);
          });
    composerState.error = "";
    syncRuntimeSelection(agent);
    const config = actualScope === null ? null : await loadRuntimeConfig(actualScope, refresh, options.runtimeAccount);
    if (request !== runtimeRequest) return;
    if (!config) composerState.error = "Could not load runtime settings.";
    if (config && !loadoutRestored) {
      restoreLoadoutSelection();
      loadoutRestored = true;
    }
    syncRuntimeSelection(agent);
  }

  function followDefault(previous: { harnessId: string; modelId: string } | undefined): void {
    const threadRef = ctx.chat.state.threadRef;
    const pick = threadRef ? threadModelPicks.get(threadRef) : undefined;
    const picked = pick ? modelOptionFor(pick, scopeKey()) : undefined;
    if (!threadRef || !previous || !picked) return;
    if (picked.harnessId !== previous.harnessId || picked.model.id !== previous.modelId) return;
    forgetThreadPick(threadRef);
    effortOverride = undefined;
    fastModeOverride = undefined;
    loadoutRestored = false;
  }

  function restoreLoadoutSelection(): void {
    loadout = loadLoadout(loadoutKey);
    let selected = currentModelOption();
    const threadRef = ctx.chat.state.threadRef;
    if (selected && threadRef && !threadModelPicks.has(threadRef)) {
      const preferred = modelLoadoutOptions(getModelOptions(scopeKey()), loadout, selected.harnessId).find(
        (option) => presetModelId(option.value) === presetModelId(selected!.value),
      );
      if (preferred && preferred.value !== selected.value) {
        rememberThreadPick(threadRef, preferred.value);
        selected = preferred;
      }
    }
    if (!selected) return;
    const saved = loadout.find((entry) => entry.value === selected.value);
    if (!saved) return;
    const normalized = normalizeLoadoutEntry(saved, selected);
    if (threadRef && threadModelPicks.has(threadRef)) {
      effortOverride ??= normalized.effort;
      fastModeOverride ??= normalized.fast;
    } else {
      restoredLoadout = normalized;
    }
  }

  function syncRuntimeSelection(agent?: Agent): void {
    const selected = currentModelOption();
    if (agent && selected) agent.state.model = selected.model;
    ctx.chat.drawActiveChat(agent);
    if (pendingComposerFocus) focusComposerEnd();
  }

  async function changeScopeRuntime(
    change: {
      harnessId?: string;
      modelId?: string;
      effortLevel?: string;
      fastMode?: boolean;
      inherit?: boolean;
      keep?: boolean;
    },
    agent: Agent,
    preserveSelection = false,
  ): Promise<void> {
    if (options.prepareSubmit) {
      if (change.harnessId && change.modelId) selectModel(`${change.harnessId}:${change.modelId}`, agent);
      return;
    }
    const request = ++runtimeRequest;
    const scopeId = scopeKey();
    if (!scopeId) return;
    composerState.error = "";
    const current = preserveSelection ? currentModelOption() : undefined;
    const settings = current ? activeLoadoutEntry(current) : undefined;
    const modelRevision = modelSelectionRevision;
    const effortRevision = effortSelectionRevision;
    const fastRevision = fastSelectionRevision;
    try {
      await saveRuntimeConfig(scopeId, change);
      if (request !== runtimeRequest || scopeId !== scopeKey()) return;
      if (modelSelectionRevision === modelRevision) {
        if (current && settings) {
          if (effortSelectionRevision === effortRevision) effortOverride = settings.effort;
          if (fastSelectionRevision === fastRevision) fastModeOverride = settings.fast;
          if (ctx.chat.state.threadRef) rememberThreadPick(ctx.chat.state.threadRef, current.value);
          rememberActiveTweaks(current);
        } else if (
          !change.keep &&
          effortSelectionRevision === effortRevision &&
          fastSelectionRevision === fastRevision
        ) {
          clearChatSelection();
        }
      }
      syncRuntimeSelection(agent);
      placeLoadout();
    } catch (e) {
      if (request !== runtimeRequest || scopeId !== scopeKey()) return;
      composerState.error = errMessage(e, "Could not update the scope default.");
      ctx.chat.drawActiveChat(agent);
    }
  }

  function composerForm(agent: Agent, header: TemplateResult | typeof nothing = nothing): TemplateResult {
    const activeRuntimeConfig = getRuntimeConfig(scopeKey());
    const selectedModel = currentModelOption();
    if (!selectedModel) {
      const selected =
        (ctx.chat.state.threadRef ? threadModelPicks.get(ctx.chat.state.threadRef) : undefined) ??
        defaultModelValue(scopeKey());
      return html`<div class="composer-wrap">
        ${header} ${composerApprovalPanel(ctx.chat.activePendingApprovals())}
        <p role="status">
          ${composerState.error || activeRuntimeConfig?.unavailableReason || "Selected model is unavailable. Choose a replacement to continue."}
          ${selected}
        </p>
        <label
          >Replacement model
          ${fieldSelect({
            ariaLabel: "Replacement model",
            value: "",
            options: html`<option value="" selected>Select a model…</option>
              ${getModelOptions(scopeKey()).map((option) => html`<option value=${option.value}>${option.harnessLabel} · ${option.label}</option>`)}`,
            onChange: async (value) => {
              const option = modelOptionFor(value, scopeKey());
              if (!option) return;
              await changeScopeRuntime({ harnessId: option.harnessId, modelId: option.model.id }, agent);
              if (
                getRuntimeConfig(scopeKey())?.effective.harnessId === option.harnessId &&
                getRuntimeConfig(scopeKey())?.effective.modelId === option.model.id
              )
                selectModel(value, agent);
            },
          })}
        </label>
        <button type="button" @click=${() => void refreshRuntimeSelection(ctx.chat.state.scopeId, agent, true)}>
          Refresh models
        </button>
      </div>`;
    }
    const approvalPauses = ctx.chat.activePendingApprovals();
    const blockingPauses = approvalPauses.filter(approvalBlocksComposer);
    const runtimePending = activeRuntimeConfig === null;
    const inputBlocked = runtimePending || ctx.chat.state.resolvingApprovals.size > 0 || blockingPauses.length > 0;
    const attachingDisabled = inputBlocked;
    let placeholder =
      options.placeholder ??
      (appEditSlug(ctx.chat.state.threadRef, appState.me?.user) ? "Describe a change…" : "Ask anything");
    if (inputBlocked) placeholder = runtimePending ? "Loading runtime…" : "Approve or deny to continue";
    else if (agent.state.isStreaming) placeholder = "Queue a message for after this turn…";
    let composerNotice: TemplateResult | typeof nothing = nothing;
    if (composerState.processingFiles) {
      composerNotice = html`<div class="composer-note">Preparing files...</div>`;
    } else if (!approvalPauses.length && runtimePending) {
      composerNotice = composerState.error
        ? html`<div class="composer-error">
            ${composerState.error}
            <button type="button" @click=${() => void refreshRuntimeSelection(ctx.chat.state.scopeId, agent, true)}>
              Retry
            </button>
          </div>`
        : html`<div class="composer-note">Loading runtime settings…</div>`;
    } else if (composerState.error) {
      composerNotice = html`<div class="composer-error">${composerState.error}</div>`;
    }

    const compact = Boolean(ctx.pane) || isPhone();
    const turnRuntime = ctx.chat.turnRuntime();
    const routed =
      turnRuntime?.change &&
      !switchedDefault(turnRuntime) &&
      (turnRuntime.harnessId !== selectedModel.harnessId || turnRuntime.modelId !== selectedModel.model.id)
        ? turnRuntime
        : undefined;
    const runtimeControls = modelPicker.render(agent, selectedModel, inputBlocked, routed);
    return html`
      <form
        class="composer-wrap ${compact ? "compact" : ""}"
        @submit=${(e: Event) => submitComposer(e, agent)}
        @keydown=${(e: KeyboardEvent) => composerShortcut(e, agent, inputBlocked)}
      >
        ${header} ${slashMenu(agent)}
        ${
          !options.prepareSubmit && activeRuntimeConfig?.upgradeAvailable
            ? html`<div class="runtime-upgrade">
                <span
                  >The org now recommends
                  ${modelOptionFor(`${activeRuntimeConfig.orgDefault.harnessId}:${activeRuntimeConfig.orgDefault.modelId}`, scopeKey())?.harnessLabel ?? activeRuntimeConfig.orgDefault.harnessId}
                  ·
                  ${modelOptionFor(`${activeRuntimeConfig.orgDefault.harnessId}:${activeRuntimeConfig.orgDefault.modelId}`, scopeKey())?.buttonLabel ?? activeRuntimeConfig.orgDefault.modelId}.</span
                >
                <button
                  type="button"
                  @click=${() => changeScopeRuntime({ harnessId: activeRuntimeConfig!.orgDefault.harnessId, modelId: activeRuntimeConfig!.orgDefault.modelId }, agent)}
                >
                  Upgrade
                </button>
                <button type="button" @click=${() => changeScopeRuntime({ keep: true }, agent)}>Keep mine</button>
                <button type="button" @click=${() => changeScopeRuntime({ inherit: true }, agent)}>
                  Inherit future defaults
                </button>
              </div>`
            : nothing
        }
        ${
          composerState.attachments.length
            ? html`
                <div class="attachment-strip">
                  ${repeat(
                    composerState.attachments,
                    (a) => a.id,
                    (a) => html`
                      <span class=${browserRenderableImage(a.mimeType) ? "file-chip composer-image" : "file-chip"}>
                        ${
                          browserRenderableImage(a.mimeType)
                            ? html`<button
                                type="button"
                                class="composer-image-open"
                                aria-label=${`Preview ${a.fileName}`}
                                @click=${() => openImagePreview(a)}
                              >
                                <img
                                  src=${a.content.startsWith("data:") ? a.content : `data:${a.mimeType};base64,${a.content}`}
                                  alt=${a.fileName}
                                  @error=${(event: Event) => {
                                    (event.currentTarget as HTMLImageElement).parentElement!.hidden = true;
                                  }}
                                />
                              </button>`
                            : nothing
                        }
                        ${
                          pastedTextIds.has(a.id)
                            ? html`
                                <button
                                  type="button"
                                  class="chip-open"
                                  aria-label="View pasted text"
                                  ${tip("View pasted text")}
                                  @click=${() => openPasteView(a.id, agent)}
                                >
                                  ${icon(FileText, 14)}
                                  <span>${pasteChipLabel(a.extractedText?.length ?? 0)}</span>
                                </button>
                              `
                            : html`${browserRenderableImage(a.mimeType) ? nothing : icon(Paperclip, 14)}<span
                                  dir="auto"
                                  title=${a.fileName}
                                  >${a.fileName}</span
                                >`
                        }
                        <button
                          type="button"
                          class="chip-x"
                          aria-label="Remove attachment"
                          ${tip("Remove")}
                          @click=${() => removeAttachment(a.id, agent)}
                        >
                          ${icon(X, 13)}
                        </button>
                      </span>
                    `,
                  )}
                </div>
              `
            : nothing
        }
        ${approvalPauses.length ? composerApprovalPanel(approvalPauses) : nothing}
        ${
          blockingPauses.length
            ? nothing
            : composerInput({
                value: composerState.draft,
                placeholder,
                disabled: inputBlocked,
                onInput: (e) => onDraftInput(e, agent),
                onKeydown: (e) => onComposerKeydown(e, agent),
                onPaste: (e) => void onComposerPaste(e, agent),
              })
        }
        <div class="composer-toolbar">
          <div class="composer-left">
            <input
              class="file-input"
              type="file"
              multiple
              hidden
              ?disabled=${attachingDisabled}
              @change=${(e: Event) => void onFilesSelected(e, agent)}
            />
            <button
              class="icon-btn composer-attach"
              type="button"
              aria-label="Attach files"
              ${tip("Attach files")}
              ?disabled=${attachingDisabled}
              @click=${() => pickFiles()}
            >
              ${icon(Paperclip, 18)}
            </button>
            ${runtimeControls}
          </div>
          <div class="composer-right">${sendControls(agent)}</div>
        </div>
        ${composerNotice}
      </form>
      ${pasteViewDialog(agent)}
    `;
  }

  function pasteViewDialog(agent: Agent): TemplateResult | typeof nothing {
    const view = composerState.pasteView;
    if (!view) return nothing;
    return html`
      <div
        class="project-dialog-backdrop"
        @click=${(e: MouseEvent) => e.target === e.currentTarget && closePasteView(agent)}
        @keydown=${(e: KeyboardEvent) => e.key === "Escape" && closePasteView(agent)}
      >
        <div class="project-dialog paste-dialog" role="dialog" aria-modal="true" aria-labelledby="paste-dialog-title">
          <div class="project-dialog-head">
            <div><h2 id="paste-dialog-title">Pasted text</h2></div>
            <button
              class="chip-x"
              type="button"
              aria-label="Close"
              ${tip("Close")}
              @click=${() => closePasteView(agent)}
            >
              ${icon(X, 16)}
            </button>
          </div>
          <textarea
            class="paste-dialog-text"
            dir="auto"
            @input=${(e: InputEvent) => {
              view.text = (e.currentTarget as HTMLTextAreaElement).value;
              view.dirty = true;
            }}
          >
  ${view.initial}</textarea>
          <div class="project-dialog-actions">
            <button class="btn" type="button" @click=${() => removeAttachment(view.id, agent)}>Remove</button>
            <button class="btn" type="button" @click=${() => insertPasteIntoDraft(agent)}>Insert into message</button>
            <button class="btn primary" type="button" @click=${() => closePasteView(agent)}>Done</button>
          </div>
        </div>
      </div>
    `;
  }

  function openPasteView(id: string, agent: Agent): void {
    const attachment = composerState.attachments.find((a) => a.id === id);
    if (!attachment) return;
    const text = attachment.extractedText ?? base64ToText(attachment.content);
    composerState.pasteView = { id, text, initial: text, dirty: false };
    ctx.chat.drawActiveChat(agent);
    requestAnimationFrame(() => ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".paste-dialog-text")?.focus());
  }

  function closePasteView(agent: Agent): void {
    const view = composerState.pasteView;
    if (!view) return;
    const attachment = composerState.attachments.find((a) => a.id === view.id);
    if (attachment && view.dirty) {
      const bytes = new TextEncoder().encode(view.text);
      attachment.content = bytesToBase64(bytes);
      attachment.size = bytes.length;
      attachment.extractedText = view.text;
    }
    composerState.pasteView = null;
    ctx.chat.drawActiveChat(agent);
  }

  function insertPasteIntoDraft(agent: Agent): void {
    const view = composerState.pasteView;
    if (!view) return;
    const ta = ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".composer-input");
    const { draft, cursor } = insertIntoDraft(composerState.draft, view.text, ta ? ta.selectionStart : null);
    composerState.draft = draft;
    persistDraft();
    composerState.pasteView = null;
    removeAttachment(view.id, agent);
    resizeComposer();
    requestAnimationFrame(() => {
      const input = ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".composer-input");
      if (!input) return;
      input.focus();
      input.setSelectionRange(cursor, cursor);
    });
  }

  function sendControls(agent: Agent): TemplateResult {
    if (!agent.state.isStreaming || ctx.chat.isStopping()) {
      return html`<button
        class="send-btn"
        type="submit"
        aria-label="Send"
        ${tip("Send")}
        ?disabled=${!composerCanSend()}
      >
        ${icon(ArrowUp, 16)}
      </button>`;
    }
    const label = alwaysSteer() && canSteer(agent) ? "Steer the running task" : "Queue for after this turn";
    return html`
      <button class="stop-btn" type="button" aria-label="Stop" ${tip("Stop")} @click=${() => stopStreaming(agent)}>
        ${icon(Square, 16)}
      </button>
      <button class="send-btn" type="submit" ${tip(label)} aria-label=${label} ?disabled=${!composerCanSend()}>
        ${icon(ArrowUp, 16)}
      </button>
    `;
  }

  function canSteer(agent: Agent): boolean {
    return (
      agent.state.isStreaming &&
      !ctx.chat.isStopping() &&
      ctx.chat.hasLiveRun() &&
      harnessSupportsSteer(currentModelOption()?.harnessId ?? "")
    );
  }

  function queuedStrip(agent: Agent): TemplateResult | typeof nothing {
    const threadRef = ctx.chat.state.threadRef;
    const queued = queuedRunsFor(threadRef).filter((q) => !pendingSteers.has(q.runId));
    if (queuedEdit?.threadRef === ctx.chat.state.threadRef && !queued.some((q) => q.runId === queuedEdit?.runId))
      queued.push({ runId: queuedEdit.runId, text: queuedEdit.original });
    if (!queued.length) return nothing;
    const steerable = canSteer(agent);
    const steerTip = (): string => {
      if (steerable) return "Steer the running task with this instead of waiting";
      return "Nothing running can take this. It will go out as its own turn";
    };
    return html`
      <div class="queued-strip" role="list" aria-label="Queued messages">
        ${queued.map((q) =>
          queuedEdit?.runId === q.runId && queuedEdit.threadRef === ctx.chat.state.threadRef
            ? html` <div class="queued-chip queued-editing" role="listitem">
                <textarea
                  class="queued-edit-input"
                  ${emojiCompletion(queuedEdit.text)}
                  aria-label="Edit queued message"
                  rows="3"
                  .value=${live(queuedEdit.text)}
                  ?disabled=${queuedEdit.saving}
                  @input=${(event: Event) => {
                    if (queuedEdit) queuedEdit.text = (event.target as HTMLTextAreaElement).value;
                  }}
                  @keydown=${(event: KeyboardEvent) => {
                    if (event.isComposing || queuedEdit?.saving) return;
                    if (event.key === "Escape") {
                      event.preventDefault();
                      event.stopPropagation();
                      cancelQueuedEdit(agent);
                    } else if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
                      event.preventDefault();
                      event.stopPropagation();
                      void saveQueuedEdit(agent);
                    }
                  }}
                ></textarea>
                <button
                  type="button"
                  class="queued-steer"
                  aria-keyshortcuts="Control+Enter Meta+Enter"
                  ?disabled=${queuedEdit.saving}
                  @click=${() => void saveQueuedEdit(agent)}
                >
                  Save
                </button>
                <button
                  type="button"
                  class="queued-steer"
                  ?disabled=${queuedEdit.saving}
                  @click=${() => cancelQueuedEdit(agent)}
                >
                  Cancel
                </button>
              </div>`
            : html`
                <div class="queued-chip" role="listitem">
                  <span class="queued-tag">Queued</span>
                  <span class="queued-text" dir="auto" ${tip(q.text || "Files, no text")}
                    >${q.text || (q.hasAttachments ? "(files)" : "")}</span
                  >
                  <button
                    type="button"
                    class="queued-steer"
                    ?disabled=${!steerable}
                    ${tip(steerTip())}
                    @click=${() => void steerQueued(agent, q)}
                  >
                    ${icon(CornerDownRight, 13)}<span>Steer</span>
                  </button>
                  <button
                    type="button"
                    class="queued-steer"
                    aria-label="Edit queued message"
                    @click=${() => {
                      const edit = (queuedEdit = {
                        runId: q.runId,
                        threadRef: ctx.chat.state.threadRef!,
                        original: q.text,
                        text: q.text,
                        saving: false,
                      });
                      ctx.chat.drawActiveChat(agent);
                      requestAnimationFrame(() => {
                        if (
                          queuedEdit !== edit ||
                          ctx.chat.state.threadRef !== edit.threadRef ||
                          ctx.chat.state.agent !== agent
                        )
                          return;
                        const input = ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".queued-edit-input");
                        input?.focus();
                        input?.setSelectionRange(input.value.length, input.value.length);
                      });
                    }}
                  >
                    Edit
                  </button>
                  <button
                    type="button"
                    class="chip-x"
                    aria-label="Remove queued message"
                    ${tip("Remove")}
                    @click=${() => void removeQueued(agent, q)}
                  >
                    ${icon(X, 13)}
                  </button>
                </div>
              `,
        )}
      </div>
    `;
  }

  function composerApprovalPanel(
    approvals: PendingApproval[],
    resolve: (decision: ApprovalDecision) => void = ctx.chat.resolveCommandApproval,
  ): TemplateResult {
    const decide = (decision: ApprovalDecision): void => {
      if (!ctx.chat.state.resolvingApprovals.has(decision.requestId)) resolve(decision);
    };
    return html`<div class="composer-approval-panel" role="group" aria-label="Command approval">
      ${approvals.map(
        (a) =>
          html`<div class="composer-approval">
            <div class="composer-approval-copy">${ctx.chat.approvalSummaryView(a, true)}</div>
            <div class="approval-actions">
              <button
                class="approval-btn deny"
                type="button"
                ?disabled=${ctx.chat.state.resolvingApprovals.has(a.requestId)}
                @click=${() => decide({ requestId: a.requestId, approved: false })}
              >
                Deny
              </button>
              <button
                class="approval-btn"
                type="button"
                ?disabled=${ctx.chat.state.resolvingApprovals.has(a.requestId)}
                @click=${() => decide({ requestId: a.requestId, approved: true, scope: "once" })}
              >
                Allow once
              </button>
              ${
                a.grantModes?.session === false
                  ? nothing
                  : html`<button
                      class="approval-btn primary"
                      type="button"
                      ?disabled=${ctx.chat.state.resolvingApprovals.has(a.requestId)}
                      @click=${() => decide({ requestId: a.requestId, approved: true, scope: "session" })}
                    >
                      Allow for session
                    </button>`
              }
              ${
                a.grantModes?.always === false
                  ? nothing
                  : html`<button
                      class="approval-btn"
                      type="button"
                      ?disabled=${ctx.chat.state.resolvingApprovals.has(a.requestId)}
                      @click=${() => decide({ requestId: a.requestId, approved: true, scope: "always" })}
                    >
                      Allow always
                    </button>`
              }
            </div>
          </div>`,
      )}
    </div>`;
  }

  let loadout = loadLoadout(loadoutKey);
  const modelPicker = createModelPicker<Agent>({
    host: () => ctx.chat.state.host,
    redraw: () => ctx.chat.drawActiveChat(),
    scopeKey,
    state: composerState,
    presets: {
      entries: seededLoadout,
      save: (entries) => {
        loadout = entries;
        saveLoadout(entries, loadoutKey);
      },
      add: addLoadoutEntry,
    },
    activeEntry: activeLoadoutEntry,
    apply: applyLoadout,
    selectEffort,
    selectHarness,
    toggleFastMode,
    effectiveFastMode,
    changeDefault: changeScopeRuntime,
    showDefaultAction: !options.prepareSubmit,
    showInheritAction: !options.prepareSubmit,
  });
  const placeLoadout = modelPicker.place;

  function activeLoadoutEntry(selected: ModelOption): LoadoutEntry {
    return {
      value: selected.value,
      effort: composerState.effortLevel,
      fast:
        harnessSupportsFastMode(selected.harnessId) &&
        modelSupportsFastMode(scopeKey(), selected.model.id) &&
        effectiveFastMode(),
    };
  }

  function normalizeLoadoutEntry(entry: LoadoutEntry, option: ModelOption): LoadoutEntry {
    const levels = effortLevelsForHarness(option.harnessId, option.model);
    const defaultEffort = defaultEffortForModel(option.model);
    const fallbackEffort = levels.some((level) => level.value === defaultEffort) ? defaultEffort : levels[0]!.value;
    return {
      value: option.value,
      effort: levels.some((level) => level.value === entry.effort) ? entry.effort : fallbackEffort,
      fast:
        entry.fast && harnessSupportsFastMode(option.harnessId) && modelSupportsFastMode(scopeKey(), option.model.id),
    };
  }

  function seededLoadout(selected: ModelOption): LoadoutEntry[] {
    const latest = loadLoadout(loadoutKey);
    if (latest.length) loadout = latest;
    const active = activeLoadoutEntry(selected);
    if (!loadout.length) {
      loadout = [active];
      const other = getModelOptions(scopeKey()).find(
        (option) => option.model.id !== selected.model.id && option.model.provider !== selected.model.provider,
      );
      if (other) loadout.push({ value: other.value, effort: defaultEffortForModel(other.model), fast: false });
    }
    return reconcileLoadout(loadout, getModelOptions(scopeKey()), active).map((entry) =>
      normalizeLoadoutEntry(entry, modelOptionFor(entry.value, scopeKey())!),
    );
  }

  function rememberActiveTweaks(selected: ModelOption): void {
    loadout = upsertLoadout(seededLoadout(selected), activeLoadoutEntry(selected));
    saveLoadout(loadout, loadoutKey);
  }

  function applyLoadout(entry: LoadoutEntry, agent: Agent): void {
    const option = modelOptionFor(entry.value, scopeKey());
    if (!option) return;
    const previous = currentModelOption();
    if (previous) rememberActiveTweaks(previous);
    const wasOpen = composerState.openMenu === "loadout";
    selectModel(entry.value, agent);
    const normalized = normalizeLoadoutEntry(entry, option);
    composerState.effortLevel = normalized.effort;
    composerState.fastMode = normalized.fast;
    loadout = upsertLoadout(loadout, activeLoadoutEntry(option));
    saveLoadout(loadout, loadoutKey);
    modelPicker.resetSection();
    composerState.openMenu = wasOpen ? "loadout" : null;
    ctx.chat.drawActiveChat(agent);
    placeLoadout();
  }

  function composerShortcut(e: KeyboardEvent, agent: Agent, disabled: boolean): void {
    if (disabled || e.defaultPrevented || !e.metaKey) return;
    if (e.shiftKey && e.code === "KeyE") {
      e.preventDefault();
      toggleFastMode(agent);
    }
  }

  function addLoadoutEntry(option: ModelOption, agent: Agent): void {
    const current = currentModelOption();
    if (!current || seededLoadout(current).length >= LOADOUT_CAP) return;
    applyLoadout({ value: option.value, effort: defaultEffortForModel(option.model), fast: false }, agent);
    composerState.menuQuery = "";
  }

  function matchSkills(query: string, skills: SkillItem[]): SkillMatch[] {
    const q = query.toLowerCase();
    if (!q) return skills.map((skill) => ({ skill, start: -1, end: -1 }));
    const out: SkillMatch[] = [];
    for (const skill of skills) {
      const at = skill.name.toLowerCase().indexOf(q);
      if (at >= 0) out.push({ skill, start: at, end: at + q.length });
    }
    return out.sort((a, b) => a.start - b.start || a.skill.name.localeCompare(b.skill.name));
  }

  function currentSlashMenu(): { open: boolean; loading: boolean; matches: SkillMatch[] } {
    const query = slashQuery(composerState.draft);
    if (query === null || composerState.slashDismissed) return { open: false, loading: false, matches: [] };
    const loading = skillsLoading;
    const matches = skillsCache ? matchSkills(query, skillsCache) : [];
    return { open: loading || matches.length > 0, loading, matches };
  }

  function clampedActive(matchCount: number): number {
    return Math.max(0, Math.min(slashActiveIndex, matchCount - 1));
  }

  async function loadSkills(agent: Agent): Promise<void> {
    if (skillsLoading || skillsCache !== null) return;
    skillsLoading = true;
    ctx.chat.drawActiveChat(agent);
    try {
      const r = await api<{ skills: SkillItem[] }>("/api/skills");
      skillsCache = r.skills ?? [];
    } catch {
      skillsCache = null;
    } finally {
      skillsLoading = false;
      if (agent === ctx.chat.state.agent) ctx.chat.drawActiveChat(agent);
    }
  }

  function acceptSkill(skill: SkillItem, agent: Agent): void {
    composerState.draft = composerState.draft.replace(SLASH_TOKEN, (_m, pre: string) => `${pre}/${skill.name} `);
    persistDraft();
    slashActiveIndex = 0;
    composerState.slashDismissed = false;
    ctx.chat.drawActiveChat(agent);
    focusComposerEnd();
  }

  function fillSuggestedPrompt(prompt: string, agent: Agent): void {
    if (
      agent !== ctx.chat.state.agent ||
      agent.state.isStreaming ||
      composerState.draft ||
      composerState.attachments.length ||
      composerState.processingFiles
    )
      return;
    composerState.draft = prompt;
    composerState.error = "";
    persistDraft();
    ctx.chat.drawActiveChat(agent);
    focusComposerEnd();
  }

  let pendingComposerFocus = false;

  function focusComposerEnd(): void {
    requestAnimationFrame(() => {
      const ta = ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".composer-input");
      if (!ta) return;
      if (ta.disabled) {
        pendingComposerFocus = true;
        return;
      }
      pendingComposerFocus = false;
      ta.focus({ preventScroll: true });
      ta.setSelectionRange(ta.value.length, ta.value.length);
    });
  }

  function closeSlashMenu(agent: Agent): void {
    composerState.slashDismissed = true;
    ctx.chat.drawActiveChat(agent);
  }

  function slashMenu(agent: Agent): TemplateResult | typeof nothing {
    const slash = currentSlashMenu();
    if (!slash.open) return nothing;
    if (slash.loading && slash.matches.length === 0) {
      return html`<div class="slash-popover">
        <div class="menu-title">Skills</div>
        <div class="slash-empty">Loading skills…</div>
      </div>`;
    }
    const active = clampedActive(slash.matches.length);
    return html`
      <div class="slash-popover" role="listbox" aria-label="Skills">
        <div class="menu-title">Skills</div>
        ${slash.matches.map((m, i) => slashRow(m, i === active, agent))}
      </div>
    `;
  }

  function slashRow(m: SkillMatch, active: boolean, agent: Agent): TemplateResult {
    return html`
      <button
        type="button"
        role="option"
        aria-selected=${active ? "true" : "false"}
        class="slash-option ${active ? "active" : ""}"
        ${tip(m.skill.description)}
        @mousedown=${(e: Event) => e.preventDefault()}
        @click=${() => acceptSkill(m.skill, agent)}
      >
        <span class="slash-icon">${icon(Box, 16)}</span>
        <span class="slash-name">${highlightName(m)}</span>
        <span class="slash-desc">${m.skill.description}</span>
        <span class="slash-scope">${scopeBadge(m.skill.scope)}</span>
      </button>
    `;
  }

  function highlightName(m: SkillMatch): TemplateResult {
    const { name } = m.skill;
    if (m.start < 0 || m.end <= m.start) return html`${name}`;
    return html`${name.slice(0, m.start)}<b>${name.slice(m.start, m.end)}</b>${name.slice(m.end)}`;
  }

  function scopeBadge(scope: string): string {
    return scope ? scope.charAt(0).toUpperCase() + scope.slice(1) : "";
  }

  function submitComposer(e: Event, agent: Agent): void {
    e.preventDefault();
    void sendPrompt(agent);
  }

  function onDraftInput(e: InputEvent, agent: Agent): void {
    const wasEmpty = !composerState.draft;
    composerState.draft = (e.currentTarget as HTMLTextAreaElement).value;
    persistDraft();
    const hadError = Boolean(composerState.error);
    composerState.error = "";
    composerState.slashDismissed = false;
    slashActiveIndex = 0;
    const armed = slashQuery(composerState.draft) !== null;
    if (armed && skillsCache === null && !skillsLoading) void loadSkills(agent);
    const popoverShown = Boolean(ctx.chat.state.host?.querySelector(".slash-popover"));
    if (
      armed ||
      popoverShown ||
      hadError ||
      (Boolean(appState.me?.suggestedActivities?.length) && wasEmpty !== !composerState.draft)
    ) {
      ctx.chat.drawActiveChat(agent);
      return;
    }
    syncComposerControls(agent);
    resizeComposer();
  }

  function composerCanSend(): boolean {
    if (!currentModelOption()) return false;
    return (
      Boolean(composerState.draft.trim() || composerState.attachments.length) &&
      !composerState.processingFiles &&
      !submitting &&
      getRuntimeConfig(scopeKey()) !== null &&
      ctx.chat.state.resolvingApprovals.size === 0 &&
      !ctx.chat.hasUnresolvedApproval()
    );
  }

  function syncComposerControls(agent: Agent): void {
    if (!ctx.chat.state.host || agent !== ctx.chat.state.agent) return;
    const send = ctx.chat.state.host.querySelector<HTMLButtonElement>(".send-btn");
    if (send) send.disabled = !composerCanSend();
  }

  function clearComposerDom(agent: Agent): void {
    if (!ctx.chat.state.host || agent !== ctx.chat.state.agent) return;
    const input = ctx.chat.state.host.querySelector<HTMLTextAreaElement>(".composer-input");
    if (input) {
      input.value = "";
      input.style.height = "auto";
      input.style.overflowY = "hidden";
      input.scrollTop = 0;
    }
    const send = ctx.chat.state.host.querySelector<HTMLButtonElement>(".send-btn");
    if (send) send.disabled = true;
  }

  function onComposerKeydown(e: KeyboardEvent, agent: Agent): void {
    // During IME composition (Japanese/Chinese/Korean), Enter confirms the
    // conversion — it must never send. Safari reports composition Enter with
    // keyCode 229 and may fire after compositionend, so check both.
    if (e.isComposing || e.keyCode === 229) return;
    const slash = currentSlashMenu();
    if (slash.open) {
      if (e.key === "Escape") {
        e.preventDefault();
        return closeSlashMenu(agent);
      }
      if (slash.matches.length) {
        const count = slash.matches.length;
        if (e.key === "ArrowDown") {
          e.preventDefault();
          slashActiveIndex = (clampedActive(count) + 1) % count;
          return ctx.chat.drawActiveChat(agent);
        }
        if (e.key === "ArrowUp") {
          e.preventDefault();
          slashActiveIndex = (clampedActive(count) - 1 + count) % count;
          return ctx.chat.drawActiveChat(agent);
        }
        if (!e.shiftKey && (e.key === "Enter" || e.key === "Tab")) {
          e.preventDefault();
          return acceptSkill(slash.matches[clampedActive(count)]!.skill, agent);
        }
      } else if (e.key === "Enter" && !e.shiftKey) {
        e.preventDefault();
        return;
      }
    }
    if (e.key !== "Enter" || e.shiftKey) return;
    e.preventDefault();
    void sendPrompt(agent);
  }

  function stopStreaming(agent: Agent): void {
    composerState.error = "";
    void ctx.chat.stopLiveRun().catch(() => {
      if (agent !== ctx.chat.state.agent) return;
      composerState.error = "Could not request stop. Try again.";
      ctx.chat.drawActiveChat(agent);
    });
    focusComposerEnd();
  }

  let failedQueueSend: { threadRef: string; text: string; filesKey: string; idempotencyKey: string } | null = null;

  function queuedFilesKey(staged: readonly Attachment[]): string {
    return staged.map((a) => a.id).join(",");
  }

  function queueSendKey(threadRef: string, text: string, filesKey: string): string {
    return failedQueueSend?.threadRef === threadRef &&
      failedQueueSend.text === text &&
      failedQueueSend.filesKey === filesKey
      ? failedQueueSend.idempotencyKey
      : mintSendKey();
  }

  async function queueDraft(agent: Agent): Promise<void> {
    const threadRef = ctx.chat.state.threadRef;
    const text = composerState.draft.trim();
    const staged = composerState.attachments;
    if ((!text && !staged.length) || !threadRef) return;
    clearActiveDraft();
    composerState.draft = "";
    composerState.attachments = [];
    composerState.error = "";
    ctx.chat.drawActiveChat(agent);
    clearComposerDom(agent);
    const { uploaded, skipped } = await uploadAttachments(staged);
    const stillHere = (): boolean => ctx.chat.state.threadRef === threadRef;
    if (skipped.length && stillHere()) composerState.error = skipped.map((s) => s.note).join(" ");
    const droppedIds = new Set(skipped.filter((s) => s.permanent).flatMap((s) => (s.id ? [s.id] : [])));
    const transientIds = new Set(skipped.filter((s) => !s.permanent).flatMap((s) => (s.id ? [s.id] : [])));
    const sendable = staged.filter((a) => !droppedIds.has(a.id));
    if (!text && !uploaded.length) {
      if (stillHere()) restoreStagedOnFailure(text, sendable, composerState.error || "Could not queue the files.");
      return ctx.chat.drawActiveChat(agent);
    }
    const steer = alwaysSteer() && canSteer(agent);
    if (!(await enqueueTurn(agent, threadRef, text, uploaded, queuedFilesKey(sendable), steer))) {
      if (stillHere()) restoreStagedOnFailure(text, sendable, composerState.error);
    } else if (transientIds.size && stillHere()) {
      restageAttachments(
        staged.filter((a) => transientIds.has(a.id)),
        composerState.error,
      );
    }
    ctx.chat.drawActiveChat(agent);
  }

  function restoreStagedOnFailure(text: string, staged: Attachment[], note: string): void {
    const typedSince = composerState.draft.trim();
    composerState.draft = !typedSince || typedSince === text ? text : `${text}\n${composerState.draft}`;
    const { kept, note: capNote } = mergeStagedAttachments(staged, composerState.attachments);
    composerState.attachments = kept;
    composerState.error = combineNote(note, capNote);
  }

  async function enqueueTurn(
    agent: Agent,
    threadRef: string,
    text: string,
    attachments: CoreAttachment[] = [],
    filesKey = "",
    steer = false,
  ): Promise<boolean> {
    const idempotencyKey = queueSendKey(threadRef, text, filesKey);
    try {
      const queued = await queueTurn(threadRef, text, agent, ctx.chat.currentTurnOptions, idempotencyKey, attachments);
      failedQueueSend = null;
      bumpSessionActivity(threadRef);
      if (steer && canSteer(agent) && threadRef === ctx.chat.state.threadRef) void steerQueued(agent, queued, true);
      else addQueuedRun(threadRef, queued);
      return true;
    } catch (err) {
      failedQueueSend = { threadRef, text, filesKey, idempotencyKey };
      composerState.error = errMessage(err, "Could not queue the message.");
      return false;
    }
  }

  function cancelQueuedEdit(agent: Agent): void {
    if (queuedEdit?.saving) return;
    queuedEdit = null;
    composerState.error = "";
    ctx.chat.drawActiveChat(agent);
    focusComposerEnd();
  }

  async function saveQueuedEdit(agent: Agent): Promise<void> {
    const edit = queuedEdit;
    if (!edit || edit.saving) return;
    edit.saving = true;
    composerState.error = "";
    ctx.chat.drawActiveChat(agent);
    try {
      await editQueuedRun(edit.runId, edit.text, edit.original);
      setQueuedRuns(
        edit.threadRef,
        queuedRunsFor(edit.threadRef).map((q) => (q.runId === edit.runId ? { ...q, text: edit.text } : q)),
      );
      if (queuedEdit === edit) {
        queuedEdit = null;
        if (ctx.chat.state.threadRef === edit.threadRef && ctx.chat.state.agent === agent) focusComposerEnd();
      }
    } catch (error) {
      if (ctx.chat.state.threadRef === edit.threadRef)
        composerState.error =
          error instanceof ApiError && error.status === 409
            ? "That message changed or already started. Your edit was not saved."
            : errMessage(error, "Could not edit the queued message.");
    } finally {
      edit.saving = false;
      if (ctx.chat.state.threadRef === edit.threadRef) ctx.chat.drawActiveChat(agent);
    }
  }

  async function removeQueued(agent: Agent, queued: QueuedRun): Promise<void> {
    const threadRef = ctx.chat.state.threadRef;
    if (!threadRef) return;
    composerState.error = "";
    try {
      await withdrawRun(queued.runId);
    } catch (err) {
      if (!(err instanceof ApiError && (err.status === 409 || err.status === 404))) {
        composerState.error = errMessage(err, "Could not remove the queued message.");
        return ctx.chat.drawActiveChat(agent);
      }
    }
    forgetQueuedRun(threadRef, queued.runId);
    ctx.chat.drawActiveChat(agent);
  }

  const pendingSteers = new Set<string>();

  function addQueuedRun(threadRef: string, queued: QueuedRun): void {
    setQueuedRuns(threadRef, [...queuedRunsFor(threadRef).filter((r) => r.runId !== queued.runId), queued]);
  }

  function markSteering(threadRef: string, queued: QueuedRun): void {
    steeringRuns.set(threadRef, [
      ...(steeringRuns.get(threadRef) ?? []).filter((run) => run.runId !== queued.runId),
      { ...queued, ts: `queued-steer:${threadRef}:${queued.runId}` },
    ]);
  }

  function unmarkSteering(threadRef: string, runId: string): void {
    const rest = (steeringRuns.get(threadRef) ?? []).filter((run) => run.runId !== runId);
    if (rest.length) steeringRuns.set(threadRef, rest);
    else steeringRuns.delete(threadRef);
  }

  async function steerQueued(agent: Agent, queued: QueuedRun, fresh = false): Promise<void> {
    const threadRef = ctx.chat.state.threadRef;
    if (!threadRef || !ctx.chat.hasLiveRun() || pendingSteers.has(queued.runId)) {
      if (fresh && threadRef) addQueuedRun(threadRef, queued);
      return;
    }
    pendingSteers.add(queued.runId);
    composerState.error = "";
    markSteering(threadRef, queued);
    let steered = false;
    let fallBackToQueue = fresh;
    try {
      const outcome = await ctx.chat.signalLiveRun("steer", queued.text, queued.runId);
      steered = outcome.ok;
      if (outcome.ok || outcome.replayed) {
        fallBackToQueue = false;
        forgetQueuedRun(threadRef, queued.runId);
        bumpSessionActivity(threadRef);
        if (
          !outcome.ok &&
          outcome.replayed &&
          agent === ctx.chat.state.agent &&
          threadRef === ctx.chat.state.threadRef
        ) {
          agent.state.messages.push({
            role: "user",
            content: queued.text,
            timestamp: Date.now(),
          } as unknown as AgentMessage);
        }
      } else if (outcome.reason === "queued_started" || outcome.reason === "not_found") {
        fallBackToQueue = false;
        forgetQueuedRun(threadRef, queued.runId);
      } else {
        reportHandledError("web:steer_refused", new Error(outcome.reason ?? "steer refused"));
        if (
          outcome.reason === "queued_changed" &&
          agent === ctx.chat.state.agent &&
          threadRef === ctx.chat.state.threadRef
        )
          composerState.error = "The queued message changed. Try steering it again.";
      }
    } catch (err) {
      reportHandledError("web:steer_queued", err);
      if (agent === ctx.chat.state.agent && threadRef === ctx.chat.state.threadRef)
        composerState.error = errMessage(err, "Could not confirm steering. Try again.");
    } finally {
      pendingSteers.delete(queued.runId);
      if (!steered) unmarkSteering(threadRef, queued.runId);
    }
    if (fallBackToQueue) addQueuedRun(threadRef, queued);
    if (agent !== ctx.chat.state.agent || threadRef !== ctx.chat.state.threadRef) return;
    ctx.chat.drawActiveChat(agent);
    ctx.chat.resumeIfIdle();
  }

  let pendingSubmissions = 0;
  let disposed = false;
  const preventUnsafeUpdate = (event: Event): void => {
    if (
      pendingSubmissions ||
      composerState.attachments.length ||
      composerState.processingFiles ||
      composerState.pasteView
    ) {
      event.preventDefault();
    }
  };
  window.addEventListener("qm:prepare-update", preventUnsafeUpdate);

  async function sendPrompt(agent: Agent): Promise<void> {
    pendingSubmissions++;
    try {
      await sendPromptNow(agent);
    } finally {
      pendingSubmissions--;
      if (disposed && !pendingSubmissions) window.removeEventListener("qm:prepare-update", preventUnsafeUpdate);
    }
  }

  async function sendPromptNow(agent: Agent): Promise<void> {
    if (!composerCanSend()) return;
    if (composerState.pasteView) closePasteView(agent);
    if (agent.state.isStreaming) return queueDraft(agent);
    const text = composerState.draft.trim();
    if (!text && composerState.attachments.length === 0) return;
    const submit = options.prepareSubmit?.();
    if (submit) {
      const selected = currentModelOption()!;
      const attachments = [...composerState.attachments];
      const selection: ComposerSubmission = {
        model: selected.model.id,
        harness: selected.harnessId,
        thinkingLevel: composerState.effortLevel,
        ...(harnessSupportsFastMode(selected.harnessId)
          ? { fastMode: modelSupportsFastMode(scopeKey(), selected.model.id) && effectiveFastMode() }
          : {}),
      };
      submitting = true;
      clearActiveDraft();
      resetComposer();
      ctx.chat.drawActiveChat(agent);
      try {
        const { uploaded, skipped } = await uploadAttachments(attachments);
        if (skipped.length) throw new Error(skipped.map((file) => file.note).join(" "));
        await submit(text, { ...selection, ...(uploaded.length ? { attachments: uploaded } : {}) });
      } catch (error) {
        restoreStagedOnFailure(text, attachments, errMessage(error, "Could not send message."));
        persistDraft();
      } finally {
        submitting = false;
        ctx.chat.drawActiveChat(agent);
      }
      return;
    }
    if (ctx.chat.state.threadRef) {
      bumpSessionActivity(ctx.chat.state.threadRef);
      ctx.chat.state.pendingSend = ctx.chat.state.threadRef;
      renderList();
    }
    const attachments = composerState.attachments;
    const sentFromThread = ctx.chat.state.threadRef;
    ctx.chat.notePendingSessionOnSend();
    clearActiveDraft();
    resetComposer();
    ctx.chat.drawActiveChat(agent);
    clearComposerDom(agent);
    try {
      if (ctx.chat.state.normalStreamFn) agent.streamFn = ctx.chat.state.normalStreamFn;
      ctx.chat.scrollToBottom();
      await agent.prompt(userSendMessage(text, attachments.length ? attachments : undefined));
      restoreBlockedSend(agent, sentFromThread, text, attachments);
      restoreFailedAttachments(agent, text, attachments);
    } catch (err) {
      ctx.chat.state.pendingSend = null;
      if (ctx.chat.state.threadRef && ctx.chat.state.sessionId === null) dropPendingSession(ctx.chat.state.threadRef);
      renderList();
      composerState.error = errMessage(err, "Could not send message.");
      ctx.chat.drawActiveChat(agent);
    }
  }

  function restoreFailedAttachments(agent: Agent, text: string, attachments: Attachment[]): void {
    const messages = agent.state.messages;
    const last = messages[messages.length - 1] as
      { role?: string; sendFailed?: string; droppedAttachmentIds?: string[] } | undefined;
    if (last?.role !== "assistant" || last.sendFailed !== "attachments" || agent !== ctx.chat.state.agent) return;
    const dropped = new Set(last.droppedAttachmentIds ?? []);
    const retryable = attachments.filter((a) => !dropped.has(a.id));
    messages.pop();
    const prompt = messages[messages.length - 1] as { role?: string } | undefined;
    if (prompt?.role === "user" || prompt?.role === "user-with-attachments") messages.pop();
    (agent.state as { errorMessage?: string }).errorMessage = undefined;
    ctx.chat.state.pendingSend = null;
    if (ctx.chat.state.threadRef && ctx.chat.state.sessionId === null) dropPendingSession(ctx.chat.state.threadRef);
    renderList();
    restoreStagedOnFailure(
      text,
      retryable,
      retryable.length
        ? "Couldn't attach the files, so the message wasn't sent. Try again."
        : "Nothing could be attached, so the message wasn't sent.",
    );
    persistDraft();
    ctx.chat.drawActiveChat(agent);
  }

  function restoreBlockedSend(
    agent: Agent,
    sentFromThread: string | null,
    text: string,
    attachments: Attachment[],
  ): void {
    const messages = agent.state.messages;
    const last = messages[messages.length - 1] as
      { role?: string; sendBlocked?: string; errorMessage?: string } | undefined;
    if (last?.role !== "assistant" || last.sendBlocked !== "pending_approval") return;
    if (agent !== ctx.chat.state.agent) {
      if (sentFromThread) saveDraft(sentFromThread, text);
      return;
    }
    messages.pop();
    const prompt = messages[messages.length - 1] as { role?: string } | undefined;
    if (prompt?.role === "user" || prompt?.role === "user-with-attachments") messages.pop();
    (agent.state as { errorMessage?: string }).errorMessage = undefined;
    ctx.chat.state.pendingSend = null;
    if (ctx.chat.state.threadRef && ctx.chat.state.sessionId === null) dropPendingSession(ctx.chat.state.threadRef);
    renderList();
    const typedSince = composerState.draft.trim();
    composerState.draft = !typedSince || typedSince === text ? text : `${text}\n${composerState.draft}`;
    const { kept, note } = mergeStagedAttachments(attachments, composerState.attachments);
    composerState.attachments = kept;
    composerState.error = combineNote(last.errorMessage || PENDING_APPROVAL_REASON, note);
    persistDraft();
    ctx.chat.drawActiveChat(agent);
  }

  const LARGE_PASTE_CHARS = 2000;

  async function onComposerPaste(e: ClipboardEvent, agent: Agent): Promise<void> {
    const data = e.clipboardData;
    if (!data) return;
    const files = Array.from(data.items)
      .filter((item) => item.kind === "file")
      .map((item) => item.getAsFile())
      .filter((file): file is File => file !== null);
    if (files.length) {
      e.preventDefault();
      await addFiles(files, agent);
      return;
    }
    const text = data.getData("text/plain");
    if (text.length <= LARGE_PASTE_CHARS) return;
    if (ctx.chat.hasUnresolvedApproval() || ctx.chat.state.resolvingApprovals.size > 0 || composerState.processingFiles)
      return;
    if (composerState.attachments.length >= MAX_FILES_PER_MESSAGE) return;
    e.preventDefault();
    const names = new Set(composerState.attachments.map((a) => a.fileName));
    let n = 1;
    while (names.has(n === 1 ? "pasted-text.txt" : `pasted-text-${n}.txt`)) n++;
    const bytes = new TextEncoder().encode(text);
    const attachment: Attachment = {
      id: `paste_${Date.now()}_${Math.random()}`,
      type: "document",
      fileName: n === 1 ? "pasted-text.txt" : `pasted-text-${n}.txt`,
      mimeType: "text/plain",
      size: bytes.length,
      content: bytesToBase64(bytes),
      extractedText: text,
    };
    pastedTextIds.add(attachment.id);
    composerState.attachments = [...composerState.attachments, attachment];
    ctx.chat.drawActiveChat(agent);
  }

  async function onFilesSelected(e: Event, agent: Agent): Promise<void> {
    const input = e.currentTarget as HTMLInputElement;
    const files = Array.from(input.files ?? []);
    input.value = "";
    await addFiles(files, agent);
  }

  async function fileToBase64(file: File): Promise<string> {
    return bytesToBase64(new Uint8Array(await file.arrayBuffer()));
  }

  async function loadAnyAttachment(file: File): Promise<Attachment> {
    try {
      const { loadAttachment } = await import("@earendil-works/pi-web-ui");
      return await loadAttachment(file);
    } catch {
      return {
        id: `${file.name}_${Date.now()}_${Math.random()}`,
        type: "document",
        fileName: file.name,
        mimeType: file.type || "application/octet-stream",
        size: file.size,
        content: await fileToBase64(file),
      };
    }
  }

  function restageAttachments(attachments: Attachment[], note: string): void {
    if (!attachments.length) {
      composerState.error = note;
      return;
    }
    const { kept, note: capNote } = mergeStagedAttachments(attachments, composerState.attachments);
    composerState.attachments = kept;
    composerState.error = combineNote(note, capNote);
  }

  function combineNote(existing: string, note: string | null): string {
    if (!note) return existing;
    return existing ? `${existing} ${note}` : note;
  }

  function capOverflowNote(dropped: readonly { fileName: string }[]): string | null {
    return dropped.length ? tooManyFilesNote(dropped.map((a) => a.fileName)) : null;
  }

  function mergeStagedAttachments(
    restored: Attachment[],
    current: Attachment[],
  ): { kept: Attachment[]; note: string | null } {
    const seen = new Set<string>();
    const merged: Attachment[] = [];
    for (const a of [...restored, ...current]) {
      if (seen.has(a.id)) continue;
      seen.add(a.id);
      merged.push(a);
    }
    return { kept: merged.slice(0, MAX_FILES_PER_MESSAGE), note: capOverflowNote(merged.slice(MAX_FILES_PER_MESSAGE)) };
  }

  function planAdmission(files: File[], folderCount: number): { files: File[]; folders: number; note: string | null } {
    const notes: string[] = [];
    const sized: File[] = [];
    for (const file of files) {
      if (file.size > MAX_ATTACHMENT_BYTES) notes.push(oversizeAttachmentNote(file.name));
      else sized.push(file);
    }
    const room = Math.max(0, MAX_FILES_PER_MESSAGE - composerState.attachments.length);
    const admittedFiles = sized.slice(0, room);
    const admittedFolders = Math.min(folderCount, Math.max(0, room - admittedFiles.length));
    const overflow = [
      ...sized.slice(room).map((f) => f.name),
      ...Array.from({ length: folderCount - admittedFolders }, () => "a folder"),
    ];
    if (overflow.length) notes.push(tooManyFilesNote(overflow));
    return { files: admittedFiles, folders: admittedFolders, note: notes.length ? notes.join(" ") : null };
  }

  async function addFiles(files: File[], agent: Agent, folders: DropEntryLike[] = []): Promise<void> {
    if (
      (!files.length && !folders.length) ||
      ctx.chat.hasUnresolvedApproval() ||
      ctx.chat.state.resolvingApprovals.size > 0
    )
      return;
    if (composerState.processingFiles) {
      composerState.error = "Still preparing the previous drop. Try again in a moment.";
      ctx.chat.drawActiveChat(agent);
      return;
    }
    composerState.processingFiles = true;
    composerState.error = "";
    ctx.chat.drawActiveChat(agent);
    const plan = planAdmission(files, folders.length);
    try {
      const zipped: File[] = [];
      for (const folder of folders.slice(0, plan.folders)) zipped.push(await folderToZipFile(folder));
      const loaded = await Promise.all([...plan.files, ...zipped].map((file) => loadAnyAttachment(file)));
      composerState.attachments = [...composerState.attachments, ...loaded];
      if (plan.note) composerState.error = plan.note;
    } catch (err) {
      let message: string;
      if (err instanceof FolderDropError) message = err.message;
      else if (isFolderReadError(err))
        message = "That drop included a folder this browser can't read. Zip it and drop the archive instead.";
      else message = errMessage(err, "Could not attach that file.");
      composerState.error = combineNote(plan.note ?? "", message);
    } finally {
      composerState.processingFiles = false;
      ctx.chat.drawActiveChat(agent);
    }
  }

  function dragHasFiles(e: DragEvent): boolean {
    const types = e.dataTransfer?.types;
    return types ? Array.from(types).includes("Files") : false;
  }

  function onDragEnter(e: DragEvent): void {
    if (!dragHasFiles(e)) return;
    e.preventDefault();
    fileDrag.enter(e);
  }

  function onDragOver(e: DragEvent): void {
    if (!dragHasFiles(e)) return;
    e.preventDefault();
    if (e.dataTransfer) e.dataTransfer.dropEffect = "copy";
  }

  function onDragLeave(e: DragEvent): void {
    fileDrag.leave(e);
  }

  async function onDrop(e: DragEvent, agent: Agent): Promise<void> {
    if (!dragHasFiles(e)) return;
    e.preventDefault();
    fileDrag.reset();
    const { files, folders } = splitDropItems(Array.from(e.dataTransfer?.items ?? []));
    if (!files.length && !folders.length) files.push(...Array.from(e.dataTransfer?.files ?? []));
    ctx.chat.drawActiveChat(agent);
    await addFiles(files, agent, folders);
  }

  function pickFiles(): void {
    if (ctx.chat.hasUnresolvedApproval() || ctx.chat.state.resolvingApprovals.size > 0) return;
    ctx.chat.state.host?.querySelector<HTMLInputElement>(".file-input")?.click();
  }

  function openImagePreview(attachment: Attachment): void {
    const dialog = document.createElement("dialog");
    dialog.className = "project-dialog attachment-preview";
    dialog.setAttribute("aria-label", attachment.fileName);
    dialog.addEventListener(
      "close",
      () => {
        render(nothing, dialog);
        dialog.remove();
      },
      { once: true },
    );
    document.body.append(dialog);
    const src = attachment.content.startsWith("data:")
      ? attachment.content
      : `data:${attachment.mimeType};base64,${attachment.content}`;
    render(
      html`
        <div class="attachment-preview-head">
          <span dir="auto">${attachment.fileName}</span>
          <button type="button" class="btn compact" @click=${() => dialog.close()}>Close</button>
        </div>
        <div class="attachment-preview-body">
          <button
            type="button"
            aria-label="Toggle actual image size"
            @click=${(event: Event) => (event.currentTarget as HTMLElement).classList.toggle("actual-size")}
          >
            <img src=${src} alt=${attachment.fileName} />
          </button>
        </div>
      `,
      dialog,
    );
    dialog.showModal();
  }

  function removeAttachment(id: string, agent: Agent): void {
    composerState.attachments = composerState.attachments.filter((a) => a.id !== id);
    pastedTextIds.delete(id);
    if (composerState.pasteView?.id === id) composerState.pasteView = null;
    ctx.chat.drawActiveChat(agent);
  }

  function clearChatSelection(): void {
    if (ctx.chat.state.threadRef) forgetThreadPick(ctx.chat.state.threadRef);
    effortOverride = undefined;
    fastModeOverride = undefined;
    restoredLoadout = undefined;
  }

  async function followScopeDefault(agent: Agent): Promise<void> {
    clearChatSelection();
    await refreshRuntimeSelection(ctx.chat.state.scopeId, agent, true);
  }

  function selectModel(value: string, agent: Agent): void {
    const option = getModelOptions(scopeKey()).find((candidate) => candidate.value === value);
    if (!option) return;
    ++modelSelectionRevision;
    const previousDefaultEffort = defaultEffortForModel(currentModelOption()?.model);
    if (ctx.chat.state.threadRef) rememberThreadPick(ctx.chat.state.threadRef, option.value);
    agent.state.model = option.model;
    if (composerState.effortLevel === previousDefaultEffort) {
      composerState.effortLevel = defaultEffortForModel(option.model);
    }
    composerState.openMenu = null;
    ctx.chat.drawActiveChat(agent);
  }

  function selectHarness(harnessId: string, agent: Agent): void {
    const selected = currentModelOption();
    if (!selected || selected.harnessId === harnessId) return;
    const target = compatibleHarnessOptions(getModelOptions(scopeKey()), selected.model.id).find(
      (option) => option.harnessId === harnessId,
    );
    if (!target) return;
    const active = activeLoadoutEntry(selected);
    applyLoadout({ ...active, value: target.value }, agent);
  }

  function selectEffort(level: EffortLevel, agent: Agent): void {
    const selected = currentModelOption();
    if (
      !selected ||
      !effortLevelsForHarness(selected.harnessId, selected.model).some((option) => option.value === level)
    )
      return;
    composerState.effortLevel = level;
    rememberActiveTweaks(selected);
    ctx.chat.drawActiveChat(agent);
    placeLoadout();
  }

  function toggleFastMode(agent: Agent): void {
    const selected = currentModelOption();
    if (ctx.chat.hasUnresolvedApproval() || ctx.chat.state.resolvingApprovals.size > 0) return;
    if (selected && isUltrafastModel(selected.model.id)) {
      const target = ultrafastChoice(getModelOptions(scopeKey()), selected);
      if (target) applyLoadout({ ...activeLoadoutEntry(selected), value: target.value, fast: true }, agent);
      return;
    }
    if (
      !selected ||
      !harnessSupportsFastMode(selected.harnessId) ||
      !modelSupportsFastMode(scopeKey(), selected.model.id)
    )
      return;
    composerState.fastMode = !effectiveFastMode();
    rememberActiveTweaks(selected);
    ctx.chat.drawActiveChat(agent);
    placeLoadout();
  }

  let autosizedTa: HTMLTextAreaElement | null = null;
  let autosizedValue: string | null = null;
  let autosizeObserver: ResizeObserver | null = null;

  function resizeComposer(): void {
    requestAnimationFrame(() => {
      const ta = ctx.chat.state.host?.querySelector<HTMLTextAreaElement>(".composer-input");
      if (!ta) return;
      if (autosizedTa !== ta && typeof ResizeObserver !== "undefined") {
        autosizeObserver ??= new ResizeObserver(() => {
          autosizedValue = null;
          resizeComposer();
        });
        if (autosizedTa) autosizeObserver.unobserve(autosizedTa);
        autosizeObserver.observe(ta);
        autosizedTa = ta;
        autosizedValue = null;
      }
      if (ta.value === autosizedValue) return;
      autosizedValue = ta.value;
      resizeComposerInput(ta, ctx.pane ? 0 : 48);
    });
  }

  function closeMenus(): boolean {
    let changed = false;
    if (composerState.openMenu) {
      modelPicker.resetSection();
      composerState.openMenu = null;
      changed = true;
    }
    if (!composerState.slashDismissed && slashQuery(composerState.draft) !== null) {
      composerState.slashDismissed = true;
      changed = true;
    }
    return changed;
  }

  function dispose(): void {
    disposed = true;
    if (!pendingSubmissions) window.removeEventListener("qm:prepare-update", preventUnsafeUpdate);
    window.removeEventListener("model-account-changed", refreshAccount);
    document.removeEventListener("visibilitychange", revalidateRuntime);
    modelPicker.dispose();
    unsubscribeRuntime?.();
    ++runtimeRequest;
    fileDrag.dispose();
    autosizeObserver?.disconnect();
    autosizeObserver = null;
    autosizedTa = null;
  }

  return {
    state: composerState,
    submit: async (instruction = "") => {
      if (submitting || !getRuntimeConfig(scopeKey())) return;
      const agent = ctx.chat.state.agent;
      if (!agent) return;
      if (instruction) composerState.draft = [composerState.draft.trim(), instruction].filter(Boolean).join("\n\n");
      await sendPrompt(agent);
    },
    restageAttachments,
    composerForm,
    composerApprovalPanel,
    queuedStrip,
    waitingSteers: (agent: Agent) => steeringRunsFor(ctx.chat.state.threadRef, agent),
    queuedRunsFor,
    setQueuedRuns,
    resetComposer,
    focusComposerEnd,
    fillSuggestedPrompt,
    addAnnotations: async (
      text: string,
      files: File[],
      annotationId = crypto.randomUUID(),
      remove = false,
    ): Promise<boolean> => {
      const agent = ctx.chat.state.agent;
      if (
        !agent ||
        composerState.processingFiles ||
        ctx.chat.hasUnresolvedApproval() ||
        ctx.chat.state.resolvingApprovals.size > 0
      )
        return false;
      const prefix = `annotation_${annotationId}_`;
      const retained = composerState.attachments.filter((attachment) => !attachment.id.startsWith(prefix));
      if (remove) {
        composerState.attachments = retained;
        ctx.chat.drawActiveChat(agent);
        return true;
      }
      if (retained.length + 1 + files.length > MAX_FILES_PER_MESSAGE) return false;
      composerState.processingFiles = true;
      ctx.chat.drawActiveChat(agent);
      try {
        const loaded = await Promise.all(files.map((file) => loadAnyAttachment(file)));
        if (agent !== ctx.chat.state.agent) return false;
        const remaining = composerState.attachments.filter((attachment) => !attachment.id.startsWith(prefix));
        if (remaining.length + 1 + loaded.length > MAX_FILES_PER_MESSAGE) return false;
        const bytes = new TextEncoder().encode(text);
        const annotation: Attachment = {
          id: prefix + "context",
          type: "document",
          fileName: "App annotation.md",
          mimeType: "text/markdown",
          size: bytes.length,
          content: bytesToBase64(bytes),
          extractedText: text,
        };
        composerState.attachments = [
          ...remaining,
          annotation,
          ...loaded.map((attachment, index) => ({ ...attachment, id: prefix + index })),
        ];
        composerState.error = "";
        return true;
      } catch {
        composerState.error = "Could not prepare annotation attachments. Retrying automatically.";
        return false;
      } finally {
        composerState.processingFiles = false;
        ctx.chat.drawActiveChat(agent);
      }
    },
    sendSuggestedPrompt: async (prompt: string, agent: Agent): Promise<void> => {
      if (
        agent !== ctx.chat.state.agent ||
        agent.state.isStreaming ||
        composerState.draft ||
        composerState.attachments.length ||
        composerState.processingFiles
      )
        return;
      fillSuggestedPrompt(prompt, agent);
      await sendPrompt(agent);
    },
    resizeComposer,
    currentModelOption,
    followsDefault,
    followScopeDefault,
    carryModelPick,
    refreshRuntimeSelection,
    onDragEnter,
    onDragOver,
    onDragLeave,
    onDrop,
    closeMenus,
    dispose,
  };
}