diff --git a/src/components/AgentModelsDialog.tsx b/src/components/AgentModelsDialog.tsx
index 95ae4397c..0f88396b4 100644
--- a/src/components/AgentModelsDialog.tsx
+++ b/src/components/AgentModelsDialog.tsx
@@ -22,7 +22,12 @@ import {
   serializeAgentConfig,
 } from "../lib/models/agent-config-serialization";
 import { formatCompactModelId, formatModelDisplay } from "../lib/models/display";
-import { type ModelOverrideMap, type ModelOverrideTarget } from "../lib/models/overrides";
+import type { ModelOverrideMap, ModelOverrideTarget } from "../lib/models/overrides";
+import {
+  DismissGuardNotice,
+  handleRovingFocusKeyDown,
+  useAccessibleDialog,
+} from "./accessibility/AccessibleDialog";
 import type { ComposerModelOption } from "./ChatComposer";
 import { CopyRawButton } from "./chat/CopyRawButton";
 import type {
@@ -161,18 +166,13 @@ export function AgentModelsDialog({
     }
   }, [open]);
 
-  useEffect(() => {
-    if (!open) {
-      return;
-    }
-    const handler = (event: KeyboardEvent) => {
-      if (event.key === "Escape") {
-        onClose();
-      }
-    };
-    window.addEventListener("keydown", handler);
-    return () => window.removeEventListener("keydown", handler);
-  }, [open, onClose]);
+  const accessibleDialog = useAccessibleDialog({
+    open,
+    onClose,
+    hasUnsavedChanges: Boolean(
+      pasteValue.trim() || profileName.trim() || profileDescription.trim(),
+    ),
+  });
 
   const serialized = useMemo(
     () =>
@@ -329,13 +329,17 @@ export function AgentModelsDialog({
   );
 
   return (
-    <div className="agent-models-backdrop" role="presentation" onMouseDown={onClose}>
+    <div className="agent-models-backdrop">
       <section
+        ref={accessibleDialog.dialogRef}
         className="agent-models-dialog"
         role="dialog"
         aria-modal="true"
         aria-labelledby="agent-models-title"
-        onMouseDown={(event) => event.stopPropagation()}
+        aria-describedby={
+          accessibleDialog.showDismissGuard ? "agent-models-dismiss-warning" : undefined
+        }
+        tabIndex={-1}
       >
         <header className="agent-models-header">
           <span className="agent-models-icon" aria-hidden="true">
@@ -352,19 +356,22 @@ export function AgentModelsDialog({
             className="icon-button"
             type="button"
             aria-label="Close agent models"
-            onClick={onClose}
+            data-dialog-initial-focus
+            onClick={accessibleDialog.requestClose}
           >
             <X size={18} />
           </button>
         </header>
 
-        <nav className="agent-models-tabs" role="tablist" aria-label="Agent models sections">
+        <div className="agent-models-tabs" role="tablist" aria-label="Agent models sections">
           <button
             type="button"
             role="tab"
             aria-selected={tab === "agents"}
+            tabIndex={tab === "agents" ? 0 : -1}
             className={tab === "agents" ? "is-active" : ""}
             onClick={() => setTab("agents")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <Sparkles size={15} /> Agents
           </button>
@@ -372,8 +379,10 @@ export function AgentModelsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "profiles"}
+            tabIndex={tab === "profiles" ? 0 : -1}
             className={tab === "profiles" ? "is-active" : ""}
             onClick={() => setTab("profiles")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <Save size={15} /> Profiles
             {profiles.length > 0 ? (
@@ -384,15 +393,25 @@ export function AgentModelsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "history"}
+            tabIndex={tab === "history" ? 0 : -1}
             className={tab === "history" ? "is-active" : ""}
             onClick={() => setTab("history")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <History size={15} /> History
             {revisions.length > 0 ? (
               <span className="agent-models-tab-count">{revisions.length}</span>
             ) : null}
           </button>
-        </nav>
+        </div>
+
+        <div id="agent-models-dismiss-warning">
+          <DismissGuardNotice
+            open={accessibleDialog.showDismissGuard}
+            onKeepEditing={accessibleDialog.keepEditing}
+            onDiscard={accessibleDialog.discardAndClose}
+          />
+        </div>
 
         {tab === "agents" ? (
           <>
diff --git a/src/components/AppConfigDialog.tsx b/src/components/AppConfigDialog.tsx
index 6584473a2..f12423e02 100644
--- a/src/components/AppConfigDialog.tsx
+++ b/src/components/AppConfigDialog.tsx
@@ -21,6 +21,11 @@ import {
 } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 
+import {
+  DismissGuardNotice,
+  handleRovingFocusKeyDown,
+  useAccessibleDialog,
+} from "./accessibility/AccessibleDialog";
 import { readJson } from "./chat/messageUtils";
 
 type TargetKind = "storage" | "vector" | "llm" | "observability" | "compute";
@@ -163,6 +168,15 @@ export function AppConfigDialog({
     return draft.observability.targets;
   }, [draft, tab]);
 
+  const configDirty =
+    Boolean(importText.trim()) ||
+    (draft !== null && view !== null && JSON.stringify(draft) !== JSON.stringify(view.config));
+  const accessibleDialog = useAccessibleDialog({
+    open,
+    onClose,
+    hasUnsavedChanges: configDirty,
+  });
+
   if (!open) return null;
 
   const updateTarget = (targetId: string, patch: Partial<ProviderTarget>) => {
@@ -402,13 +416,17 @@ export function AppConfigDialog({
   const registry = view?.registry[tab] ?? [];
 
   return (
-    <div className="app-config-backdrop" role="presentation" onMouseDown={onClose}>
+    <div className="app-config-backdrop">
       <section
+        ref={accessibleDialog.dialogRef}
         className="app-config-dialog"
         role="dialog"
         aria-modal="true"
         aria-labelledby="app-config-title"
-        onMouseDown={(event) => event.stopPropagation()}
+        aria-describedby={
+          accessibleDialog.showDismissGuard ? "app-config-dismiss-warning" : undefined
+        }
+        tabIndex={-1}
       >
         <header className="app-config-header">
           <span className="app-config-icon">
@@ -425,7 +443,8 @@ export function AppConfigDialog({
             className="icon-button"
             type="button"
             aria-label="Close app configuration"
-            onClick={onClose}
+            data-dialog-initial-focus
+            onClick={accessibleDialog.requestClose}
           >
             <X size={18} />
           </button>
@@ -453,7 +472,7 @@ export function AppConfigDialog({
           </div>
         ) : null}
 
-        <nav className="app-config-tabs" role="tablist">
+        <div className="app-config-tabs" role="tablist" aria-label="App configuration sections">
           {TABS.map((item) => {
             const Icon = item.icon;
             const count =
@@ -470,14 +489,24 @@ export function AppConfigDialog({
                 type="button"
                 role="tab"
                 aria-selected={tab === item.id}
+                tabIndex={tab === item.id ? 0 : -1}
                 className={tab === item.id ? "is-active" : ""}
                 onClick={() => setTab(item.id)}
+                onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
               >
                 <Icon size={15} /> {item.label} <span>{count ?? 0}</span>
               </button>
             );
           })}
-        </nav>
+        </div>
+
+        <div id="app-config-dismiss-warning">
+          <DismissGuardNotice
+            open={accessibleDialog.showDismissGuard}
+            onKeepEditing={accessibleDialog.keepEditing}
+            onDiscard={accessibleDialog.discardAndClose}
+          />
+        </div>
 
         <div className="app-config-toolbar">
           <textarea
diff --git a/src/components/ChatComposer.tsx b/src/components/ChatComposer.tsx
index 70da88fe0..ef0ac3405 100644
--- a/src/components/ChatComposer.tsx
+++ b/src/components/ChatComposer.tsx
@@ -35,6 +35,7 @@ import type { RemoteModelReasoning } from "../lib/models/remote-model-metadata";
 import { AUTONOMY_CONTROL_LABELS } from "../lib/security-chat/autonomy-controls";
 import type { RuntimeToolOption } from "../lib/tools/catalog";
 import { isHiddenRuntimeToolId } from "../lib/tools/catalog";
+import { handleRovingFocusKeyDown } from "./accessibility/AccessibleDialog";
 import { ComposerRunActivity } from "./chat/ComposerRunActivity";
 import type { RunMonitorView, SendMessageOptions } from "./chat/messageUtils";
 import {
@@ -42,6 +43,13 @@ import {
   type UploadResponseBody,
   uploadResultSummary,
 } from "./chat/uploadedEvidenceMessage";
+import {
+  admitUploadSelection,
+  CHAT_UPLOAD_LIMITS,
+  runBoundedTasks,
+  type UploadSelectionOutcome,
+  uploadSourcePath,
+} from "./uploads/uploadAdmission";
 
 export type ChatComposerHandle = {
   focus: () => void;
@@ -269,25 +277,33 @@ const isSignedUploadReady = (
   typeof upload.storageKey === "string" &&
   typeof upload.url === "string";
 
-const sha256File = async (file: File) => {
+const sha256File = async (file: File, signal?: AbortSignal) => {
+  if (signal?.aborted) throw new DOMException("Upload cancelled.", "AbortError");
   if (!globalThis.crypto?.subtle) {
     return undefined;
   }
   const digest = await globalThis.crypto.subtle.digest("SHA-256", await file.arrayBuffer());
+  if (signal?.aborted) throw new DOMException("Upload cancelled.", "AbortError");
   return Array.from(new Uint8Array(digest))
     .map((byte) => byte.toString(16).padStart(2, "0"))
     .join("");
 };
 
-const uploadSourcePath = (file: File) => file.webkitRelativePath?.trim() || file.name;
-
 const putSignedUpload = (
   file: File,
   upload: SignedUploadView & { url: string },
   onProgress: (loadedBytes: number) => void,
+  signal?: AbortSignal,
 ) =>
   new Promise<void>((resolve, reject) => {
     const xhr = new XMLHttpRequest();
+    const abort = () => xhr.abort();
+    const cleanup = () => signal?.removeEventListener("abort", abort);
+    if (signal?.aborted) {
+      reject(new DOMException("Upload cancelled.", "AbortError"));
+      return;
+    }
+    signal?.addEventListener("abort", abort, { once: true });
     xhr.open(upload.method ?? "PUT", upload.url);
     for (const [key, value] of Object.entries(upload.headers ?? {})) {
       xhr.setRequestHeader(key, value);
@@ -297,14 +313,22 @@ const putSignedUpload = (
     };
     xhr.onload = () => {
       if (xhr.status >= 200 && xhr.status < 300) {
+        cleanup();
         onProgress(file.size);
         resolve();
         return;
       }
+      cleanup();
       reject(new Error(`Signed upload failed for ${file.name}: ${xhr.status || "network error"}.`));
     };
-    xhr.onerror = () => reject(new Error(`Signed upload failed for ${file.name}.`));
-    xhr.onabort = () => reject(new Error(`Signed upload was cancelled for ${file.name}.`));
+    xhr.onerror = () => {
+      cleanup();
+      reject(new Error(`Signed upload failed for ${file.name}.`));
+    };
+    xhr.onabort = () => {
+      cleanup();
+      reject(new Error(`Signed upload was cancelled for ${file.name}.`));
+    };
     xhr.send(file);
   });
 
@@ -394,6 +418,7 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
   const [isUploading, setIsUploading] = useState(false);
   const [isSending, setIsSending] = useState(false);
   const [uploadStatus, setUploadStatus] = useState("");
+  const [uploadOutcomes, setUploadOutcomes] = useState<UploadSelectionOutcome[]>([]);
   const [isDragging, setIsDragging] = useState(false);
   const [isModelMenuOpen, setIsModelMenuOpen] = useState(false);
   const [isToolMenuOpen, setIsToolMenuOpen] = useState(false);
@@ -417,6 +442,7 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
   const settingsControlRef = useRef<HTMLDivElement>(null);
   const historyDraftRef = useRef("");
   const historyIndexRef = useRef<number | null>(null);
+  const uploadAbortRef = useRef<AbortController | null>(null);
 
   useImperativeHandle(
     ref,
@@ -449,21 +475,14 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
     if (nextFiles.length === 0) {
       return;
     }
-    setFiles((current) => {
-      const seen = new Set(
-        current.map((file) => `${uploadSourcePath(file)}:${file.size}:${file.lastModified}`),
-      );
-      const unique = nextFiles.filter((file) => {
-        const key = `${uploadSourcePath(file)}:${file.size}:${file.lastModified}`;
-        if (seen.has(key)) {
-          return false;
-        }
-        seen.add(key);
-        return true;
-      });
-      return [...current, ...unique];
-    });
-    setUploadStatus(`${nextFiles.length} file${nextFiles.length === 1 ? "" : "s"} ready.`);
+    const admission = admitUploadSelection(files, nextFiles);
+    setFiles(admission.files);
+    setUploadOutcomes(admission.outcomes);
+    const ready = admission.outcomes.filter((outcome) => outcome.status === "ready").length;
+    const rejected = admission.outcomes.length - ready;
+    setUploadStatus(
+      `${admission.files.length}/${CHAT_UPLOAD_LIMITS.maxFileCount} files ready · ${formatBytes(admission.totalBytes)} of ${formatBytes(CHAT_UPLOAD_LIMITS.maxTotalBytes)}${rejected ? ` · ${rejected} rejected before upload` : ""}.`,
+    );
   };
 
   const removeFile = (index: number) => {
@@ -495,6 +514,7 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
     const response = await fetch(`/api/projects/${encodeURIComponent(projectId)}/uploads`, {
       method: "POST",
       body: form,
+      signal: uploadAbortRef.current?.signal,
     });
     const body = (await response.json().catch(() => null)) as UploadResponseBody | null;
 
@@ -566,19 +586,27 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
       );
     };
 
-    const finalizedUploads = await Promise.all(
-      signedUploads.map(async (upload) => {
+    const taskOutcomes = await runBoundedTasks({
+      items: signedUploads,
+      concurrency: CHAT_UPLOAD_LIMITS.concurrency,
+      signal: uploadAbortRef.current?.signal,
+      run: async (upload, _taskIndex, signal) => {
         const file = filesToUpload[upload.uploadIndex];
         if (!file) {
           throw new Error("Signed upload plan referenced a missing file.");
         }
         loadedByIndex.set(upload.uploadIndex, 0);
         const [sha256] = await Promise.all([
-          sha256File(file),
-          putSignedUpload(file, upload, (loadedBytes) => {
-            loadedByIndex.set(upload.uploadIndex, Math.min(loadedBytes, file.size));
-            renderProgress();
-          }),
+          sha256File(file, signal),
+          putSignedUpload(
+            file,
+            upload,
+            (loadedBytes) => {
+              loadedByIndex.set(upload.uploadIndex, Math.min(loadedBytes, file.size));
+              renderProgress();
+            },
+            signal,
+          ),
         ]);
         completed.add(upload.uploadIndex);
         loadedByIndex.set(upload.uploadIndex, file.size);
@@ -593,8 +621,34 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
           storageKey: upload.storageKey,
           ...(sha256 ? { sha256 } : {}),
         };
+      },
+    });
+    const finalizedUploads = taskOutcomes.flatMap((outcome) =>
+      outcome.status === "completed" ? [outcome.value] : [],
+    );
+    setUploadOutcomes(
+      taskOutcomes.map((outcome) => {
+        const uploadIndex = signedUploads[outcome.index]?.uploadIndex ?? outcome.index;
+        const selectedFile = filesToUpload[uploadIndex];
+        return {
+          index: uploadIndex,
+          name:
+            selectedFile !== undefined
+              ? uploadSourcePath(selectedFile)
+              : (signedUploads[outcome.index]?.name ?? `Upload ${uploadIndex + 1}`),
+          status: outcome.status === "completed" ? "ready" : "rejected",
+          detail:
+            outcome.status === "completed" ? "Uploaded and ready for finalization." : outcome.error,
+        };
       }),
     );
+    if (finalizedUploads.length === 0) {
+      throw new Error(
+        uploadAbortRef.current?.signal.aborted
+          ? "Upload cancelled."
+          : "No files completed signed upload.",
+      );
+    }
 
     setUploadStatus("Finalizing uploaded evidence...");
     const completeResponse = await fetch(
@@ -629,6 +683,7 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
     }
 
     try {
+      uploadAbortRef.current = new AbortController();
       setIsUploading(true);
       const body =
         (await uploadFilesViaSignedUrls(filesToUpload)) ??
@@ -637,6 +692,7 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
       setUploadStatus(uploadResultSummary(body));
       return body;
     } finally {
+      uploadAbortRef.current = null;
       setIsUploading(false);
     }
   };
@@ -759,6 +815,14 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
       return haystack.includes(query);
     });
   }, [availableTools, toolQuery]);
+  const modelRovingIndex = Math.max(
+    0,
+    filteredModels.findIndex((model) => getModelKey(model.uri) === selectedModelKey),
+  );
+  const toolRovingIndex = Math.max(
+    0,
+    filteredTools.findIndex((tool) => selectedToolIdSet.has(tool.id)),
+  );
   const isBusy = disabled || isSending || isUploading;
   const settings = useMemo(
     () =>
@@ -988,6 +1052,15 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
           <div className="upload-status" aria-live="polite">
             {uploadStatus}
           </div>
+          {uploadOutcomes.length > 0 ? (
+            <ul className="composer-upload-outcomes" aria-label="Upload admission outcomes">
+              {uploadOutcomes.map((outcome) => (
+                <li key={`${outcome.index}-${outcome.name}`} data-status={outcome.status}>
+                  <strong>{outcome.name}</strong>: {outcome.detail}
+                </li>
+              ))}
+            </ul>
+          ) : null}
         </div>
         <div className="composer-actions">
           <input
@@ -1020,6 +1093,17 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
           >
             <Paperclip size={18} />
           </button>
+          {isUploading ? (
+            <button
+              className="toolbar-button"
+              type="button"
+              aria-label="Cancel evidence upload"
+              title="Cancel evidence upload"
+              onClick={() => uploadAbortRef.current?.abort()}
+            >
+              <X size={18} />
+            </button>
+          ) : null}
           <button
             className="toolbar-button"
             type="button"
@@ -1163,13 +1247,15 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
                 aria-label="Tools"
                 aria-multiselectable="true"
               >
-                {filteredTools.map((tool) => (
+                {filteredTools.map((tool, index) => (
                   <button
                     className={`tool-option${selectedToolIdSet.has(tool.id) ? " is-active" : ""}`}
                     type="button"
                     role="option"
                     aria-selected={selectedToolIdSet.has(tool.id)}
+                    tabIndex={index === toolRovingIndex ? 0 : -1}
                     key={tool.id}
+                    onKeyDown={(event) => handleRovingFocusKeyDown(event, "option")}
                     onClick={() => toggleTool(tool.id)}
                   >
                     <span className="tool-option-check">
@@ -1491,13 +1577,15 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(fu
                   />
                 </label>
                 <div className="model-options" role="listbox" aria-label="Models">
-                  {filteredModels.map((model) => (
+                  {filteredModels.map((model, index) => (
                     <button
                       className={`model-option${getModelKey(model.uri) === selectedModelKey ? " is-active" : ""}`}
                       type="button"
                       role="option"
                       aria-selected={getModelKey(model.uri) === selectedModelKey}
+                      tabIndex={index === modelRovingIndex ? 0 : -1}
                       key={model.id}
+                      onKeyDown={(event) => handleRovingFocusKeyDown(event, "option")}
                       onClick={() => {
                         setIsModelMenuOpen(false);
                         if (selectedModelTarget === "default") {
diff --git a/src/components/WorkspaceSettingsDialog.tsx b/src/components/WorkspaceSettingsDialog.tsx
index ab8e9a7ea..647c6d42e 100644
--- a/src/components/WorkspaceSettingsDialog.tsx
+++ b/src/components/WorkspaceSettingsDialog.tsx
@@ -16,11 +16,16 @@ import {
   Trash2,
   X,
 } from "lucide-react";
-import { FormEvent, useEffect, useMemo, useState } from "react";
+import { type FormEvent, useEffect, useMemo, useState } from "react";
 
 import { createId } from "../lib/ids";
 import type { SecurityResearchStructuredOutputMode } from "../lib/render-json";
 import type { ProjectWorkspaceConfig, WorkspaceSandboxProvider } from "../lib/workspace-config";
+import {
+  DismissGuardNotice,
+  handleRovingFocusKeyDown,
+  useAccessibleDialog,
+} from "./accessibility/AccessibleDialog";
 import { CopyRawButton } from "./chat/CopyRawButton";
 import { readJson } from "./chat/messageUtils";
 
@@ -392,6 +397,25 @@ export function WorkspaceSettingsDialog({
     };
   }, [open, projectId]);
 
+  const settingsDirty =
+    settingsDraft.egressProfile !== settings.egressProfile ||
+    settingsDraft.agencyLevel !== settings.agencyLevel ||
+    settingsDraft.verbosity !== settings.verbosity ||
+    settingsDraft.structuredOutputMode !== settings.structuredOutputMode ||
+    settingsDraft.contextCompressionMode !== settings.contextCompressionMode ||
+    !sameShellAccess(settingsDraft.shellAccess, settings.shellAccess) ||
+    JSON.stringify(settingsDraft.workspace ?? {}) !== JSON.stringify(settings.workspace ?? {}) ||
+    JSON.stringify(settingsDraft.providerBindings ?? {}) !==
+      JSON.stringify(settings.providerBindings ?? {}) ||
+    JSON.stringify(draft) !== JSON.stringify(emptyDraft()) ||
+    JSON.stringify(keyDraft) !== JSON.stringify(emptyKeyDraft()) ||
+    JSON.stringify(mcpDraft) !== JSON.stringify(emptyMcpDraft());
+  const accessibleDialog = useAccessibleDialog({
+    open,
+    onClose,
+    hasUnsavedChanges: settingsDirty,
+  });
+
   if (!open) {
     return null;
   }
@@ -620,25 +644,18 @@ export function WorkspaceSettingsDialog({
   };
 
   const selectedKey = sshKeys.find((key) => key.id === draft.sshKeyId);
-  const settingsDirty =
-    settingsDraft.egressProfile !== settings.egressProfile ||
-    settingsDraft.agencyLevel !== settings.agencyLevel ||
-    settingsDraft.verbosity !== settings.verbosity ||
-    settingsDraft.structuredOutputMode !== settings.structuredOutputMode ||
-    settingsDraft.contextCompressionMode !== settings.contextCompressionMode ||
-    !sameShellAccess(settingsDraft.shellAccess, settings.shellAccess) ||
-    JSON.stringify(settingsDraft.workspace ?? {}) !== JSON.stringify(settings.workspace ?? {}) ||
-    JSON.stringify(settingsDraft.providerBindings ?? {}) !==
-      JSON.stringify(settings.providerBindings ?? {});
-
   return (
-    <div className="workspace-settings-backdrop" role="presentation" onMouseDown={onClose}>
+    <div className="workspace-settings-backdrop">
       <section
+        ref={accessibleDialog.dialogRef}
         className="workspace-settings-dialog"
         role="dialog"
         aria-modal="true"
         aria-labelledby="workspace-settings-title"
-        onMouseDown={(event) => event.stopPropagation()}
+        aria-describedby={
+          accessibleDialog.showDismissGuard ? "workspace-settings-dismiss-warning" : undefined
+        }
+        tabIndex={-1}
       >
         <header className="workspace-settings-dialog-header">
           <span className="workspace-settings-dialog-icon" aria-hidden="true">
@@ -652,13 +669,14 @@ export function WorkspaceSettingsDialog({
             className="icon-button"
             type="button"
             aria-label="Close workspace settings"
-            onClick={onClose}
+            data-dialog-initial-focus
+            onClick={accessibleDialog.requestClose}
           >
             <X size={18} />
           </button>
         </header>
 
-        <nav
+        <div
           className="workspace-settings-tabs"
           role="tablist"
           aria-label="Workspace settings sections"
@@ -667,8 +685,10 @@ export function WorkspaceSettingsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "general"}
+            tabIndex={tab === "general" ? 0 : -1}
             className={tab === "general" ? "is-active" : ""}
             onClick={() => setTab("general")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <Shield size={15} /> General
           </button>
@@ -676,8 +696,10 @@ export function WorkspaceSettingsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "connections"}
+            tabIndex={tab === "connections" ? 0 : -1}
             className={tab === "connections" ? "is-active" : ""}
             onClick={() => setTab("connections")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <Link size={15} /> Connections
           </button>
@@ -685,8 +707,10 @@ export function WorkspaceSettingsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "providers"}
+            tabIndex={tab === "providers" ? 0 : -1}
             className={tab === "providers" ? "is-active" : ""}
             onClick={() => setTab("providers")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <ServerCog size={15} /> Providers
           </button>
@@ -694,8 +718,10 @@ export function WorkspaceSettingsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "mcp"}
+            tabIndex={tab === "mcp" ? 0 : -1}
             className={tab === "mcp" ? "is-active" : ""}
             onClick={() => setTab("mcp")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <PlugZap size={15} /> MCP
           </button>
@@ -703,12 +729,22 @@ export function WorkspaceSettingsDialog({
             type="button"
             role="tab"
             aria-selected={tab === "keys"}
+            tabIndex={tab === "keys" ? 0 : -1}
             className={tab === "keys" ? "is-active" : ""}
             onClick={() => setTab("keys")}
+            onKeyDown={(event) => handleRovingFocusKeyDown(event, "tab")}
           >
             <KeyRound size={15} /> Keys
           </button>
-        </nav>
+        </div>
+
+        <div id="workspace-settings-dismiss-warning">
+          <DismissGuardNotice
+            open={accessibleDialog.showDismissGuard}
+            onKeepEditing={accessibleDialog.keepEditing}
+            onDiscard={accessibleDialog.discardAndClose}
+          />
+        </div>
 
         {error ? <p className="workspace-settings-error">{error}</p> : null}
 
diff --git a/src/components/accessibility/AccessibleDialog.tsx b/src/components/accessibility/AccessibleDialog.tsx
new file mode 100644
index 000000000..2e29a9540
--- /dev/null
+++ b/src/components/accessibility/AccessibleDialog.tsx
@@ -0,0 +1,205 @@
+"use client";
+
+import {
+	type KeyboardEvent as ReactKeyboardEvent,
+	type RefObject,
+	useCallback,
+	useEffect,
+	useRef,
+	useState,
+} from "react";
+
+const FOCUSABLE_SELECTOR = [
+	"button:not([disabled])",
+	"[href]",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	'[tabindex]:not([tabindex="-1"])',
+].join(",");
+
+export function useAccessibleDialog(input: {
+	open: boolean;
+	onClose(): void;
+	hasUnsavedChanges?: boolean;
+}): {
+	dialogRef: RefObject<HTMLElement | null>;
+	requestClose(): void;
+	discardAndClose(): void;
+	keepEditing(): void;
+	showDismissGuard: boolean;
+} {
+	const dialogRef = useRef<HTMLElement>(null);
+	const previouslyFocusedRef = useRef<HTMLElement | null>(null);
+	const onCloseRef = useRef(input.onClose);
+	const dirtyRef = useRef(input.hasUnsavedChanges === true);
+	const [showDismissGuard, setShowDismissGuard] = useState(false);
+
+	onCloseRef.current = input.onClose;
+	dirtyRef.current = input.hasUnsavedChanges === true;
+
+	const requestClose = useCallback(() => {
+		if (dirtyRef.current) {
+			setShowDismissGuard(true);
+			return;
+		}
+		onCloseRef.current();
+	}, []);
+
+	const discardAndClose = useCallback(() => {
+		setShowDismissGuard(false);
+		onCloseRef.current();
+	}, []);
+
+	const keepEditing = useCallback(() => {
+		setShowDismissGuard(false);
+		dialogRef.current?.focus();
+	}, []);
+
+	useEffect(() => {
+		if (!input.open) {
+			setShowDismissGuard(false);
+			return;
+		}
+
+		previouslyFocusedRef.current =
+			document.activeElement instanceof HTMLElement
+				? document.activeElement
+				: null;
+		const focusInitialControl = () => {
+			const dialog = dialogRef.current;
+			if (!dialog) return;
+			const initial = dialog.querySelector<HTMLElement>(
+				`[data-dialog-initial-focus], ${FOCUSABLE_SELECTOR}`,
+			);
+			(initial ?? dialog).focus();
+		};
+		const frame = window.requestAnimationFrame(focusInitialControl);
+
+		const onKeyDown = (event: KeyboardEvent) => {
+			const dialog = dialogRef.current;
+			if (!dialog) return;
+			if (event.key === "Escape") {
+				event.preventDefault();
+				event.stopPropagation();
+				requestClose();
+				return;
+			}
+			if (event.key !== "Tab") return;
+
+			const controls = Array.from(
+				dialog.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
+			).filter(
+				(control) =>
+					control.getClientRects().length > 0 &&
+					control.getAttribute("aria-hidden") !== "true",
+			);
+			if (controls.length === 0) {
+				event.preventDefault();
+				dialog.focus();
+				return;
+			}
+			const first = controls[0];
+			const last = controls[controls.length - 1];
+			const active = document.activeElement;
+			if (event.shiftKey && (active === first || !dialog.contains(active))) {
+				event.preventDefault();
+				last.focus();
+			} else if (
+				!event.shiftKey &&
+				(active === last || !dialog.contains(active))
+			) {
+				event.preventDefault();
+				first.focus();
+			}
+		};
+
+		document.addEventListener("keydown", onKeyDown, true);
+		return () => {
+			window.cancelAnimationFrame(frame);
+			document.removeEventListener("keydown", onKeyDown, true);
+			previouslyFocusedRef.current?.focus();
+			previouslyFocusedRef.current = null;
+		};
+	}, [input.open, requestClose]);
+
+	return {
+		dialogRef,
+		requestClose,
+		discardAndClose,
+		keepEditing,
+		showDismissGuard,
+	};
+}
+
+export function DismissGuardNotice(props: {
+	open: boolean;
+	onKeepEditing(): void;
+	onDiscard(): void;
+}) {
+	const keepEditingRef = useRef<HTMLButtonElement>(null);
+
+	useEffect(() => {
+		if (props.open) keepEditingRef.current?.focus();
+	}, [props.open]);
+
+	if (!props.open) return null;
+	return (
+		<div className="dialog-dismiss-guard" role="alert">
+			<span>You have unsaved changes.</span>
+			<button
+				ref={keepEditingRef}
+				type="button"
+				className="secondary-button"
+				onClick={props.onKeepEditing}
+			>
+				Keep editing
+			</button>
+			<button type="button" className="danger-button" onClick={props.onDiscard}>
+				Discard changes
+			</button>
+		</div>
+	);
+}
+
+export function handleRovingFocusKeyDown(
+	event: ReactKeyboardEvent<HTMLElement>,
+	role: "tab" | "option",
+) {
+	const keys = [
+		"ArrowRight",
+		"ArrowDown",
+		"ArrowLeft",
+		"ArrowUp",
+		"Home",
+		"End",
+	];
+	if (!keys.includes(event.key)) return;
+	const container = event.currentTarget.closest(
+		role === "tab" ? '[role="tablist"]' : '[role="listbox"]',
+	);
+	if (!container) return;
+	const items = Array.from(
+		container.querySelectorAll<HTMLElement>(`[role="${role}"]`),
+	).filter(
+		(item) =>
+			!item.hasAttribute("disabled") &&
+			item.getAttribute("aria-disabled") !== "true",
+	);
+	const current = items.indexOf(event.currentTarget);
+	if (current < 0 || items.length === 0) return;
+	let next = current;
+	if (event.key === "Home") next = 0;
+	else if (event.key === "End") next = items.length - 1;
+	else if (event.key === "ArrowRight" || event.key === "ArrowDown") {
+		next = (current + 1) % items.length;
+	} else {
+		next = (current - 1 + items.length) % items.length;
+	}
+	event.preventDefault();
+	const nextItem = items[next];
+	if (!nextItem) return;
+	for (const item of items) item.tabIndex = item === nextItem ? 0 : -1;
+	nextItem.focus();
+	if (role === "tab") nextItem.click();
+}
diff --git a/src/components/uploads/uploadAdmission.ts b/src/components/uploads/uploadAdmission.ts
new file mode 100644
index 000000000..c9f127bce
--- /dev/null
+++ b/src/components/uploads/uploadAdmission.ts
@@ -0,0 +1,160 @@
+export type UploadAdmissionLimits = {
+	maxFileCount: number;
+	maxTotalBytes: number;
+	maxFileBytes: number;
+	concurrency: number;
+};
+
+export const CHAT_UPLOAD_LIMITS: Readonly<UploadAdmissionLimits> =
+	Object.freeze({
+		maxFileCount: 200,
+		maxTotalBytes: 200 * 1024 * 1024,
+		maxFileBytes: 20 * 1024 * 1024,
+		concurrency: 3,
+	});
+
+export type UploadSelectionOutcome = {
+	index: number;
+	name: string;
+	status: "ready" | "rejected";
+	detail: string;
+};
+
+export function admitUploadSelection(
+	current: readonly File[],
+	incoming: readonly File[],
+	limits: Readonly<UploadAdmissionLimits> = CHAT_UPLOAD_LIMITS,
+): { files: File[]; outcomes: UploadSelectionOutcome[]; totalBytes: number } {
+	const seen = new Set(current.map(fileIdentity));
+	const candidates: Array<{ file: File; index: number }> = [];
+	const outcomes: UploadSelectionOutcome[] = [];
+
+	incoming.forEach((file, index) => {
+		const name = uploadSourcePath(file);
+		const identity = fileIdentity(file);
+		if (seen.has(identity)) {
+			outcomes.push({
+				index,
+				name,
+				status: "rejected",
+				detail: "Duplicate selection.",
+			});
+			return;
+		}
+		seen.add(identity);
+		if (file.size > limits.maxFileBytes) {
+			outcomes.push({
+				index,
+				name,
+				status: "rejected",
+				detail: `File exceeds the ${formatBytes(limits.maxFileBytes)} client admission limit.`,
+			});
+			return;
+		}
+		candidates.push({ file, index });
+	});
+
+	const proposed = [...current, ...candidates.map(({ file }) => file)];
+	const totalBytes = proposed.reduce((sum, file) => sum + file.size, 0);
+	const selectionProblem =
+		proposed.length > limits.maxFileCount
+			? `Selection exceeds the ${limits.maxFileCount}-file client admission limit.`
+			: totalBytes > limits.maxTotalBytes
+				? `Selection exceeds the ${formatBytes(limits.maxTotalBytes)} aggregate client admission limit.`
+				: null;
+
+	if (selectionProblem) {
+		for (const candidate of candidates) {
+			outcomes.push({
+				index: candidate.index,
+				name: uploadSourcePath(candidate.file),
+				status: "rejected",
+				detail: selectionProblem,
+			});
+		}
+		return {
+			files: [...current],
+			outcomes: outcomes.sort((left, right) => left.index - right.index),
+			totalBytes: current.reduce((sum, file) => sum + file.size, 0),
+		};
+	}
+
+	for (const candidate of candidates) {
+		outcomes.push({
+			index: candidate.index,
+			name: uploadSourcePath(candidate.file),
+			status: "ready",
+			detail: `${formatBytes(candidate.file.size)} admitted; server limits remain authoritative.`,
+		});
+	}
+	return {
+		files: proposed,
+		outcomes: outcomes.sort((left, right) => left.index - right.index),
+		totalBytes,
+	};
+}
+
+export type BoundedTaskOutcome<T> =
+	| { index: number; status: "completed"; value: T }
+	| { index: number; status: "failed" | "cancelled"; error: string };
+
+export async function runBoundedTasks<Input, Output>(input: {
+	items: readonly Input[];
+	concurrency?: number;
+	signal?: AbortSignal;
+	run(item: Input, index: number, signal?: AbortSignal): Promise<Output>;
+}): Promise<Array<BoundedTaskOutcome<Output>>> {
+	const outcomes = new Array<BoundedTaskOutcome<Output>>(input.items.length);
+	const concurrency = Math.max(
+		1,
+		Math.min(
+			Math.floor(input.concurrency ?? CHAT_UPLOAD_LIMITS.concurrency),
+			input.items.length || 1,
+		),
+	);
+	let cursor = 0;
+	const workers = Array.from({ length: concurrency }, async () => {
+		while (cursor < input.items.length) {
+			const index = cursor++;
+			if (input.signal?.aborted) {
+				outcomes[index] = {
+					index,
+					status: "cancelled",
+					error: "Upload cancelled.",
+				};
+				continue;
+			}
+			try {
+				const value = await input.run(
+					input.items[index] as Input,
+					index,
+					input.signal,
+				);
+				// A task that resolved may already have produced a side effect. Preserve it
+				// as completed even if a sibling aborts the remaining queue immediately after.
+				outcomes[index] = { index, status: "completed", value };
+			} catch (error) {
+				outcomes[index] = {
+					index,
+					status: input.signal?.aborted ? "cancelled" : "failed",
+					error: error instanceof Error ? error.message : String(error),
+				};
+			}
+		}
+	});
+	await Promise.all(workers);
+	return outcomes;
+}
+
+export const uploadSourcePath = (file: File) =>
+	file.webkitRelativePath?.trim() || file.name;
+
+function fileIdentity(file: File) {
+	return `${uploadSourcePath(file)}:${file.size}:${file.lastModified}`;
+}
+
+function formatBytes(value: number) {
+	if (value >= 1024 * 1024) return `${Math.round(value / (1024 * 1024))} MB`;
+	if (value >= 1024) return `${Math.round(value / 1024)} KB`;
+	return `${value} B`;
+}
diff --git a/tests/playwright/accessibility-upload-guardrails.spec.ts b/tests/playwright/accessibility-upload-guardrails.spec.ts
new file mode 100644
index 000000000..3a2994451
--- /dev/null
+++ b/tests/playwright/accessibility-upload-guardrails.spec.ts
@@ -0,0 +1,154 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, type Page, test } from "@playwright/test";
+
+async function createUploadWorkspace(page: Page) {
+	await page.goto(process.env.PLAYWRIGHT_BASE_URL ?? "http://localhost:3210/");
+	return page.evaluate(async () => {
+		const response = await fetch("/api/projects/create", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				project: { name: `Upload guardrail ${Date.now()}` },
+				thread: { title: "Upload guardrail" },
+				model: { modelUri: "llm://openrouter/deepseek/deepseek-v4-flash" },
+				workspace: { resolve: true },
+			}),
+		});
+		if (!response.ok) throw new Error(await response.text());
+		return response.json() as Promise<{
+			project: { id: string };
+			thread: { id: string };
+		}>;
+	});
+}
+
+test("app configuration traps focus, supports roving tabs, and protects dirty dismissal", async ({
+	page,
+}) => {
+	test.setTimeout(90_000);
+	await page.route("**/api/app-config", (route) =>
+		route.fulfill({
+			status: 200,
+			contentType: "application/json",
+			body: JSON.stringify({
+				config: {
+					version: 1,
+					storage: { targets: [], appTargetId: "", defaultTargetId: "" },
+					vectors: { targets: [], defaultTargetId: "" },
+					llms: { targets: [], defaultTargetId: "" },
+					observability: { targets: [], defaultTargetIds: [] },
+				},
+				paths: {
+					configPath: "/tmp/app.json",
+					secretsPath: "/tmp/secrets",
+					source: "test",
+				},
+				registry: {
+					storage: [],
+					vector: [],
+					llm: [],
+					observability: [],
+					compute: [],
+				},
+				health: [],
+				restartRequired: false,
+			}),
+		}),
+	);
+
+	await page.goto(process.env.PLAYWRIGHT_BASE_URL ?? "http://localhost:3210/", {
+		waitUntil: "domcontentloaded",
+	});
+	const opener = page.getByRole("button", { name: "Settings", exact: true });
+	await expect(opener).toBeVisible();
+	await expect
+		.poll(() =>
+			opener.evaluate((element) =>
+				Object.getOwnPropertyNames(element).some((name) =>
+					name.startsWith("__reactProps"),
+				),
+			),
+		)
+		.toBe(true);
+	await opener.click();
+
+	const dialog = page.getByRole("dialog", { name: "App Configuration" });
+	await expect(dialog).toBeVisible();
+	const closeButton = page.getByRole("button", {
+		name: "Close app configuration",
+	});
+	await expect(closeButton).toBeFocused();
+	await dialog.getByRole("button", { name: "Save" }).focus();
+	await page.keyboard.press("Tab");
+	await expect(closeButton).toBeFocused();
+
+	const dataTab = page.getByRole("tab", { name: /Data/ });
+	await dataTab.focus();
+	await page.keyboard.press("ArrowRight");
+	await expect(page.getByRole("tab", { name: /Vector/ })).toHaveAttribute(
+		"aria-selected",
+		"true",
+	);
+
+	await page.getByPlaceholder(/Paste llm:\/\//).fill("llm://example/model");
+	await page.keyboard.press("Escape");
+	await expect(dialog).toBeVisible();
+	await expect(dialog.getByRole("alert")).toContainText("unsaved changes");
+
+	await page.getByRole("button", { name: "Discard changes" }).click();
+	await expect(dialog).toBeHidden();
+	await expect(opener).toBeFocused();
+});
+
+test("an oversized folder is rejected in the rendered composer before upload work", async ({
+	page,
+}) => {
+	test.setTimeout(90_000);
+	const setup = await createUploadWorkspace(page);
+	let uploadRequests = 0;
+	await page.route("**/api/projects/*/uploads**", (route) => {
+		uploadRequests += 1;
+		return route.abort();
+	});
+
+	const baseUrl = process.env.PLAYWRIGHT_BASE_URL ?? "http://localhost:3210";
+	await page.goto(
+		`${baseUrl}/projects/${encodeURIComponent(setup.project.id)}?thread=${encodeURIComponent(setup.thread.id)}`,
+		{
+			waitUntil: "domcontentloaded",
+		},
+	);
+	await expect(
+		page.getByRole("button", { name: "Attach folder" }),
+	).toBeVisible();
+
+	const fixtureDirectory = await mkdtemp(
+		join(tmpdir(), "exploit-hunter-upload-"),
+	);
+	const nestedDirectory = join(fixtureDirectory, "oversized-folder");
+	try {
+		await mkdir(nestedDirectory);
+		await Promise.all(
+			Array.from({ length: 201 }, (_, index) =>
+				writeFile(
+					join(nestedDirectory, `file-${String(index).padStart(3, "0")}.txt`),
+					"x",
+				),
+			),
+		);
+		await page
+			.locator('input[type="file"][webkitdirectory]')
+			.setInputFiles(fixtureDirectory);
+
+		await expect(page.getByText(/201 rejected before upload/)).toBeVisible();
+		await expect(
+			page.getByLabel("Upload admission outcomes").getByRole("listitem"),
+		).toHaveCount(201);
+		await expect(page.getByLabel("Attached files")).toHaveCount(0);
+		expect(uploadRequests).toBe(0);
+	} finally {
+		await rm(fixtureDirectory, { recursive: true, force: true });
+	}
+});
diff --git a/tests/unit/upload-admission.test.ts b/tests/unit/upload-admission.test.ts
new file mode 100644
index 000000000..7e585f37f
--- /dev/null
+++ b/tests/unit/upload-admission.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	admitUploadSelection,
+	runBoundedTasks,
+} from "../../src/components/uploads/uploadAdmission";
+
+const file = (name: string, size: number, lastModified = 1) =>
+	new File([new Uint8Array(size)], name, { lastModified });
+
+describe("browser upload admission", () => {
+	it("rejects an oversized folder selection before admitting any new work", () => {
+		const selected = [file("existing.txt", 2)];
+		const result = admitUploadSelection(
+			selected,
+			[file("one.txt", 4), file("two.txt", 4)],
+			{
+				maxFileCount: 2,
+				maxTotalBytes: 20,
+				maxFileBytes: 10,
+				concurrency: 2,
+			},
+		);
+
+		expect(result.files).toEqual(selected);
+		expect(result.outcomes).toEqual([
+			{
+				index: 0,
+				name: "one.txt",
+				status: "rejected",
+				detail: "Selection exceeds the 2-file client admission limit.",
+			},
+			{
+				index: 1,
+				name: "two.txt",
+				status: "rejected",
+				detail: "Selection exceeds the 2-file client admission limit.",
+			},
+		]);
+	});
+
+	it("reports per-file and aggregate byte admission failures without reading file bodies", () => {
+		const oversized = file("oversized.bin", 11);
+		let reads = 0;
+		Object.defineProperty(oversized, "arrayBuffer", {
+			value: async () => {
+				reads += 1;
+				return new ArrayBuffer(11);
+			},
+		});
+		const result = admitUploadSelection(
+			[],
+			[oversized, file("one.bin", 8), file("two.bin", 8)],
+			{
+				maxFileCount: 5,
+				maxTotalBytes: 10,
+				maxFileBytes: 10,
+				concurrency: 2,
+			},
+		);
+
+		expect(reads).toBe(0);
+		expect(result.files).toEqual([]);
+		expect(result.outcomes.map((outcome) => outcome.detail)).toEqual([
+			"File exceeds the 10 B client admission limit.",
+			"Selection exceeds the 10 B aggregate client admission limit.",
+			"Selection exceeds the 10 B aggregate client admission limit.",
+		]);
+	});
+
+	it("bounds parallel work, preserves input order, and records cancellation", async () => {
+		const controller = new AbortController();
+		let active = 0;
+		let peak = 0;
+		const outcomes = await runBoundedTasks({
+			items: ["one", "two", "three", "four"],
+			concurrency: 2,
+			signal: controller.signal,
+			run: async (item) => {
+				active += 1;
+				peak = Math.max(peak, active);
+				await Promise.resolve();
+				active -= 1;
+				if (item === "two") controller.abort();
+				return item.toUpperCase();
+			},
+		});
+
+		expect(peak).toBe(2);
+		expect(outcomes.map((outcome) => [outcome.index, outcome.status])).toEqual([
+			[0, "completed"],
+			[1, "completed"],
+			[2, "cancelled"],
+			[3, "cancelled"],
+		]);
+	});
+});