diff --git a/docs/features/local-upload.md b/docs/features/local-upload.md
new file mode 100644
index 00000000..fc3f4376
--- /dev/null
+++ b/docs/features/local-upload.md
@@ -0,0 +1,83 @@
+# 本地音视频文件上传与历史管理 (Local Media Upload)
+
+## 功能概述
+
+本地音视频文件上传功能允许用户直接在网页端上传本地音视频文件进行 ASR 转录与 AI 处理，并在个人历史页面查看任务进度、保留期与管理公开分享状态。
+
+---
+
+## 页面操作流程
+
+### 1. 提交上传 (`/add_task_by_web`)
+
+1. **模式切换**：在首页表单顶部切换“音视频链接”与“本地文件上传”标签页。
+2. **鉴权与可用性探测**：
+   - 上传功能需要 Bearer 访问令牌认证；在高级设置中填写访问令牌。
+   - 填写令牌后，页面会自动请求 `GET /api/uploads/capabilities` 探测服务端能力开关与配置限制。
+   - 上传功能启用的必要前提为：服务端配置开关开启、具备正有限数值的配额限制（如 `max_file_mib > 0`）且后台 worker 就绪。若三者中任一不满足（或未授权/网络异常），前端必须明确可见禁用提示并禁用提交按钮，不承诺可上传。
+3. **选择文件**：
+   - 点击文件选择区域或将音视频文件拖拽至虚线框内。仅支持单文件选择，不支持批量上传。
+   - 若文件体积超过服务端配置的 `max_file_mib`，页面将进行提示并拦截提交。
+4. **元数据配置**：
+   - **自定义标题**：可选，最多不超过 200 个字符。若未填写则传 `null`。
+   - **来源网址**：可选，仅作溯源展示，不超过 2048 字节。必须为 `http://` 或 `https://` 协议，不得包含用户名/密码（userinfo）。
+   - **保留期限**：提供“保留 30 天”（默认）与“永久保留”。每次重新选择文件或变更意图时，保留期均重置为默认 30 天。
+   - **处理选项**：包括 AI 文本校对（calibrate）、内容总结（summarize）、提取章节（chapters）、说话人识别（infer_speaker_names）等开关。
+5. **提交与传输**：
+   - 点击“提交上传”按钮。
+   - 前端生成单次意图唯一的 `Idempotency-Key`（格式：`<epoch_ms>-<UUID>`）与 `X-Upload-Metadata` 头（base64url UTF-8 编码 JSON，恰包含 6 个字段：`filename`, `byte_size`, `title`, `source_url`, `retention`, `processing_options`）。
+   - 以 `application/octet-stream` 流式发送原始文件字节。
+   - 具备双击防重保护；若因网络异常导致结果未知，保持原 `Idempotency-Key`，通过 `GET /api/uploads/by-idempotency-key/{key}` 进行回执查询，不重复发送文件字节。
+
+---
+
+## 任务生命周期与阶段状态
+
+| 阶段 | 状态码 / 标识 | 说明 |
+|------|-------------|------|
+| 传输接收 | `receiving` | 服务端正在流式接收上传文件字节 |
+| 任务受理 | `accepted` | 文件完整写入临时存储，已生成回执（包含 `upload_id`, `state`, `task_id`, `view_token` 等），后台转录任务已入队 |
+| 后台排队与处理 | `pending` / `processing` | 后台 worker 正在执行 ASR 识别、校对与总结处理 |
+| 处理完成 | `success` | 任务处理成功，可通过 `view_token` 打开公开阅读页面查看转录正文；临时媒体输入文件在转录完成后及时清理 |
+| 处理失败 | `failed` | 任务处理失败，可查看失败原因 |
+
+---
+
+## 数据保留期 (Retention) 与生命周期策略
+
+- **临时媒体清理**：上传的原始音视频媒体仅作为临时转录输入，转录任务处理完成后即时进行清理释放空间。
+- **计算起点**：保留期从根任务首次到达终态（`success` 或 `failed`）起算，派生或重处理任务不延长生命周期。
+- **30 天保留 (`30d`)**：默认选项，转录正文在 30 天内映射受保护阅读，到期后由既有系统的 cleanup 规则统一回收。
+- **永久保留 (`never`)**：需用户在提交前显式选择，转录正文长期保持映射受保护阅读。
+- **停止公开分享说明**：用户在历史记录中停止分享将立即撤销公开阅读访问权限（公开链接访问返回 404），但不等同于立即从磁盘物理擦除转录正文；系统不提供任意“手动删除”功能。
+
+---
+
+## 本人历史与停止公开分享 (`/static/history.html`)
+
+1. **历史查询与过滤**：
+   - 输入访问令牌后查询个人历史记录。
+   - 顶部过滤栏提供“来源”下拉菜单（支持“音视频链接”与“本地上传”两种模式切换），过滤条件同步至 URL 参数。
+2. **上传任务状态展示**：
+   - 列表展示任务标题、请求时间、保留期标识（如“30天保留”或“永久保留”）。
+   - 展示公开分享状态徽章（“分享中”或“已停止分享”）。
+   - 任务完成后，通过 `upload_view_token` 点击条目可打开公开阅读页。
+3. **停止公开分享 (Owner 操作)**：
+   - 拥有者在历史条目中点击“停止分享”按钮。
+   - 弹出确认对话框提示：“确认关闭公开分享？关闭后将停止后续阅读、导出与重新处理，但不立即擦除正文，也不取消在途处理与通知。”
+   - 确认后前端发送 `DELETE /api/uploads/{upload_id}/share` 请求。
+   - 停止分享后，公开阅读链接即刻失效（访问返回 404），历史记录中状态就地更新为“已停止分享”。
+   - 阅读页面展示正文及现有重处理能力，不包含停止分享按钮。
+
+---
+
+## 限制与系统配置
+
+| 配置项 / 约束 | 默认值 / 限制 | 说明 |
+|--------------|--------------|------|
+| 服务开关 | 默认禁用 (`false`) | 由服务端配置或环境变量 `VTA_UPLOADS_ENABLED="true"` 控制；同时需正有限配额 limits 与 worker 就绪 |
+| 单文件体积限制 | 由服务端 `limits.max_file_mib` 决定 | 超过限制的文件将在前端被拦截 |
+| 文件名长度 | 最多 255 字节 | UTF-8 编码 |
+| 标题长度 | 最多 200 字符 | 可选 |
+| 来源网址长度 | 最多 2048 字节 | 可选，必须为 http(s) 且无 userinfo |
+| 传输格式 | 单文件 raw binary | `application/octet-stream`，不使用 multipart 格式 |
diff --git a/e2e/tests/local-upload.spec.ts b/e2e/tests/local-upload.spec.ts
new file mode 100644
index 00000000..bce850f6
--- /dev/null
+++ b/e2e/tests/local-upload.spec.ts
@@ -0,0 +1,491 @@
+import { createHash } from 'node:crypto';
+import { expect, test, type Page } from '@playwright/test';
+import { resetBackend } from '../reset-backend';
+
+const baseURL = process.env.VTA_BROWSER_PORT
+  ? `http://127.0.0.1:${process.env.VTA_BROWSER_PORT}`
+  : '';
+const browserErrors = new WeakMap<Page, string[]>();
+const expectedHttpErrors = new WeakMap<Page, { method: string; path: string; status: number; observed: boolean; consoleSeen: boolean }[]>();
+
+function expectHttpError(page: Page, method: string, path: string, status: number): void {
+  expectedHttpErrors.get(page)?.push({ method, path, status, observed: false, consoleSeen: false });
+}
+
+function observeBrowser(page: Page): void {
+  const errors: string[] = [];
+  browserErrors.set(page, errors);
+  expectedHttpErrors.set(page, []);
+  page.on('console', (message) => {
+    if (message.type() === 'error') {
+      const status = Number(message.text().match(/status of (\d+)/)?.[1]), location = message.location().url, path = location ? new URL(location).pathname : '';
+      const match = (expectedHttpErrors.get(page) ?? []).find((item) => !item.consoleSeen && item.path === path && item.status === status);
+      if (match) match.consoleSeen = true;
+      else errors.push(`console: ${message.text()}`);
+    }
+  });
+  page.on('pageerror', (error) => errors.push(`pageerror: ${error.message}`));
+  page.on('requestfailed', (request) => {
+    errors.push(`request failed: ${request.method()} ${request.url()} (${request.failure()?.errorText})`);
+  });
+  page.on('response', (response) => {
+    if (response.status() >= 400) {
+      const request = response.request();
+      const path = new URL(response.url()).pathname;
+      const expected = expectedHttpErrors.get(page) ?? [];
+      const match = expected.findIndex((item) =>
+        !item.observed && item.method === request.method() && item.path === path && item.status === response.status());
+      if (match !== -1) {
+        expected[match].observed = true;
+      } else {
+        errors.push(`HTTP ${response.status()}: ${request.method()} ${response.url()}`);
+      }
+    }
+  });
+}
+
+test.beforeEach(async ({ page, request }) => {
+  if (!baseURL) throw new Error('VTA_BROWSER_PORT must be set by the browser test runner');
+  observeBrowser(page);
+  page.context().on('page', observeBrowser);
+  await resetBackend(request, baseURL);
+});
+
+test.afterEach(async ({ page }) => {
+  for (const observedPage of page.context().pages()) {
+    expect(expectedHttpErrors.get(observedPage)?.every((item) => item.observed)).toBe(true);
+    expect(browserErrors.get(observedPage) ?? []).toEqual([]);
+  }
+});
+
+test('upload page selects local media, submits raw bytes with metadata headers, and captures server receipt', async ({ page, request }) => {
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+
+  // Switch to upload tab
+  await page.locator('#mode-tab-upload').click();
+  await expect(page.locator('#upload-mode-panel')).toBeVisible();
+  await expect(page.locator('#url-mode-panel')).toBeHidden();
+
+  // Fill in optional title and source url
+  await page.locator('#upload-title').fill('浏览器测试上传标题');
+  await page.locator('#upload-source-url').fill('https://example.com/source-podcast');
+
+  // Set file payload
+  const fileBytes = Buffer.from('真实浏览器音视频字节内容-SHA验证', 'utf-8');
+  const expectedSha256 = createHash('sha256').update(fileBytes).digest('hex');
+
+  const fileInput = page.locator('#upload-file-input');
+  await fileInput.setInputFiles({
+    name: '测试音频.mp3',
+    mimeType: 'audio/mp3',
+    buffer: fileBytes,
+  });
+
+  // Verify file info is displayed
+  await expect(page.locator('#upload-file-info')).toBeVisible();
+  await expect(page.locator('#upload-file-name')).toHaveText('测试音频.mp3');
+  await expect(page.locator('#submit-btn')).toBeEnabled();
+
+  // Intercept actual HTTP POST request from browser
+  const submitted = page.waitForRequest((req) =>
+    req.url().endsWith('/api/uploads') && req.method() === 'POST');
+
+  await page.locator('#submit-btn').click();
+  const req = await submitted;
+
+  // Assert headers
+  const headers = req.headers();
+  expect(headers['authorization']).toBe('Bearer browser-fixture-token');
+  expect(headers['content-type']).toBe('application/octet-stream');
+  expect(headers['idempotency-key']).toMatch(/^\d+-[0-9a-fA-F-]+$/);
+
+  const rawMetadata = headers['x-upload-metadata'];
+  expect(rawMetadata).toBeTruthy();
+  const padded = rawMetadata + '='.repeat((4 - (rawMetadata.length % 4)) % 4);
+  const metadataJson = JSON.parse(Buffer.from(padded, 'base64url').toString('utf-8'));
+
+  expect(metadataJson).toEqual({
+    filename: '测试音频.mp3',
+    byte_size: fileBytes.length,
+    title: '浏览器测试上传标题',
+    source_url: 'https://example.com/source-podcast',
+    retention: '30d',
+    processing_options: {
+      calibrate: true,
+      summarize: true,
+      infer_speaker_names: false,
+      chapters: true,
+    },
+  });
+
+  // Assert actual raw body bytes captured by browser server fixture
+  const lastUploadRes = await request.get(`${baseURL}/__e2e__/last-upload`);
+  expect(lastUploadRes.status()).toBe(200);
+  const lastUpload = await lastUploadRes.json();
+  expect(lastUpload.actual_byte_length).toBe(fileBytes.length);
+  expect(lastUpload.raw_bytes_sha256).toBe(expectedSha256);
+  expect(lastUpload.filename).toBe('测试音频.mp3');
+  expect(lastUpload.byte_size).toBe(fileBytes.length);
+
+  // Assert UI feedback shows accepted receipt
+  await expect(page.locator('#status-content')).toContainText('文件上传成功，任务已受理！');
+  await expect(page.locator('#status-content')).toContainText('上传ID:');
+  await expect(page.locator('#status-content a[href^="/view/"]')).toBeVisible();
+});
+
+test('upload page prevents double submission on duplicate clicks', async ({ page }) => {
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+
+  await page.locator('#mode-tab-upload').click();
+
+  const fileBytes = Buffer.from('单次意图防重测试', 'utf-8');
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '防重测试.mp3',
+    mimeType: 'audio/mp3',
+    buffer: fileBytes,
+  });
+
+  let postCount = 0;
+  page.on('request', (req) => {
+    if (req.url().endsWith('/api/uploads') && req.method() === 'POST') {
+      postCount += 1;
+    }
+  });
+
+  const submitBtn = page.locator('#submit-btn');
+  // Rapid double click
+  await Promise.all([
+    submitBtn.click({ clickCount: 2 }),
+  ]);
+
+  await expect(page.locator('#status-content')).toContainText('文件上传成功，任务已受理！');
+  expect(postCount).toBe(1);
+});
+
+test('history page filters upload tasks, displays retention and share state, and allows owner to stop sharing', async ({ page, request }) => {
+  // First upload a file to have an active upload record
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+  await page.locator('#mode-tab-upload').click();
+  await page.locator('#upload-title').fill('本人上传历史项目');
+
+  const fileBytes = Buffer.from('本人历史与停止分享测试', 'utf-8');
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '本人分享.mp4',
+    mimeType: 'video/mp4',
+    buffer: fileBytes,
+  });
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('文件上传成功，任务已受理！');
+
+  // Now open history page
+  await page.goto('/static/history.html');
+  await page.locator('#apiKeyInput').fill('browser-fixture-token');
+  await page.locator('#historyQueryBtn').click();
+
+  // Wait for initial load to finish before changing filter to avoid aborting in-flight requests
+  await expect(page.locator('.task-row[data-vt="browser-fixture-view"]')).toBeVisible();
+
+  // Switch source filter to local upload
+  await page.locator('#filterSource').selectOption('upload');
+
+  // Wait for list to render upload item
+  const row = page.locator('.task-row').first();
+  await expect(row.locator('.task-title')).toContainText('本人上传历史项目');
+  await expect(row.locator('.task-author')).toContainText('30天保留');
+  await expect(row.locator('.task-author')).toContainText('分享中');
+
+  // Capture stop share button and token before revoking
+  const stopShareBtn = row.locator('.btn-stop-share');
+  await expect(stopShareBtn).toBeVisible();
+  const token = await row.getAttribute('data-vt');
+  expect(token).toBeTruthy();
+
+  // Set up dialog confirmation
+  page.once('dialog', async (dialog) => {
+    expect(dialog.message()).toContain('确认关闭公开分享？关闭后将停止后续阅读、导出与重新处理');
+    await dialog.accept();
+  });
+
+  // Click stop share button
+  await stopShareBtn.click();
+
+  // Assert status and updated UI
+  await expect(page.locator('#authStatus')).toContainText('已停止公开分享');
+  await expect(row.locator('.task-author')).toContainText('已停止分享');
+  await expect(row.locator('.btn-stop-share')).toHaveCount(0);
+
+  // Assert backend revoked state directly via API
+  const viewRes = await request.get(`${baseURL}/view/${token}`);
+  expect(viewRes.status()).toBe(404);
+});
+
+test('mobile viewport, keyboard selection, and DOM drop submit raw bytes and all-false options', async ({ page, request }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+  await page.locator('#mode-tab-upload').click();
+
+  const [fileChooser] = await Promise.all([
+    page.waitForEvent('filechooser'),
+    page.locator('#upload-drop-zone').press('Enter'),
+  ]);
+  await fileChooser.setFiles({ name: '初始.mp3', mimeType: 'audio/mp3', buffer: Buffer.from('初始', 'utf-8') });
+  await expect(page.locator('#upload-file-name')).toHaveText('初始.mp3');
+
+  const fileBytes = Buffer.from('小屏拖拽上传测试内容', 'utf-8');
+  const expectedSha256 = createHash('sha256').update(fileBytes).digest('hex');
+  await page.evaluate(({ name, content }) => {
+    const dt = new DataTransfer();
+    dt.items.add(new File([new Uint8Array(content)], name, { type: 'audio/mp3' }));
+    document.getElementById('upload-drop-zone')!.dispatchEvent(new DragEvent('drop', { bubbles: true, cancelable: true, dataTransfer: dt }));
+  }, { name: '小屏录音.mp3', content: Array.from(fileBytes) });
+  await expect(page.locator('#upload-file-name')).toHaveText('小屏录音.mp3');
+
+  await page.locator('#transcription-options-toggle').click();
+  await page.locator('#calibrate-option').uncheck();
+  await page.locator('#summarize-option').uncheck();
+
+  await page.locator('#upload-title').fill('移动端小屏标题');
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('文件上传成功，任务已受理！');
+
+  const lastUploadRes = await request.get(`${baseURL}/__e2e__/last-upload`);
+  expect(lastUploadRes.status()).toBe(200);
+  const lastUpload = await lastUploadRes.json();
+  expect(lastUpload.actual_byte_length).toBe(fileBytes.length);
+  expect(lastUpload.raw_bytes_sha256).toBe(expectedSha256);
+  expect(lastUpload.filename).toBe('小屏录音.mp3');
+  expect(lastUpload.title).toBe('移动端小屏标题');
+  expect(lastUpload.processing_options).toEqual({
+    calibrate: false,
+    summarize: false,
+    infer_speaker_names: false,
+    chapters: false,
+  });
+});
+
+test('post 500 followed by get 404, receiving, and failed preserves key and prevents second post', async ({ page }) => {
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+  await page.locator('#mode-tab-upload').click();
+
+  let postCount = 0;
+  let postKey = '';
+  const getKeys: string[] = [];
+  let getResponseState = '404';
+
+  await page.route('**/api/uploads', async (route) => {
+    if (route.request().method() === 'POST') {
+      postCount++;
+      postKey = route.request().headers()['idempotency-key'];
+      expectHttpError(page, 'POST', '/api/uploads', 500);
+      await route.fulfill({ status: 500, body: JSON.stringify({ detail: 'server error' }) });
+    } else {
+      await route.continue();
+    }
+  });
+
+  await page.route('**/api/uploads/by-idempotency-key/*', async (route) => {
+    const request = route.request();
+    const key = new URL(request.url()).pathname.split('/by-idempotency-key/')[1];
+    getKeys.push(decodeURIComponent(key));
+    expect(decodeURIComponent(key)).toBe(postKey);
+    if (getResponseState === '404') {
+      expectHttpError(page, 'GET', new URL(request.url()).pathname, 404);
+      await route.fulfill({ status: 404, body: JSON.stringify({ detail: 'not found' }) });
+    } else {
+      await route.fulfill({
+        status: 200,
+        body: JSON.stringify({
+          upload_id: 'up-123',
+          state: getResponseState,
+          task_id: null,
+          error_code: getResponseState === 'failed' ? 'transcode_err' : null,
+        }),
+      });
+    }
+  });
+
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '待核实.mp3',
+    mimeType: 'audio/mp3',
+    buffer: Buffer.from('500内容', 'utf-8'),
+  });
+
+  // 1st click: POST 500 -> initial GET 404 -> status pending
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('上传状态待核实');
+  expect(postCount).toBe(1);
+
+  await page.locator('#submit-btn').click();
+  expect(getKeys).toHaveLength(2);
+
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('上传状态待核实');
+  expect(postCount).toBe(1);
+  expect(getKeys).toHaveLength(3);
+
+  getResponseState = 'receiving';
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('文件已接收，等待排队受理');
+  await expect(page.locator('#status-content')).not.toContainText('文件上传成功，任务已受理！');
+  await expect(page.locator('#history-list .history-item')).toHaveCount(0);
+
+  // 3rd click: GET only with same key -> returns failed, no local history
+  getResponseState = 'failed';
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('上传处理失败');
+  await expect(page.locator('#status-content')).toContainText('transcode_err');
+  await expect(page.locator('#history-list .history-item')).toHaveCount(0);
+  expect(postCount).toBe(1);
+  expect(getKeys).toEqual(Array(5).fill(postKey));
+});
+
+test('parameter change with colon variations produces distinct idempotency keys', async ({ page }) => {
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+  await page.locator('#mode-tab-upload').click();
+
+  const fileBytes = Buffer.from('冒号碰撞原始文件字节', 'utf-8');
+  const expectedSha256 = createHash('sha256').update(fileBytes).digest('hex');
+  const uploads: { key: string; metadata: any; bodySha256: string; headers: Record<string, string> }[] = [];
+  const getKeys: string[] = [];
+  await page.route('**/api/uploads', async (route) => {
+    if (route.request().method() === 'POST') {
+      const request = route.request();
+      const headers = request.headers();
+      const raw = headers['x-upload-metadata'];
+      const body = request.postDataBuffer();
+      expect(body).not.toBeNull();
+      uploads.push({
+        key: headers['idempotency-key'],
+        metadata: JSON.parse(Buffer.from(raw, 'base64url').toString('utf-8')),
+        bodySha256: createHash('sha256').update(body!).digest('hex'),
+        headers,
+      });
+      if (uploads.length === 1) {
+        expectHttpError(page, 'POST', '/api/uploads', 500);
+        await route.fulfill({ status: 500, body: JSON.stringify({ detail: 'server error' }) });
+      } else {
+        await route.fulfill({
+          status: 202,
+          body: JSON.stringify({ upload_id: 'up-collision', state: 'receiving', task_id: null, error_code: null }),
+        });
+      }
+    } else {
+      await route.continue();
+    }
+  });
+  await page.route('**/api/uploads/by-idempotency-key/*', async (route) => {
+    const request = route.request();
+    const path = new URL(request.url()).pathname;
+    getKeys.push(decodeURIComponent(path.split('/by-idempotency-key/')[1]));
+    expectHttpError(page, 'GET', path, 404);
+    await route.fulfill({ status: 404, body: JSON.stringify({ detail: 'not found' }) });
+  });
+
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '冒号测试.mp3',
+    mimeType: 'audio/mp3',
+    buffer: fileBytes,
+  });
+
+  await page.locator('#upload-title').fill('T');
+  await page.locator('#upload-source-url').fill('https://example.com/path:https://example.org');
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText('上传状态待核实');
+  expect(uploads).toHaveLength(1);
+
+  await page.locator('#upload-title').fill('T:https://example.com/path');
+  await page.locator('#upload-source-url').fill('https://example.org');
+  await page.locator('#submit-btn').click();
+  await expect(page.locator('#status-content')).toContainText(/文件已接收，等待排队受理|上传失败/);
+
+  expect(uploads).toHaveLength(2);
+  expect(uploads[1].key).not.toBe(uploads[0].key);
+  expect(uploads.map((upload) => upload.bodySha256)).toEqual([expectedSha256, expectedSha256]);
+  expect(uploads.map((upload) => [upload.headers.authorization, upload.headers['content-type']])).toEqual([['Bearer browser-fixture-token', 'application/octet-stream'], ['Bearer browser-fixture-token', 'application/octet-stream']]);
+  const processingOptions = { calibrate: true, summarize: true, infer_speaker_names: false, chapters: true };
+  const expectedMetadata = [
+    { filename: '冒号测试.mp3', byte_size: fileBytes.length, title: 'T', source_url: 'https://example.com/path:https://example.org', retention: '30d', processing_options: processingOptions },
+    { filename: '冒号测试.mp3', byte_size: fileBytes.length, title: 'T:https://example.com/path', source_url: 'https://example.org', retention: '30d', processing_options: processingOptions },
+  ];
+  expect(uploads.map((upload) => upload.metadata)).toEqual(expectedMetadata);
+  expect(getKeys).toEqual([uploads[0].key]);
+  await expect(page.locator('#status-content')).toContainText('文件已接收，等待排队受理');
+  await expect(page.locator('#history-list .history-item')).toHaveCount(0);
+});
+
+test('upload in flight: selecting replacement file binds original snapshot to upload and preserves replacement file', async ({ page, request }) => {
+  await page.goto('/add_task_by_web');
+  await page.locator('#advanced-toggle').click();
+  await page.locator('#bearer-token').fill('browser-fixture-token');
+  await page.locator('#mode-tab-upload').click();
+
+  const file1Bytes = Buffer.from('第一份音频内容-原意图', 'utf-8');
+  const file1Sha256 = createHash('sha256').update(file1Bytes).digest('hex');
+
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '原文件.mp3',
+    mimeType: 'audio/mp3',
+    buffer: file1Bytes,
+  });
+
+  // Pause the POST request via page.route
+  let continueRoute: () => void = () => {};
+  const routePromise = new Promise<void>((resolve) => {
+    continueRoute = resolve;
+  });
+
+  await page.route('**/api/uploads', async (route) => {
+    if (route.request().method() === 'POST') {
+      await routePromise;
+      await route.continue();
+    } else {
+      await route.continue();
+    }
+  });
+
+  // Trigger submit
+  await page.locator('#submit-btn').click();
+
+  // While in flight, select a second file
+  const file2Bytes = Buffer.from('第二份音频内容-新文件', 'utf-8');
+  await page.locator('#upload-file-input').setInputFiles({
+    name: '替换新文件.mp4',
+    mimeType: 'video/mp4',
+    buffer: file2Bytes,
+  });
+
+  // Now resume the original POST
+  continueRoute();
+
+  // Wait for submission to complete
+  await expect(page.locator('#status-content')).toContainText('文件上传成功，任务已受理！');
+
+  // Assert backend received file1 snapshot
+  const lastUploadRes = await request.get(`${baseURL}/__e2e__/last-upload`);
+  expect(lastUploadRes.status()).toBe(200);
+  const lastUpload = await lastUploadRes.json();
+  expect(lastUpload.filename).toBe('原文件.mp3');
+  expect(lastUpload.raw_bytes_sha256).toBe(file1Sha256);
+
+  // Assert replacement file is still selected and visible in UI
+  const fileInfo = page.locator('#upload-file-info');
+  await expect(fileInfo).toBeVisible();
+  await expect(page.locator('#upload-file-name')).toHaveText('替换新文件.mp4');
+
+  // Assert local task history has file1 title
+  const historyItem = page.locator('#history-list .history-item').first();
+  await expect(historyItem).toBeVisible();
+  await expect(historyItem.locator('.history-title')).toHaveText('原文件.mp3');
+});
diff --git a/src/video_transcript_api/api/routes/audit.py b/src/video_transcript_api/api/routes/audit.py
index ffb66db3..95eaa1b1 100644
--- a/src/video_transcript_api/api/routes/audit.py
+++ b/src/video_transcript_api/api/routes/audit.py
@@ -331,6 +331,7 @@ def _run_upload_query():
                     "request_time": row.get("root_completed_at") or row.get("root_created_at"),
                     "api_key_masked": api_key_masked,
                     "view_token": None,
+                    "upload_view_token": row.get("view_token") if active else None,
                     "title": row.get("root_title") or row.get("filename") or "本地上传",
                     "author": None,
                     "platform": "local_upload",
diff --git a/src/web/static/history.html b/src/web/static/history.html
index 82e4c563..047ed449 100644
--- a/src/web/static/history.html
+++ b/src/web/static/history.html
@@ -501,6 +501,13 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
 
     <!-- 过滤栏 -->
     <div class="filter-bar" id="filterBar" style="display:none">
+        <div class="filter-group">
+            <label>来源</label>
+            <select id="filterSource" onchange="serializeFiltersToURL(); applyFilter()">
+                <option value="url">链接转录</option>
+                <option value="upload">本地音视频</option>
+            </select>
+        </div>
         <div class="filter-group">
             <label>开始日期</label>
             <input type="date" id="filterStartDate">
@@ -696,6 +703,8 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
         const element = document.getElementById(id);
         if (element) element.value = '';
     });
+    const sourceEl = document.getElementById('filterSource');
+    if (sourceEl) sourceEl.value = 'url';
     const status = document.getElementById('filterStatus');
     if (status) status.value = 'success';
     const read = document.getElementById('filterRead');
@@ -845,6 +854,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
     const get = id => document.getElementById(id)?.value.trim() || '';
 
     const q         = get('filterQ');
+    const source    = get('filterSource');
     const startDate = get('filterStartDate');
     const endDate   = get('filterEndDate');
     const webhook   = get('filterWebhook');
@@ -854,6 +864,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
     const read      = get('filterRead');
 
     if (q)         params.set('q', q);
+    if (source && source !== 'url') params.set('source', source);
     if (startDate) params.set('start_date', startDate);
     if (endDate)   params.set('end_date', endDate);
     // webhook 含密钥，不写入 URL
@@ -875,6 +886,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
         if (val !== null) { const el = document.getElementById(id); if (el) el.value = val; }
     };
     set('filterQ',          'q');
+    set('filterSource',     'source');
     set('filterStartDate',  'start_date');
     set('filterEndDate',    'end_date');
     // webhook 不从 URL 读取
@@ -971,8 +983,12 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
     try {
         const res = await apiFetch('/api/audit/filter-options', {}, requestGeneration);
         if (requestGeneration !== privateRequestGeneration) return;
-        if (res.code === 200) {
-            filterOptions = res.data;
+        if (res.code === 200 && res.data) {
+            filterOptions = {
+                webhooks: res.data.webhooks,
+                platforms: res.data.platforms,
+                authors: res.data.authors,
+            };
             currentMasked = res.data.api_key_masked || '';
             populateFilterDropdowns();
             loadFiltersFromURL();   // 恢复 URL 里的过滤条件（必须在下拉填充后）
@@ -1091,6 +1107,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
 // ===================== 过滤 =====================
 function applyFilter() { serializeFiltersToURL(); loadHistory(0); }
 function resetFilter() {
+    document.getElementById('filterSource').value = 'url';
     document.getElementById('filterStartDate').value = '';
     document.getElementById('filterEndDate').value = '';
     document.getElementById('filterWebhook').value = '';
@@ -1121,20 +1138,26 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
 }
 
 // ===================== API 请求 =====================
-async function apiFetch(url, params = {}, requestGeneration = privateRequestGeneration) {
+async function apiFetch(url, params = {}, requestGeneration = privateRequestGeneration, method = 'GET') {
     const authStorage = requireHistoryAuth();
     if (!authStorage) throw new Error(HISTORY_AUTH_ERROR);
     if (requestGeneration !== privateRequestGeneration) throw createSupersededPrivateHistoryError();
-    const qs = new URLSearchParams(params).toString();
+    const qs = method === 'GET' ? new URLSearchParams(params).toString() : '';
     const fullUrl = qs ? `${url}?${qs}` : url;
     const requestSnapshot = authStorage.snapshotAuthToken();
     const controller = new AbortController();
     privateRequestControllers.add(controller);
     try {
-        const res = await fetch(fullUrl, {
+        const fetchOptions = {
+            method,
             headers: authStorage.buildAuthHeaders(),
             signal: controller.signal
-        });
+        };
+        if (method !== 'GET' && params && Object.keys(params).length > 0) {
+            fetchOptions.headers['Content-Type'] = 'application/json';
+            fetchOptions.body = JSON.stringify(params);
+        }
+        const res = await fetch(fullUrl, fetchOptions);
         if (requestGeneration !== privateRequestGeneration) throw createSupersededPrivateHistoryError();
         if (res.status === 401) {
             const cleared = authStorage.clearAuthTokenIfMatch(requestSnapshot);
@@ -1147,12 +1170,54 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
         }
         const body = await res.json();
         if (requestGeneration !== privateRequestGeneration) throw createSupersededPrivateHistoryError();
+        if (!res.ok) {
+            throw new Error(body.detail || body.message || `HTTP ${res.status}`);
+        }
         return body;
     } finally {
         privateRequestControllers.delete(controller);
     }
 }
 
+/**
+ * 停止上传内容的公开分享
+ */
+async function stopShare(uploadId) {
+    if (!uploadId) return;
+    const confirmed = confirm('确认关闭公开分享？关闭后将停止后续阅读、导出与重新处理，但不立即擦除正文，也不取消在途处理与通知。');
+    if (!confirmed) return;
+
+    try {
+        await apiFetch(`/api/uploads/${encodeURIComponent(uploadId)}/share`, {}, privateRequestGeneration, 'DELETE');
+        showStatus('ok', '已停止公开分享');
+        const btn = document.querySelector(`.btn-stop-share[data-upload-id="${uploadId}"]`);
+        if (btn) {
+            const row = btn.closest('.task-row');
+            btn.remove();
+            if (row) {
+                row.classList.add('unclickable');
+                row.removeAttribute('data-vt');
+                row.removeAttribute('onclick');
+                const authorCell = row.querySelector('.task-author');
+                if (authorCell) {
+                    const badge = authorCell.querySelector('.task-status-badge');
+                    if (badge) {
+                        badge.className = 'task-status-badge status-failed';
+                        badge.style.background = '';
+                        badge.style.color = '';
+                        badge.textContent = '已停止分享';
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        showStatus('err', '停止分享失败: ' + (err.message || '未知错误'));
+    }
+}
+if (typeof window !== 'undefined') {
+    window.stopShare = stopShare;
+}
+
 // 缓存客户端过滤后的全量数据（仅已读/未读过滤激活时使用）
 let _filteredItems = null;
 
@@ -1170,6 +1235,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
         params.offset = currentPage * PAGE_SIZE;
     }
 
+    const source    = document.getElementById('filterSource')?.value || 'url';
     const startDate = document.getElementById('filterStartDate').value;
     const endDate   = document.getElementById('filterEndDate').value;
     const webhook   = document.getElementById('filterWebhook').value;
@@ -1178,6 +1244,7 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
     const status    = document.getElementById('filterStatus').value;
     const q = document.getElementById('filterQ')?.value.trim() || '';
 
+    if (source)    params.source = source;
     if (startDate) params.start_date = startDate;
     if (endDate)   params.end_date = endDate;
     if (webhook)   params.webhook = webhook;
@@ -1253,6 +1320,76 @@ <h3>Webhook 别名（保存在本地浏览器）</h3>
 }
 
 function buildRow(item, readSet) {
+    if (item.source === 'upload') {
+        const isCompleted = item.status === 'success';
+        const activeToken = item.upload_view_token;
+        const canClick = Boolean(isCompleted && activeToken && item.share_active);
+        const isRead = Boolean(canClick && activeToken && readSet.has(activeToken));
+
+        const time = item.request_time
+            ? item.request_time.replace('T', ' ').slice(0, 16)
+            : '—';
+
+        const displayTitle = item.title || item.filename || '本地上传';
+        const retentionLabel = item.retention === 'never' ? '永久保留' : (item.retention === '30d' ? '30天保留' : (item.retention || '30天保留'));
+
+        let shareBadge = '';
+        if (item.share_active) {
+            shareBadge = '<span class="task-status-badge status-processing" style="background:var(--success-bg); color:var(--success-text);">分享中</span>';
+        } else if (item.share_inactive_reason === 'expired') {
+            shareBadge = '<span class="task-status-badge status-unknown">已到期</span>';
+        } else {
+            shareBadge = '<span class="task-status-badge status-failed">已停止分享</span>';
+        }
+
+        const titleHtml = `
+            <div class="task-title">${esc(displayTitle)}</div>
+            <div class="task-author" style="display:flex; gap:8px; align-items:center; flex-wrap:wrap;">
+                ${item.filename ? `<span>📁 ${esc(item.filename)}</span>` : ''}
+                <span>⏱️ ${esc(retentionLabel)}</span>
+                ${shareBadge}
+                ${item.source_url ? `<span title="${esc(item.source_url)}">🌐 来源链接</span>` : ''}
+            </div>
+        `;
+
+        const classes = ['task-row'];
+        if (isRead) classes.push('read');
+        if (!canClick) classes.push('unclickable');
+
+        const vtAttr = canClick ? `data-vt="${esc(activeToken)}"` : '';
+        const clickHandler = canClick
+            ? `onclick="openTask('${esc(activeToken)}', this)"`
+            : '';
+
+        const checkboxHtml = canClick
+            ? `<input type="checkbox" class="row-checkbox" onclick="event.stopPropagation()">`
+            : `<span></span>`;
+
+        let actionHtml = `<div class="task-platform">📁 本地上传</div>`;
+        if (item.share_active && item.upload_id) {
+            actionHtml = `
+                <div style="display:flex; flex-direction:column; gap:4px; align-items:center;">
+                    <div class="task-platform">📁 本地上传</div>
+                    <button type="button" class="btn btn-ghost btn-stop-share"
+                            style="font-size:0.7rem; padding:2px 8px; color:var(--error-text); border-color:var(--error-border); white-space:nowrap;"
+                            data-upload-id="${esc(item.upload_id)}"
+                            onclick="event.stopPropagation(); stopShare('${esc(item.upload_id)}')">
+                        停止分享
+                    </button>
+                </div>
+            `;
+        }
+
+        return `
+            <div class="${classes.join(' ')}" ${vtAttr} ${clickHandler}>
+                ${!isRead && canClick ? '<div class="read-dot"></div>' : ''}
+                ${checkboxHtml}
+                <div class="task-time">${esc(time)}</div>
+                <div class="task-title-cell">${titleHtml}</div>
+                ${actionHtml}
+            </div>`;
+    }
+
     const isCompleted = item.status === 'success';
     const isRead = isCompleted && item.view_token && readSet.has(item.view_token);
     const canClick = isCompleted && item.view_token;
diff --git a/src/web/static/index.html b/src/web/static/index.html
index cb7e48c5..dd7d1a2d 100644
--- a/src/web/static/index.html
+++ b/src/web/static/index.html
@@ -19,6 +19,149 @@
     <meta name="apple-mobile-web-app-capable" content="yes">
     <link rel="apple-touch-icon" href="/static/icons/apple-touch-icon.png">
     <link rel="stylesheet" href="/static/css/styles.css">
+    <style>
+        .mode-tabs {
+            display: flex;
+            gap: 8px;
+            margin-bottom: 16px;
+            border-bottom: 1px solid var(--border-primary);
+            padding-bottom: 8px;
+        }
+        .mode-tab {
+            padding: 8px 16px;
+            border: 1px solid var(--border-primary);
+            border-radius: 8px;
+            background: var(--bg-secondary);
+            color: var(--text-secondary);
+            cursor: pointer;
+            font-size: 0.95rem;
+            font-weight: 500;
+            transition: all 0.2s ease;
+            min-height: 44px;
+        }
+        .mode-tab:hover {
+            border-color: var(--accent-primary);
+            color: var(--text-primary);
+        }
+        .mode-tab.active {
+            background: var(--accent-primary);
+            border-color: var(--accent-primary);
+            color: #ffffff;
+            font-weight: 600;
+        }
+        .upload-disabled-banner {
+            background: var(--error-bg);
+            border: 1px solid var(--error-border);
+            color: var(--error-text);
+            padding: 10px 14px;
+            border-radius: 8px;
+            margin-bottom: 14px;
+            font-size: 0.9rem;
+            font-weight: 600;
+        }
+        .upload-privacy-notice {
+            background: var(--bg-secondary);
+            border: 1px solid var(--border-primary);
+            border-radius: 8px;
+            padding: 10px 14px;
+            margin-bottom: 14px;
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+            line-height: 1.5;
+        }
+        .upload-drop-zone {
+            border: 2px dashed var(--border-secondary);
+            border-radius: 12px;
+            padding: 24px 16px;
+            text-align: center;
+            background: var(--bg-secondary);
+            cursor: pointer;
+            transition: border-color 0.2s ease, background-color 0.2s ease;
+            outline: none;
+        }
+        .upload-drop-zone:hover, .upload-drop-zone:focus-visible, .upload-drop-zone.dragover {
+            border-color: var(--accent-primary);
+            background: var(--bg-tertiary);
+        }
+        .drop-zone-prompt {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 6px;
+        }
+        .drop-zone-icon {
+            font-size: 2rem;
+        }
+        .drop-zone-text {
+            font-size: 0.95rem;
+            font-weight: 600;
+            color: var(--text-primary);
+        }
+        .drop-zone-hint {
+            font-size: 0.8rem;
+            color: var(--text-tertiary);
+        }
+        .upload-file-info {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 12px;
+            padding: 10px 14px;
+            background: var(--bg-primary);
+            border: 1px solid var(--border-primary);
+            border-radius: 8px;
+            text-align: left;
+        }
+        .upload-file-icon {
+            font-size: 1.5rem;
+        }
+        .upload-file-meta {
+            flex: 1;
+            min-width: 0;
+            display: flex;
+            flex-direction: column;
+        }
+        .upload-file-name {
+            font-weight: 600;
+            font-size: 0.9rem;
+            color: var(--text-primary);
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+        .upload-file-size {
+            font-size: 0.8rem;
+            color: var(--text-tertiary);
+        }
+        .btn-clear {
+            background: none;
+            border: none;
+            color: var(--text-tertiary);
+            font-size: 1.2rem;
+            cursor: pointer;
+            padding: 4px 8px;
+            border-radius: 4px;
+            line-height: 1;
+        }
+        .btn-clear:hover {
+            color: var(--error-text);
+            background: var(--bg-secondary);
+        }
+        .retention-options {
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+            margin-top: 6px;
+        }
+        .retention-radio-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 0.9rem;
+            color: var(--text-primary);
+            cursor: pointer;
+        }
+    </style>
 </head>
 <body>
     <div class="container">
@@ -39,25 +182,97 @@ <h1>🎬 视频转录服务</h1>
 
         <main class="main-content">
             <form id="transcribe-form" class="form-container">
-                <!-- URL输入区域 -->
-                <div class="form-group share-input-group">
-                    <label for="share-content" class="form-label">
-                        📋 粘贴分享内容或视频链接
-                    </label>
-                    <textarea
-                        id="share-content"
-                        class="form-textarea"
-                        placeholder="粘贴链接或完整分享文案"
-                        rows="3"
-                        autocapitalize="sentences"
-                        spellcheck="true"
-                        aria-describedby="input-feedback">
-                    </textarea>
-                    <p id="input-feedback" class="input-feedback" role="status"
-                       aria-live="polite" hidden></p>
-
-                    <!-- URL识别结果：仅在找到链接时显示 -->
-                    <div id="url-preview" class="url-preview" aria-live="polite" hidden></div>
+                <!-- 提交模式切换：链接转录 / 本地音视频 -->
+                <div class="mode-tabs" role="tablist" aria-label="转录方式">
+                    <button type="button" role="tab" id="mode-tab-url" class="mode-tab active" aria-selected="true" aria-controls="url-mode-panel">🔗 链接转录</button>
+                    <button type="button" role="tab" id="mode-tab-upload" class="mode-tab" aria-selected="false" aria-controls="upload-mode-panel">📁 本地音视频</button>
+                </div>
+
+                <!-- URL 模式面板 -->
+                <div id="url-mode-panel" class="mode-panel">
+                    <!-- URL输入区域 -->
+                    <div class="form-group share-input-group">
+                        <label for="share-content" class="form-label">
+                            📋 粘贴分享内容或视频链接
+                        </label>
+                        <textarea
+                            id="share-content"
+                            class="form-textarea"
+                            placeholder="粘贴链接或完整分享文案"
+                            rows="3"
+                            autocapitalize="sentences"
+                            spellcheck="true"
+                            aria-describedby="input-feedback">
+                        </textarea>
+                        <p id="input-feedback" class="input-feedback" role="status"
+                           aria-live="polite" hidden></p>
+
+                        <!-- URL识别结果：仅在找到链接时显示 -->
+                        <div id="url-preview" class="url-preview" aria-live="polite" hidden></div>
+                    </div>
+                </div>
+
+                <!-- 本地音视频上传面板 -->
+                <div id="upload-mode-panel" class="mode-panel" hidden>
+                    <!-- 上传未开启/不可用警告条 -->
+                    <div id="upload-disabled-banner" class="upload-disabled-banner" role="alert" hidden>
+                        <span>⚠️ 本地上传服务当前未开启或暂不可用</span>
+                    </div>
+
+                    <!-- 公开只读与外部处理提示 -->
+                    <div class="upload-privacy-notice" role="note">
+                        ℹ️ 提示：上传的音视频将通过外部语音识别引擎转录，并通过 AI 模型进行智能校对与总结；转录完成将生成公开只读分享链接，请勿上传包含个人敏感隐私的内容。
+                    </div>
+
+                    <!-- 文件选择与拖拽区域 -->
+                    <div class="form-group">
+                        <label class="form-label">📁 选择或拖入音视频文件</label>
+                        <div id="upload-drop-zone" class="upload-drop-zone" tabindex="0" role="button" aria-label="点击或拖拽选择音视频文件">
+                            <input type="file" id="upload-file-input" accept="audio/*,video/*" style="display:none">
+                            <div class="drop-zone-prompt" id="drop-zone-prompt">
+                                <span class="drop-zone-icon">📤</span>
+                                <span class="drop-zone-text">点击选择 或 将音视频文件拖至此处</span>
+                                <span class="drop-zone-hint" id="upload-limits-hint">支持常见音频与视频格式</span>
+                            </div>
+                            <div id="upload-file-info" class="upload-file-info" hidden>
+                                <span class="upload-file-icon">🎬</span>
+                                <div class="upload-file-meta">
+                                    <span id="upload-file-name" class="upload-file-name"></span>
+                                    <span id="upload-file-size" class="upload-file-size"></span>
+                                </div>
+                                <button type="button" id="upload-file-clear" class="btn-clear" aria-label="取消已选文件">✕</button>
+                            </div>
+                        </div>
+                        <p id="upload-input-feedback" class="input-feedback" role="status" aria-live="polite" hidden></p>
+                    </div>
+
+                    <!-- 选填标题 -->
+                    <div class="form-group">
+                        <label for="upload-title" class="form-label">📌 标题（选填）</label>
+                        <input type="text" id="upload-title" class="form-input" maxlength="200" placeholder="选填，最多200字，留空自动提取文件名">
+                    </div>
+
+                    <!-- 选填来源链接 -->
+                    <div class="form-group">
+                        <label for="upload-source-url" class="form-label">🌐 来源链接（选填）</label>
+                        <input type="url" id="upload-source-url" class="form-input" maxlength="2048" placeholder="选填，http(s) 链接，仅展示不抓取">
+                    </div>
+
+                    <!-- 保留期限 -->
+                    <div class="form-group retention-group">
+                        <label class="form-label">⏱️ 内容保留期限</label>
+                        <div class="retention-options">
+                            <label class="retention-radio-label">
+                                <input type="radio" name="upload-retention" value="30d" checked>
+                                <span>30天保留（默认，转录终态起算）</span>
+                            </label>
+                            <label class="retention-radio-label">
+                                <input type="radio" name="upload-retention" value="never">
+                                <span>永久保留（每次新选文件重置）</span>
+                            </label>
+                        </div>
+                        <small class="form-help">保留期限从转录终态（成功/失败）起算；到期或停止分享后链接失效</small>
+                    </div>
                 </div>
 
                 <!-- 高频选项入口：摘要常驻，说明按需展开 -->
@@ -77,6 +292,20 @@ <h1>🎬 视频转录服务</h1>
                                 <span class="checkbox-desc">适用于多人对话、访谈等场景</span>
                             </label>
                         </div>
+                        <div class="checkbox-group" style="margin-top: 10px;">
+                            <input type="checkbox" id="calibrate-option" class="form-checkbox" checked>
+                            <label for="calibrate-option" class="checkbox-label">
+                                启用 AI 智能校对
+                                <span class="checkbox-desc">使用 LLM 修复语音识别中的错别字与断句</span>
+                            </label>
+                        </div>
+                        <div class="checkbox-group" style="margin-top: 10px;">
+                            <input type="checkbox" id="summarize-option" class="form-checkbox" checked>
+                            <label for="summarize-option" class="checkbox-label">
+                                启用内容总结与章节
+                                <span class="checkbox-desc">生成全文摘要、重点回顾与章节大纲</span>
+                            </label>
+                        </div>
                     </div>
                 </div>
 
diff --git a/src/web/static/js/app.js b/src/web/static/js/app.js
index 978a85b2..c0487d95 100644
--- a/src/web/static/js/app.js
+++ b/src/web/static/js/app.js
@@ -24,6 +24,12 @@ let authStorageErrorShown = false;
 let currentTask = null;
 let isAdvancedSettingsExpanded = false;
 let webhookSaveTimer = null;
+let currentMode = 'url';
+let selectedUploadFile = null;
+let uploadCapabilities = null;
+let uploadCapabilitiesIdentity = null;
+let currentUploadIntent = null;
+let isUploading = false;
 
 /**
  * 通用URL提取正则表达式
@@ -95,6 +101,7 @@ function handleHomepageAuthStorageEvent(event) {
     ].includes(event && event.key)) return;
     const tokenInput = document.getElementById('bearer-token');
     if (tokenInput) tokenInput.value = authStorage.readAuthToken() || '';
+    checkUploadCapabilities();
     UIManager.updateSubmitButton();
 }
 
@@ -123,23 +130,27 @@ function buildHistoryItemHTML(task) {
     const timeStr = escapeHTML(new Date(task.timestamp).toLocaleString('zh-CN'));
     const originalTextPreview = task.original_text ?
         (task.original_text.length > 100 ? task.original_text.substring(0, 100) + '...' : task.original_text) : '';
+    const isUpload = task.source === 'upload';
+    const retentionBadge = task.retention ? `<span class="feature-tag">• 保留: ${escapeHTML(task.retention)}</span>` : '';
     return `
         <div class="history-info">
             <div class="history-title">${escapeHTML(task.title)}</div>
             ${originalTextPreview ? `
                 <div class="history-original-text">
-                    <span class="original-text-label">原始内容：</span>
+                    <span class="original-text-label">${isUpload ? '来源链接：' : '原始内容：'}</span>
                     <span class="original-text-content">${escapeHTML(originalTextPreview)}</span>
                 </div>
             ` : ''}
-            <div class="history-url">${escapeHTML(task.url)}</div>
+            ${task.url ? `<div class="history-url">${escapeHTML(task.url)}</div>` : ''}
             <div class="history-meta">
                 <span>${timeStr}</span>
+                ${isUpload ? '<span class="feature-tag">• 本地上传</span>' : ''}
                 ${task.useSpeakerRecognition ? '<span class="feature-tag">• 说话人识别</span>' : ''}
+                ${retentionBadge}
             </div>
         </div>
         <div class="history-actions">
-            <button class="history-btn history-copy-btn" data-url="${escapeHTML(task.url)}">📋 复制</button>
+            ${task.url ? `<button class="history-btn history-copy-btn" data-url="${escapeHTML(task.url)}">📋 复制</button>` : ''}
             <a class="history-btn" href="/view/${escapeHTML(task.view_token || task.id)}" target="_blank">👁️ 查看</a>
             <button class="history-btn delete-btn history-delete-btn" data-task-id="${escapeHTML(task.id)}">🗑️ 删除</button>
         </div>
@@ -387,6 +398,106 @@ class APIManager {
 
         return await response.json();
     }
+
+    /**
+     * 获取上传功能配置
+     */
+    static async getUploadCapabilities() {
+        const authStorage = requireAuthStorage();
+        const headers = authStorage ? authStorage.buildAuthHeaders() : {};
+        const response = await fetch('/api/uploads/capabilities', {
+            headers
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.message || errorData.detail || `HTTP ${response.status}`);
+        }
+
+        return await response.json();
+    }
+
+    /**
+     * 提交本地音视频上传
+     */
+    static async submitUpload(file, idempotencyKey, metadata) {
+        const authStorage = requireAuthStorage();
+        const token = authStorage && authStorage.readAuthToken();
+
+        if (!token) {
+            throw new Error(authStorage ? '请先设置访问令牌' : AUTH_STORAGE_ERROR_MESSAGE);
+        }
+
+        const encodedMetadata = encodeUploadMetadata(metadata);
+        const headers = {
+            'Content-Type': 'application/octet-stream',
+            'Idempotency-Key': idempotencyKey,
+            'X-Upload-Metadata': encodedMetadata,
+            ...authStorage.buildAuthHeaders()
+        };
+
+        const response = await fetch('/api/uploads', {
+            method: 'POST',
+            headers,
+            body: file
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            const error = new Error(errorData.message || errorData.detail || `HTTP ${response.status}`);
+            error.status = response.status;
+            error.data = errorData;
+            throw error;
+        }
+
+        return await response.json();
+    }
+
+    /**
+     * 根据 Idempotency-Key 查询上传回执
+     */
+    static async getUploadReceipt(idempotencyKey) {
+        const authStorage = requireAuthStorage();
+        const headers = authStorage ? authStorage.buildAuthHeaders() : {};
+        const response = await fetch(`/api/uploads/by-idempotency-key/${encodeURIComponent(idempotencyKey)}`, {
+            headers
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            const error = new Error(errorData.message || errorData.detail || `HTTP ${response.status}`);
+            error.status = response.status;
+            throw error;
+        }
+
+        return await response.json();
+    }
+
+    /**
+     * 停止上传内容的公开分享
+     */
+    static async stopUploadShare(uploadId) {
+        const authStorage = requireAuthStorage();
+        const token = authStorage && authStorage.readAuthToken();
+
+        if (!token) {
+            throw new Error(authStorage ? '请先设置访问令牌' : AUTH_STORAGE_ERROR_MESSAGE);
+        }
+
+        const response = await fetch(`/api/uploads/${encodeURIComponent(uploadId)}/share`, {
+            method: 'DELETE',
+            headers: authStorage.buildAuthHeaders()
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            const error = new Error(errorData.message || errorData.detail || `HTTP ${response.status}`);
+            error.status = response.status;
+            throw error;
+        }
+
+        return await response.json();
+    }
 }
 
 /**
@@ -404,16 +515,20 @@ class TaskHistoryManager {
             const newTask = {
                 id: taskData.task_id,
                 view_token: taskData.view_token,
-                url: taskData.url,
+                upload_id: taskData.upload_id || null,
+                source: taskData.source || 'url',
+                url: taskData.url || '',
                 original_text: taskData.original_text || '',
-                title: taskData.title || this.extractTitleFromURL(taskData.url),
+                title: taskData.title || (taskData.url ? this.extractTitleFromURL(taskData.url) : '本地上传'),
                 timestamp: Date.now(),
                 useSpeakerRecognition: taskData.use_speaker_recognition || false,
+                retention: taskData.retention || null,
+                share_active: taskData.share_active !== undefined ? taskData.share_active : true,
                 status: 'submitted'
             };
 
-            // 基于URL去重：相同URL只保留最新的记录
-            const existingUrlIndex = history.findIndex(task => task.url === newTask.url);
+            // 基于URL去重：仅当URL非空时相同URL才去重保留最新
+            const existingUrlIndex = newTask.url ? history.findIndex(task => task.url === newTask.url) : -1;
             let isDuplicate = false;
             let oldTask = null;
             
@@ -533,9 +648,9 @@ class TaskHistoryManager {
             item.innerHTML = buildHistoryItemHTML(task);
 
             const copyBtn = item.querySelector('.history-copy-btn');
-            copyBtn.addEventListener('click', () => copyToClipboard(copyBtn.dataset.url));
+            if (copyBtn) copyBtn.addEventListener('click', () => copyToClipboard(copyBtn.dataset.url));
             const deleteBtn = item.querySelector('.history-delete-btn');
-            deleteBtn.addEventListener('click', () => TaskHistoryManager.deleteTask(deleteBtn.dataset.taskId));
+            if (deleteBtn) deleteBtn.addEventListener('click', () => TaskHistoryManager.deleteTask(deleteBtn.dataset.taskId));
 
             list.appendChild(item);
         });
@@ -708,6 +823,7 @@ class UIManager {
      * 更新提交按钮状态
      */
     static updateSubmitButton() {
+        if (typeof document === 'undefined') return;
         const btn = document.getElementById('submit-btn');
         if (!btn) return;
         const btnIcon = btn.querySelector('.btn-icon');
@@ -721,7 +837,6 @@ class UIManager {
             return;
         }
 
-        const selectedURL = getSelectedURL();
         const token = StorageManager.get(APP_CONFIG.STORAGE_KEYS.BEARER_TOKEN);
         const authPrompt = document.getElementById('auth-missing-prompt');
 
@@ -729,6 +844,38 @@ class UIManager {
             authPrompt.hidden = Boolean(token);
         }
 
+        if (currentMode === 'upload') {
+            let fileValid = Boolean(selectedUploadFile);
+            const uploadEnabled = Boolean(
+                uploadCapabilities &&
+                uploadCapabilities.enabled === true &&
+                uploadCapabilities.limits &&
+                typeof uploadCapabilities.limits.max_file_mib === 'number' &&
+                uploadCapabilities.limits.max_file_mib > 0
+            );
+            if (selectedUploadFile && uploadCapabilities && uploadCapabilities.limits && uploadCapabilities.limits.max_file_mib) {
+                if (selectedUploadFile.size > uploadCapabilities.limits.max_file_mib * 1024 * 1024) {
+                    fileValid = false;
+                }
+            }
+            const canSubmit = fileValid && token && !isUploading && uploadEnabled;
+
+            btn.disabled = !canSubmit;
+
+            if (isUploading) {
+                btnIcon.textContent = '⏳';
+                btnText.textContent = '上传中...';
+            } else if (!selectedUploadFile) {
+                btnIcon.textContent = '📁';
+                btnText.textContent = '开始上传';
+            } else {
+                btnIcon.textContent = '🚀';
+                btnText.textContent = '开始上传';
+            }
+            return;
+        }
+
+        const selectedURL = getSelectedURL();
         const canSubmit = selectedURL && token && !currentTask;
         
         btn.disabled = !canSubmit;
@@ -1039,6 +1186,500 @@ async function submitTranscription(event) {
     }
 }
 
+/**
+ * 格式化文件大小
+ */
+function formatBytes(bytes) {
+    if (!bytes || bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * 构建上传元数据（恰六个字段）
+ */
+function buildUploadMetadata(file, options = {}) {
+    const titleVal = options.title !== undefined ? options.title : (typeof document !== 'undefined' ? document.getElementById('upload-title')?.value : '');
+    const sourceUrlVal = options.sourceUrl !== undefined ? options.sourceUrl : (typeof document !== 'undefined' ? document.getElementById('upload-source-url')?.value : '');
+    const retentionVal = options.retention || getUploadRetention();
+
+    const processingOptions = options.processingOptions || {
+        calibrate: typeof document !== 'undefined' ? (document.getElementById('calibrate-option')?.checked ?? true) : true,
+        summarize: typeof document !== 'undefined' ? (document.getElementById('summarize-option')?.checked ?? true) : true,
+        infer_speaker_names: typeof document !== 'undefined' ? (document.getElementById('speaker-recognition')?.checked ?? false) : false,
+        chapters: typeof document !== 'undefined' ? (document.getElementById('summarize-option')?.checked ?? true) : true,
+    };
+
+    const cleanTitle = (typeof titleVal === 'string' && titleVal.trim()) ? titleVal.trim().slice(0, 200) : null;
+    const cleanSource = (typeof sourceUrlVal === 'string' && sourceUrlVal.trim()) ? sourceUrlVal.trim().slice(0, 2048) : null;
+
+    return {
+        filename: file.name,
+        byte_size: file.size,
+        title: cleanTitle,
+        source_url: cleanSource,
+        retention: retentionVal,
+        processing_options: {
+            calibrate: Boolean(processingOptions.calibrate),
+            summarize: Boolean(processingOptions.summarize),
+            infer_speaker_names: Boolean(processingOptions.infer_speaker_names),
+            chapters: Boolean(processingOptions.chapters),
+        }
+    };
+}
+
+/**
+ * base64url UTF-8 编码
+ */
+function encodeUploadMetadata(metadata) {
+    const jsonStr = JSON.stringify(metadata);
+    const EncoderClass = typeof TextEncoder !== 'undefined'
+        ? TextEncoder
+        : (typeof globalThis !== 'undefined' && globalThis.TextEncoder ? globalThis.TextEncoder : null);
+    if (!EncoderClass) {
+        throw new Error('TextEncoder is not supported in this environment');
+    }
+    const bytes = new EncoderClass().encode(jsonStr);
+    let binary = '';
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary)
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}
+
+/**
+ * 生成 Idempotency-Key (epoch_ms-UUID)
+ */
+function generateUploadIdempotencyKey() {
+    const epoch = Date.now();
+    const cryptoObj = typeof crypto !== 'undefined'
+        ? crypto
+        : (typeof globalThis !== 'undefined' && globalThis.crypto ? globalThis.crypto : null);
+    if (!cryptoObj || typeof cryptoObj.randomUUID !== 'function') {
+        throw new Error('crypto.randomUUID is not supported in this environment');
+    }
+    const uuid = cryptoObj.randomUUID();
+    return `${epoch}-${uuid}`;
+}
+
+/**
+ * 获取选中的保留期限
+ */
+function getUploadRetention() {
+    if (typeof document === 'undefined') return '30d';
+    const radio = document.querySelector('input[name="upload-retention"]:checked');
+    return radio ? radio.value : '30d';
+}
+
+/**
+ * 选择音视频文件
+ */
+function selectUploadFile(file) {
+    if (!file) return;
+    selectedUploadFile = file;
+    currentUploadIntent = null; // 新选文件重置意图
+
+    // 每次新选文件重置保留期限为 30d
+    const defaultRetention = (uploadCapabilities && uploadCapabilities.default_retention) || '30d';
+    if (typeof document !== 'undefined') {
+        const retentionRadios = document.querySelectorAll('input[name="upload-retention"]');
+        retentionRadios.forEach(r => {
+            r.checked = (r.value === defaultRetention);
+        });
+
+        const dropZonePrompt = document.getElementById('drop-zone-prompt');
+        const fileInfo = document.getElementById('upload-file-info');
+        const fileName = document.getElementById('upload-file-name');
+        const fileSize = document.getElementById('upload-file-size');
+        const feedback = document.getElementById('upload-input-feedback');
+
+        if (dropZonePrompt) dropZonePrompt.hidden = true;
+        if (fileInfo) fileInfo.hidden = false;
+        if (fileName) fileName.textContent = file.name;
+        if (fileSize) fileSize.textContent = formatBytes(file.size);
+
+        let sizeError = null;
+        if (uploadCapabilities && uploadCapabilities.limits && uploadCapabilities.limits.max_file_mib) {
+            const maxBytes = uploadCapabilities.limits.max_file_mib * 1024 * 1024;
+            if (file.size > maxBytes) {
+                sizeError = `文件大小 (${formatBytes(file.size)}) 超出限制 (${uploadCapabilities.limits.max_file_mib} MiB)`;
+            }
+        }
+
+        if (feedback) {
+            if (sizeError) {
+                feedback.textContent = sizeError;
+                feedback.hidden = false;
+            } else {
+                feedback.textContent = '';
+                feedback.hidden = true;
+            }
+        }
+    }
+
+    if (typeof UIManager !== 'undefined') {
+        UIManager.updateSubmitButton();
+    }
+}
+
+/**
+ * 清除已选文件
+ */
+function clearUploadFile() {
+    selectedUploadFile = null;
+    currentUploadIntent = null;
+    if (typeof document !== 'undefined') {
+        const fileInput = document.getElementById('upload-file-input');
+        if (fileInput) fileInput.value = '';
+
+        const dropZonePrompt = document.getElementById('drop-zone-prompt');
+        const fileInfo = document.getElementById('upload-file-info');
+        const feedback = document.getElementById('upload-input-feedback');
+
+        if (dropZonePrompt) dropZonePrompt.hidden = false;
+        if (fileInfo) fileInfo.hidden = true;
+        if (feedback) {
+            feedback.textContent = '';
+            feedback.hidden = true;
+        }
+    }
+
+    if (typeof UIManager !== 'undefined') {
+        UIManager.updateSubmitButton();
+    }
+}
+
+/**
+ * 切换转录模式 (url / upload)
+ */
+function switchMode(mode) {
+    currentMode = mode;
+    if (typeof document !== 'undefined') {
+        const urlTab = document.getElementById('mode-tab-url');
+        const uploadTab = document.getElementById('mode-tab-upload');
+        const urlPanel = document.getElementById('url-mode-panel');
+        const uploadPanel = document.getElementById('upload-mode-panel');
+
+        if (mode === 'upload') {
+            if (urlTab) {
+                urlTab.classList.remove('active');
+                urlTab.setAttribute('aria-selected', 'false');
+            }
+            if (uploadTab) {
+                uploadTab.classList.add('active');
+                uploadTab.setAttribute('aria-selected', 'true');
+            }
+            if (urlPanel) urlPanel.hidden = true;
+            if (uploadPanel) uploadPanel.hidden = false;
+            checkUploadCapabilities();
+        } else {
+            if (uploadTab) {
+                uploadTab.classList.remove('active');
+                uploadTab.setAttribute('aria-selected', 'false');
+            }
+            if (urlTab) {
+                urlTab.classList.add('active');
+                urlTab.setAttribute('aria-selected', 'true');
+            }
+            if (uploadPanel) uploadPanel.hidden = true;
+            if (urlPanel) urlPanel.hidden = false;
+        }
+    }
+
+    if (typeof UIManager !== 'undefined') {
+        UIManager.updateSubmitButton();
+    }
+}
+
+/**
+ * 检查上传功能配置
+ */
+async function checkUploadCapabilities() {
+    if (typeof document === 'undefined' || typeof fetch === 'undefined') return;
+    if (typeof window !== 'undefined' && window.location && (!window.location.protocol || !window.location.protocol.startsWith('http'))) return;
+
+    const authStorage = requireAuthStorage();
+    const token = authStorage && authStorage.readAuthToken();
+    const banner = document.getElementById('upload-disabled-banner');
+    const hint = document.getElementById('upload-limits-hint');
+    if (!token) {
+        uploadCapabilities = null;
+        uploadCapabilitiesIdentity = null;
+        if (banner) banner.hidden = true;
+        if (hint) hint.textContent = '';
+        if (typeof UIManager !== 'undefined') UIManager.updateSubmitButton();
+        return;
+    }
+
+    if (uploadCapabilitiesIdentity !== token) {
+        uploadCapabilities = null;
+        uploadCapabilitiesIdentity = null;
+        if (typeof UIManager !== 'undefined') {
+            UIManager.updateSubmitButton();
+        }
+    }
+
+    const requestIdentity = token;
+    try {
+        const caps = await APIManager.getUploadCapabilities();
+        if (typeof document === 'undefined') return;
+        if (authStorage.readAuthToken() !== requestIdentity) return;
+
+        const isFiniteLimit = caps && caps.limits && typeof caps.limits.max_file_mib === 'number' && caps.limits.max_file_mib > 0;
+        if (caps && caps.enabled === true && isFiniteLimit) {
+            uploadCapabilities = caps;
+            uploadCapabilitiesIdentity = requestIdentity;
+            if (banner) banner.hidden = true;
+            if (hint) {
+                hint.textContent = `最大支持 ${caps.limits.max_file_mib} MiB，最多 ${caps.limits.max_media_hours} 小时`;
+            }
+        } else {
+            uploadCapabilities = { enabled: false };
+            uploadCapabilitiesIdentity = requestIdentity;
+            if (banner) {
+                banner.hidden = false;
+                banner.textContent = '服务端当前已禁用本地音视频文件上传功能。';
+            }
+        }
+    } catch (err) {
+        if (authStorage.readAuthToken() !== requestIdentity) return;
+        uploadCapabilities = { enabled: false, error: err.message };
+        uploadCapabilitiesIdentity = requestIdentity;
+        if (banner) {
+            banner.hidden = false;
+            banner.textContent = (err.message && err.message.includes('401'))
+                ? '访问令牌未授权使用上传服务。'
+                : `无法获取上传服务配置: ${err.message || '网络异常'}`;
+        }
+    } finally {
+        if (authStorage.readAuthToken() === requestIdentity) {
+            if (typeof document !== 'undefined' && typeof UIManager !== 'undefined') {
+                UIManager.updateSubmitButton();
+            }
+        }
+    }
+}
+
+/**
+ * 设置拖拽区域
+ */
+function setupUploadDropZone() {
+    if (typeof document === 'undefined') return;
+    const dropZone = document.getElementById('upload-drop-zone');
+    const fileInput = document.getElementById('upload-file-input');
+    const clearBtn = document.getElementById('upload-file-clear');
+
+    if (!dropZone || !fileInput) return;
+
+    dropZone.addEventListener('click', (e) => {
+        if (e.target === clearBtn || (clearBtn && clearBtn.contains(e.target))) {
+            return;
+        }
+        fileInput.click();
+    });
+
+    dropZone.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault();
+            fileInput.click();
+        }
+    });
+
+    dropZone.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        dropZone.classList.add('dragover');
+    });
+
+    dropZone.addEventListener('dragleave', () => {
+        dropZone.classList.remove('dragover');
+    });
+
+    dropZone.addEventListener('drop', (e) => {
+        e.preventDefault();
+        dropZone.classList.remove('dragover');
+        if (e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+            selectUploadFile(e.dataTransfer.files[0]);
+        }
+    });
+
+    fileInput.addEventListener('change', (e) => {
+        if (e.target.files && e.target.files.length > 0) {
+            selectUploadFile(e.target.files[0]);
+        }
+    });
+
+    if (clearBtn) {
+        clearBtn.addEventListener('click', (e) => {
+            e.stopPropagation();
+            clearUploadFile();
+        });
+    }
+}
+
+/**
+ * 提交文件上传表单
+ */
+async function submitUploadForm(event) {
+    if (event && event.preventDefault) event.preventDefault();
+
+    if (isUploading) {
+        return;
+    }
+
+    if (!selectedUploadFile) {
+        const feedback = document.getElementById('upload-input-feedback');
+        if (feedback) {
+            feedback.textContent = '请先选择一个音视频文件。';
+            feedback.hidden = false;
+        }
+        UIManager.showStatus('error', '请先选择文件', '点击或拖拽选择本地音视频文件后重试');
+        setTimeout(UIManager.hideStatus, 5000);
+        return;
+    }
+
+    if (!uploadCapabilities || uploadCapabilities.enabled !== true) {
+        UIManager.showStatus('error', '上传服务未开启', '当前服务端已关闭本地文件上传能力或尚未完成配置探测');
+        return;
+    }
+
+    if (uploadCapabilities.limits && uploadCapabilities.limits.max_file_mib) {
+        if (selectedUploadFile.size > uploadCapabilities.limits.max_file_mib * 1024 * 1024) {
+            UIManager.showStatus('error', '文件超出限制', `文件大小超出上限 ${uploadCapabilities.limits.max_file_mib} MiB`);
+            return;
+        }
+    }
+
+    const token = StorageManager.get(APP_CONFIG.STORAGE_KEYS.BEARER_TOKEN);
+    if (!token) {
+        const authPrompt = document.getElementById('auth-missing-prompt');
+        if (authPrompt) authPrompt.hidden = false;
+        UIManager.showStatus('error', '请先设置访问令牌', '点击“去设置”展开访问令牌输入框');
+        setTimeout(UIManager.hideStatus, 5000);
+        return;
+    }
+
+    const fileSnapshot = selectedUploadFile;
+    const metadataSnapshot = buildUploadMetadata(fileSnapshot);
+    const metaSignature = JSON.stringify(metadataSnapshot);
+
+    if (!currentUploadIntent || currentUploadIntent.file !== fileSnapshot || currentUploadIntent.metaSignature !== metaSignature) {
+        currentUploadIntent = {
+            file: fileSnapshot,
+            metaSignature: metaSignature,
+            idempotencyKey: generateUploadIdempotencyKey(),
+            pendingVerification: false
+        };
+    }
+
+    const intentSnapshot = currentUploadIntent;
+    isUploading = true;
+    UIManager.updateSubmitButton();
+
+    let receipt = null;
+    try {
+        if (intentSnapshot.pendingVerification) {
+            UIManager.showStatus('loading', '正在核实上传受理状态...', '未重复发送文件，正在查询回执');
+            try {
+                receipt = await APIManager.getUploadReceipt(intentSnapshot.idempotencyKey);
+            } catch (getErr) {
+                UIManager.showStatus('error', '上传状态待核实', `核实回执失败（${getErr.message || getErr.status || '未知'}），当前尚未取得回执记录。请稍后重试核实状态。`);
+                return;
+            }
+        } else {
+            UIManager.showStatus('loading', '正在上传音视频文件...', '请稍候，文件正在传输并提交受理');
+            try {
+                receipt = await APIManager.submitUpload(fileSnapshot, intentSnapshot.idempotencyKey, metadataSnapshot);
+            } catch (postErr) {
+                const isClientRejection = postErr.status && postErr.status >= 400 && postErr.status < 500;
+                if (isClientRejection) {
+                    currentUploadIntent = null;
+                    UIManager.showStatus('error', '上传失败', postErr.message || `HTTP ${postErr.status}`);
+                    return;
+                }
+
+                // POST 5xx 或网络/解析异常：保留原 key，仅在初次错误后核实一次
+                intentSnapshot.pendingVerification = true;
+                UIManager.showStatus('loading', '服务响应异常，正在核实受理状态...', '未重复发送文件，正在按回执核实状态');
+                try {
+                    receipt = await APIManager.getUploadReceipt(intentSnapshot.idempotencyKey);
+                } catch (receiptErr) {
+                    UIManager.showStatus('error', '上传状态待核实', `服务或网络响应异常（${postErr.message || postErr.status || '未知'}），初次核实回执未确认: ${receiptErr.message}。请稍后重试核实状态。`);
+                    return;
+                }
+            }
+        }
+    } finally {
+        isUploading = false;
+        UIManager.updateSubmitButton();
+    }
+
+    if (!receipt) {
+        return;
+    }
+
+    if (receipt.state === 'accepted') {
+        currentUploadIntent = null;
+        const taskData = {
+            task_id: receipt.task_id,
+            view_token: receipt.view_token,
+            upload_id: receipt.upload_id,
+            source: 'upload',
+            title: metadataSnapshot.title || fileSnapshot.name,
+            original_text: metadataSnapshot.source_url || '',
+            retention: receipt.retention,
+            share_active: receipt.share_active
+        };
+        TaskHistoryManager.addTask(taskData);
+
+        const isStandalone = (typeof window !== 'undefined' && window.matchMedia && window.matchMedia('(display-mode: standalone)').matches)
+            || (typeof window !== 'undefined' && window.navigator && window.navigator.standalone === true);
+
+        let statusMessage = '文件上传成功，任务已受理！';
+        let statusDetails = `上传ID: ${escapeHTML(receipt.upload_id)}<br>` +
+            (receipt.task_id ? `任务ID: ${escapeHTML(receipt.task_id)}<br>` : '') +
+            `状态: ${escapeHTML(receipt.state)}<br>` +
+            (receipt.expires_at ? `保留至: ${escapeHTML(receipt.expires_at)}<br>` : '') +
+            (receipt.view_token ? `<a href="/view/${escapeHTML(receipt.view_token)}" target="${isStandalone ? '_self' : '_blank'}" style="color: #667eea; text-decoration: underline;">点击查看转录结果与进度</a>` : '');
+
+        UIManager.showStatus('success', statusMessage, statusDetails);
+
+        if (!isStandalone && receipt.view_token) {
+            setTimeout(() => {
+                if (typeof window !== 'undefined' && window.open) {
+                    window.open(`/view/${receipt.view_token}`, '_blank');
+                }
+            }, 3000);
+        }
+
+        if (selectedUploadFile === fileSnapshot) {
+            clearUploadFile();
+        }
+    } else if (receipt.state === 'receiving') {
+        intentSnapshot.pendingVerification = true;
+        let statusMessage = '文件已接收，等待排队受理...';
+        let statusDetails = `上传ID: ${escapeHTML(receipt.upload_id)}<br>` +
+            `状态: ${escapeHTML(receipt.state)}<br>` +
+            '当前任务仍在接收处理中，尚未生成正式任务ID，请稍后核实。';
+        UIManager.showStatus('loading', statusMessage, statusDetails);
+    } else if (receipt.state === 'failed') {
+        currentUploadIntent = null;
+        let statusMessage = '上传处理失败';
+        let statusDetails = `上传ID: ${escapeHTML(receipt.upload_id)}<br>` +
+            `状态: ${escapeHTML(receipt.state)}<br>` +
+            `错误: ${escapeHTML(receipt.error_code || '处理异常')}`;
+        UIManager.showStatus('error', statusMessage, statusDetails);
+    } else {
+        intentSnapshot.pendingVerification = true;
+        UIManager.showStatus('error', '上传状态未知', `回执返回状态: ${escapeHTML(receipt.state || '空')}`);
+    }
+}
+
 /**
  * 页面初始化
  */
@@ -1078,7 +1719,25 @@ function initializePage() {
     previewContainer.hidden = true;
     
     const form = document.getElementById('transcribe-form');
-    form.addEventListener('submit', submitTranscription);
+    form.addEventListener('submit', (e) => {
+        if (currentMode === 'upload') {
+            submitUploadForm(e);
+        } else {
+            submitTranscription(e);
+        }
+    });
+
+    // 模式切换
+    const urlTab = document.getElementById('mode-tab-url');
+    const uploadTab = document.getElementById('mode-tab-upload');
+    if (urlTab) urlTab.addEventListener('click', () => switchMode('url'));
+    if (uploadTab) uploadTab.addEventListener('click', () => switchMode('upload'));
+
+    // 设置上传拖拽与点击选择
+    setupUploadDropZone();
+
+    // 预检上传功能开关
+    checkUploadCapabilities();
     
     const advancedToggle = document.getElementById('advanced-toggle');
     advancedToggle.addEventListener('click', UIManager.toggleAdvancedSettings);
@@ -1106,6 +1765,7 @@ function initializePage() {
             e.target.value = StorageManager.get(APP_CONFIG.STORAGE_KEYS.BEARER_TOKEN) || '';
             UIManager.showStatus('error', '访问令牌保存失败', '仍使用当前访问令牌');
         }
+        checkUploadCapabilities();
         UIManager.updateSubmitButton();
     });
 
@@ -1161,6 +1821,18 @@ if (typeof document !== 'undefined') {
 // 导出全局函数供HTML使用
 if (typeof window !== 'undefined') {
     window.copyToClipboard = copyToClipboard;
+    window.buildUploadMetadata = buildUploadMetadata;
+    window.encodeUploadMetadata = encodeUploadMetadata;
+    window.generateUploadIdempotencyKey = generateUploadIdempotencyKey;
+    window.selectUploadFile = selectUploadFile;
+    window.clearUploadFile = clearUploadFile;
+    window.getUploadRetention = getUploadRetention;
+    window.switchMode = switchMode;
+    window.checkUploadCapabilities = checkUploadCapabilities;
+    window.submitUploadForm = submitUploadForm;
+    window.APIManager = APIManager;
+    window.UIManager = UIManager;
+    window.TaskHistoryManager = TaskHistoryManager;
 }
 
 // 导出纯函数供 vitest（CJS，经 createRequire 加载）
@@ -1170,8 +1842,19 @@ if (typeof module !== 'undefined' && module.exports) {
         buildHistoryItemHTML,
         StorageManager,
         APIManager,
+        UIManager,
+        TaskHistoryManager,
         getAuthStorage,
         disableProtectedActions,
         AUTH_STORAGE_ERROR_MESSAGE,
+        buildUploadMetadata,
+        encodeUploadMetadata,
+        generateUploadIdempotencyKey,
+        selectUploadFile,
+        clearUploadFile,
+        getUploadRetention,
+        switchMode,
+        checkUploadCapabilities,
+        submitUploadForm,
     };
 }
diff --git a/src/web/tests/local-upload.test.js b/src/web/tests/local-upload.test.js
new file mode 100644
index 00000000..c9af460c
--- /dev/null
+++ b/src/web/tests/local-upload.test.js
@@ -0,0 +1,688 @@
+// @vitest-environment jsdom
+import { readFileSync } from 'node:fs';
+import { JSDOM } from 'jsdom';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const indexSource = readFileSync('src/web/static/index.html', 'utf-8');
+const authSource = readFileSync('src/web/static/js/auth-storage.js', 'utf-8');
+const appSource = readFileSync('src/web/static/js/app.js', 'utf-8');
+const historySource = readFileSync('src/web/static/history.html', 'utf-8');
+
+let dom;
+
+function decodeBase64Url(str) {
+  const padded = str + '='.repeat((4 - (str.length % 4)) % 4);
+  const base64 = padded.replace(/-/g, '+').replace(/_/g, '/');
+  const binary = atob(base64);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
+const originalFetch = globalThis.fetch;
+
+async function installIndexPage({ token = 'test-token', capabilities = undefined } = {}) {
+  dom = new JSDOM(indexSource, {
+    url: 'https://vta.test/add_task_by_web',
+    runScripts: 'outside-only',
+  });
+  const { window } = dom;
+  window.TextEncoder = globalThis.TextEncoder;
+  if (!window.crypto) {
+    Object.defineProperty(window, 'crypto', { value: globalThis.crypto, configurable: true });
+  }
+  dom.window.HTMLElement.prototype.scrollIntoView = vi.fn();
+  window.matchMedia = vi.fn((media) => ({
+    matches: false,
+    media,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  }));
+
+  const caps = capabilities !== undefined ? capabilities : {
+    enabled: true,
+    default_retention: '30d',
+    retention_options: ['30d', 'never'],
+    limits: {
+      max_file_mib: 100,
+      max_media_hours: 2,
+      receive_concurrency: 1,
+      upload_temp_budget_mib: 500,
+    },
+  };
+  dom.caps = caps;
+
+  window.fetch = vi.fn(async (url, options = {}) => {
+    if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+      if (!caps) {
+        throw new Error('Capabilities 401 / unavailable');
+      }
+      return {
+        ok: true,
+        status: 200,
+        json: async () => caps,
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({ code: 200, data: {} }),
+    };
+  });
+  globalThis.fetch = vi.fn((url, options) => window.fetch(url, options));
+
+  window.eval(authSource);
+  if (token) {
+    window.VideoTranscriptAuthStorage.writeAuthToken(token, { remember: true });
+  }
+  window.eval(appSource);
+
+  if (token && caps && window.checkUploadCapabilities) {
+    await window.checkUploadCapabilities();
+  }
+
+  // Allow microtasks and timers
+  await new Promise((resolve) => setTimeout(resolve, 10));
+}
+
+afterEach(() => {
+  vi.clearAllTimers();
+  globalThis.fetch = originalFetch;
+  dom?.window?.close();
+  vi.restoreAllMocks();
+});
+
+describe('local upload frontend logic', () => {
+  it('correctly constructs metadata with exactly 6 required fields and base64url encoding', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file = new window.File(['fake audio content'], '测试录音.mp3', { type: 'audio/mp3' });
+    const metadata = window.buildUploadMetadata(file, {
+      title: '中文标题测试',
+      sourceUrl: 'https://example.com/source',
+      retention: '30d',
+      processingOptions: {
+        calibrate: true,
+        summarize: true,
+        infer_speaker_names: false,
+        chapters: true,
+      },
+    });
+
+    const expectedKeys = ['filename', 'byte_size', 'title', 'source_url', 'retention', 'processing_options'];
+    expect(Object.keys(metadata).sort()).toEqual(expectedKeys.sort());
+    expect(metadata.filename).toBe('测试录音.mp3');
+    expect(metadata.byte_size).toBe(file.size);
+    expect(metadata.title).toBe('中文标题测试');
+    expect(metadata.source_url).toBe('https://example.com/source');
+    expect(metadata.retention).toBe('30d');
+    expect(metadata.processing_options.infer_speaker_names).toBe(false);
+
+    const encoded = window.encodeUploadMetadata(metadata);
+    expect(encoded).not.toContain('+');
+    expect(encoded).not.toContain('/');
+    expect(encoded).not.toContain('=');
+
+    const decoded = decodeBase64Url(encoded);
+    expect(decoded).toEqual(metadata);
+  });
+
+  it('sets optional title and source_url to null when empty', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file = new window.File(['sample'], 'sample.wav', { type: 'audio/wav' });
+    const metadata = window.buildUploadMetadata(file, {
+      title: '   ',
+      sourceUrl: '',
+      retention: '30d',
+      processingOptions: { calibrate: true, summarize: false, infer_speaker_names: false, chapters: false },
+    });
+
+    expect(metadata.title).toBeNull();
+    expect(metadata.source_url).toBeNull();
+    expect(metadata.processing_options.summarize).toBe(false);
+  });
+
+  it('generates valid Idempotency-Key adhering to epoch_ms-UUID format', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const key = window.generateUploadIdempotencyKey();
+    expect(key).toMatch(/^\d+-[0-9a-fA-F-]+$/);
+  });
+
+  it('switches between URL mode and Upload mode without breaking URL transcription', async () => {
+    await installIndexPage();
+    const { document } = dom.window;
+
+    const uploadTab = document.getElementById('mode-tab-upload');
+    const urlTab = document.getElementById('mode-tab-url');
+    const urlPanel = document.getElementById('url-mode-panel');
+    const uploadPanel = document.getElementById('upload-mode-panel');
+
+    expect(uploadTab).toBeTruthy();
+    expect(urlTab).toBeTruthy();
+
+    // Default is URL mode
+    expect(urlPanel.hidden).toBe(false);
+    expect(uploadPanel.hidden).toBe(true);
+
+    // Switch to upload mode
+    uploadTab.click();
+    expect(urlPanel.hidden).toBe(true);
+    expect(uploadPanel.hidden).toBe(false);
+
+    // Switch back to URL mode
+    urlTab.click();
+    expect(urlPanel.hidden).toBe(false);
+    expect(uploadPanel.hidden).toBe(true);
+  });
+
+  it('disables upload submission and shows notice when capabilities.enabled is false', async () => {
+    await installIndexPage({
+      capabilities: {
+        enabled: false,
+        default_retention: '30d',
+        retention_options: ['30d', 'never'],
+        limits: { max_file_mib: 100, max_media_hours: 2, receive_concurrency: 1, upload_temp_budget_mib: 500 },
+      },
+    });
+    const { window } = dom;
+    const { document } = window;
+
+    document.getElementById('mode-tab-upload').click();
+    const banner = document.getElementById('upload-disabled-banner');
+    expect(banner.hidden).toBe(false);
+
+    const file = new window.File(['abc'], 'clip.mp4', { type: 'video/mp4' });
+    window.selectUploadFile(file);
+
+    const submitBtn = document.getElementById('submit-btn');
+    expect(submitBtn.disabled).toBe(true);
+  });
+
+  it('rejects files exceeding limits.max_file_mib', async () => {
+    await installIndexPage({
+      capabilities: {
+        enabled: true,
+        default_retention: '30d',
+        retention_options: ['30d', 'never'],
+        limits: { max_file_mib: 1, max_media_hours: 1, receive_concurrency: 1, upload_temp_budget_mib: 10 },
+      },
+    });
+    const { window } = dom;
+    const { document } = window;
+    document.getElementById('mode-tab-upload').click();
+
+    // 2 MiB file exceeding 1 MiB limit
+    const largeContent = new Uint8Array(2 * 1024 * 1024);
+    const file = new window.File([largeContent], 'large.mp4', { type: 'video/mp4' });
+
+    window.selectUploadFile(file);
+    const feedback = document.getElementById('upload-input-feedback');
+    expect(feedback.hidden).toBe(false);
+    expect(feedback.textContent).toContain('超出限制');
+
+    const submitBtn = document.getElementById('submit-btn');
+    expect(submitBtn.disabled).toBe(true);
+  });
+
+  it('resets retention to 30d when a new file is chosen', async () => {
+    await installIndexPage();
+    const { window } = dom;
+    const { document } = window;
+    document.getElementById('mode-tab-upload').click();
+
+    const file1 = new window.File(['abc'], 'clip1.mp4', { type: 'video/mp4' });
+    window.selectUploadFile(file1);
+
+    // Explicitly choose never
+    const neverRadio = document.querySelector('input[name="upload-retention"][value="never"]');
+    neverRadio.checked = true;
+    neverRadio.dispatchEvent(new window.Event('change'));
+    expect(window.getUploadRetention()).toBe('never');
+
+    // Select a second file
+    const file2 = new window.File(['def'], 'clip2.mp4', { type: 'video/mp4' });
+    window.selectUploadFile(file2);
+
+    // Must reset to 30d
+    expect(window.getUploadRetention()).toBe('30d');
+    const defaultRadio = document.querySelector('input[name="upload-retention"][value="30d"]');
+    expect(defaultRadio.checked).toBe(true);
+  });
+
+  it('prevents double submission on duplicate clicks for same upload intent', async () => {
+    await installIndexPage();
+    const { window } = dom;
+    const { document } = window;
+    document.getElementById('mode-tab-upload').click();
+
+    const file = new window.File(['hello audio'], 'audio.mp3', { type: 'audio/mp3' });
+    window.selectUploadFile(file);
+
+    let uploadPostCalls = 0;
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+        return { ok: true, status: 200, json: async () => dom.caps };
+      }
+      if (typeof url === 'string' && url.endsWith('/api/uploads') && options.method === 'POST') {
+        uploadPostCalls += 1;
+        // simulate delay
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        return {
+          ok: true,
+          status: 202,
+          json: async () => ({
+            upload_id: 'up-1',
+            state: 'accepted',
+            task_id: 'task-1',
+            view_token: 'upload_view_1',
+            retention: '30d',
+            expires_at: null,
+            share_active: true,
+            error_code: null,
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    const form = document.getElementById('transcribe-form');
+    // Double click / trigger submit twice
+    const p1 = window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+    const p2 = window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    await Promise.all([p1, p2]);
+    expect(uploadPostCalls).toBe(1);
+  });
+
+  it('queries receipt via /api/uploads/by-idempotency-key/{key} on network unknown without resending body', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file = new window.File(['bytes'], 'network.mp4', { type: 'video/mp4' });
+    window.selectUploadFile(file);
+
+    let postCount = 0;
+    let queryKeyCalled = null;
+
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+        return { ok: true, status: 200, json: async () => dom.caps };
+      }
+      if (typeof url === 'string' && url.endsWith('/api/uploads') && options.method === 'POST') {
+        postCount += 1;
+        throw new TypeError('NetworkError: Failed to fetch');
+      }
+      if (typeof url === 'string' && url.includes('/api/uploads/by-idempotency-key/')) {
+        queryKeyCalled = url.split('/by-idempotency-key/')[1];
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            upload_id: 'up-unknown',
+            state: 'accepted',
+            task_id: 'task-unknown',
+            view_token: 'upload_view_unknown',
+            retention: '30d',
+            expires_at: null,
+            share_active: true,
+            error_code: null,
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    await window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    expect(postCount).toBe(1);
+    expect(queryKeyCalled).toBeTruthy();
+    expect(dom.window.document.getElementById('status-content').textContent).toContain('任务已受理');
+  });
+
+  it('binds snapshot to in-flight upload: history uses snapshot name and does not clear replacement file', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file1 = new window.File(['first-content'], 'first-file.wav', { type: 'audio/wav' });
+    window.selectUploadFile(file1);
+
+    let resolvePost;
+    const postPromise = new Promise((resolve) => { resolvePost = resolve; });
+
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+        return { ok: true, status: 200, json: async () => dom.caps };
+      }
+      if (typeof url === 'string' && url.endsWith('/api/uploads') && options.method === 'POST') {
+        await postPromise;
+        return {
+          ok: true,
+          status: 202,
+          json: async () => ({
+            upload_id: 'up-snapshot-1',
+            state: 'accepted',
+            task_id: 'task-snapshot-1',
+            view_token: 'upload_view_snapshot',
+            retention: '30d',
+            expires_at: null,
+            share_active: true,
+            error_code: null,
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    const submitPromise = window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    // While upload is in flight, user selects a replacement file
+    const file2 = new window.File(['second-content'], 'replacement-file.wav', { type: 'audio/wav' });
+    window.selectUploadFile(file2);
+
+    resolvePost();
+    await submitPromise;
+
+    const history = window.TaskHistoryManager.getHistory();
+    expect(history.length).toBe(1);
+    expect(history[0].title).toBe('first-file.wav');
+
+    // Replacement file should NOT be cleared
+    const fileInfo = dom.window.document.getElementById('upload-file-info');
+    expect(fileInfo.hidden).toBe(false);
+    expect(dom.window.document.getElementById('upload-file-name').textContent).toBe('replacement-file.wav');
+  });
+
+  it('handles receiving receipt by showing in-progress status without writing to history or clearing file', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file = new window.File(['content'], 'receiving.wav', { type: 'audio/wav' });
+    window.selectUploadFile(file);
+
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+        return { ok: true, status: 200, json: async () => dom.caps };
+      }
+      if (typeof url === 'string' && url.endsWith('/api/uploads') && options.method === 'POST') {
+        return {
+          ok: true,
+          status: 202,
+          json: async () => ({
+            upload_id: 'up-rec',
+            state: 'receiving',
+            task_id: null,
+            view_token: null,
+            retention: '30d',
+            expires_at: null,
+            share_active: false,
+            error_code: null,
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    await window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    const statusContent = dom.window.document.getElementById('status-content').textContent;
+    expect(statusContent).not.toContain('任务已受理！');
+    expect(statusContent).toContain('receiving');
+
+    // No task in history
+    expect(window.TaskHistoryManager.getHistory().length).toBe(0);
+
+    // File not cleared
+    const fileInfo = dom.window.document.getElementById('upload-file-info');
+    expect(fileInfo.hidden).toBe(false);
+  });
+
+  it('queries receipt on HTTP 500 and prevents second POST body on repeated submission', async () => {
+    await installIndexPage();
+    const { window } = dom;
+
+    const file = new window.File(['content-500'], 'committed-500.wav', { type: 'audio/wav' });
+    window.selectUploadFile(file);
+
+    let postCount = 0;
+    let queryCount = 0;
+
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/capabilities')) {
+        return { ok: true, status: 200, json: async () => dom.caps };
+      }
+      if (typeof url === 'string' && url.endsWith('/api/uploads') && options.method === 'POST') {
+        postCount += 1;
+        return {
+          ok: false,
+          status: 500,
+          json: async () => ({ detail: 'notification exception after commit' }),
+        };
+      }
+      if (typeof url === 'string' && url.includes('/api/uploads/by-idempotency-key/')) {
+        queryCount += 1;
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            upload_id: 'up-500-committed',
+            state: 'accepted',
+            task_id: 'task-500',
+            view_token: 'view_500',
+            retention: '30d',
+            expires_at: null,
+            share_active: true,
+            error_code: null,
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    await window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    expect(postCount).toBe(1);
+    expect(queryCount).toBe(1);
+    expect(dom.window.document.getElementById('status-content').textContent).toContain('任务已受理');
+  });
+
+  it('keeps an unknown upload intent separate from metadata with a colliding colon signature', async () => {
+    await installIndexPage();
+    const { window } = dom;
+    const file = new window.File(['content'], 'test.mp4', { type: 'video/mp4' });
+    window.selectUploadFile(file);
+
+    const postKeys = [];
+    const postBodies = [];
+    const getKeys = [];
+    const metadata = [];
+    window.fetch = vi.fn(async (url, opts = {}) => {
+      if (url.includes('/capabilities')) return { ok: true, status: 200, json: async () => dom.caps };
+      if (url.endsWith('/api/uploads') && opts.method === 'POST') {
+        postKeys.push(opts.headers['Idempotency-Key']);
+        postBodies.push(opts.body);
+        metadata.push(decodeBase64Url(opts.headers['X-Upload-Metadata']));
+        if (postKeys.length === 1) {
+          return { ok: false, status: 500, json: async () => ({ detail: 'server error' }) };
+        }
+        return {
+          ok: true,
+          status: 202,
+          json: async () => ({ upload_id: 'up-collision', state: 'receiving', task_id: null, error_code: null }),
+        };
+      }
+      if (url.includes('/by-idempotency-key/')) {
+        getKeys.push(decodeURIComponent(url.split('/by-idempotency-key/')[1]));
+        return { ok: false, status: 404, json: async () => ({ detail: 'not found' }) };
+      }
+      return { ok: true, status: 200, json: async () => ({}) };
+    });
+
+    const title = window.document.getElementById('upload-title');
+    const source = window.document.getElementById('upload-source-url');
+    title.value = 'T';
+    source.value = 'https://example.com/path:https://example.org';
+    await window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    expect(postKeys.length).toBe(1);
+    expect(getKeys).toEqual([postKeys[0]]);
+    expect(dom.window.document.getElementById('status-content').textContent).toContain('上传状态待核实');
+
+    title.value = 'T:https://example.com/path';
+    source.value = 'https://example.org';
+    await window.submitUploadForm(new window.Event('submit', { cancelable: true }));
+
+    expect(postKeys.length).toBe(2);
+    expect(postKeys[1]).not.toBe(postKeys[0]);
+    expect(postBodies.every((body) => body === file)).toBe(true);
+    expect(getKeys).toEqual([postKeys[0]]);
+    expect(metadata.map(({ title, source_url }) => [title, source_url])).toEqual([
+      ['T', 'https://example.com/path:https://example.org'],
+      ['T:https://example.com/path', 'https://example.org'],
+    ]);
+    expect(dom.window.document.getElementById('status-content').textContent).toContain('文件已接收，等待排队受理');
+    expect(dom.window.document.getElementById('status-content').textContent).not.toContain('任务已受理！');
+    expect(window.TaskHistoryManager.getHistory()).toHaveLength(0);
+  });
+
+
+  it('disables submit button when capabilities are unresolved (fail-closed)', async () => {
+    await installIndexPage({ token: 'test-token', capabilities: null });
+    const { window } = dom;
+    const { document } = window;
+    document.getElementById('mode-tab-upload').click();
+
+    const file = new window.File(['bytes'], 'test.wav', { type: 'audio/wav' });
+    window.selectUploadFile(file);
+
+    const submitBtn = document.getElementById('submit-btn');
+    expect(submitBtn.disabled).toBe(true);
+  });
+
+  it('renders upload history item with retention, share badge, and stop share button', async () => {
+    dom = new JSDOM(historySource, {
+      url: 'https://vta.test/static/history.html',
+      runScripts: 'outside-only',
+    });
+    const { window } = dom;
+    window.matchMedia = vi.fn(() => ({ matches: false, addEventListener: vi.fn(), removeEventListener: vi.fn() }));
+
+    const uploadItem = {
+      task_id: 'task-up-1',
+      video_url: 'https://example.com/source.mp4',
+      request_time: '2026-10-09T12:00:00',
+      api_key_masked: 'test-…-token',
+      view_token: null,
+      upload_view_token: 'active_token_123',
+      title: '测试本地视频',
+      author: null,
+      platform: 'local_upload',
+      status: 'success',
+      source: 'upload',
+      upload_id: 'up-123',
+      filename: 'test.mp4',
+      source_url: 'https://example.com/source.mp4',
+      retention: '30d',
+      expires_at: null,
+      share_active: true,
+      share_inactive_reason: null,
+      revoked_at: null,
+    };
+
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/audit/history')) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            code: 200,
+            data: {
+              items: [uploadItem],
+              total: 1,
+              api_key_masked: 'test-…-token',
+            },
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({ code: 200, data: { webhooks: [], platforms: [], authors: [] } }) };
+    });
+
+    window.eval(authSource);
+    window.VideoTranscriptAuthStorage.writeAuthToken('valid-token', { remember: true });
+    const scriptElements = dom.window.document.querySelectorAll('script');
+    for (const s of scriptElements) {
+      if (!s.src) {
+        window.eval(s.textContent);
+      }
+    }
+
+    await window.loadHistory();
+
+    const listArea = dom.window.document.getElementById('listArea');
+    expect(listArea.textContent).toContain('测试本地视频');
+    expect(listArea.textContent).toContain('30天保留');
+    expect(listArea.textContent).toContain('分享中');
+
+    const stopBtn = listArea.querySelector('.btn-stop-share');
+    expect(stopBtn).toBeTruthy();
+    expect(stopBtn.getAttribute('data-upload-id')).toBe('up-123');
+
+    const row = listArea.querySelector('.task-row');
+    expect(row.getAttribute('data-vt')).toBe('active_token_123');
+  });
+
+  it('stops sharing after confirmation and calls DELETE /api/uploads/{id}/share', async () => {
+    dom = new JSDOM(historySource, {
+      url: 'https://vta.test/static/history.html',
+      runScripts: 'outside-only',
+    });
+    const { window } = dom;
+    window.confirm = vi.fn(() => true);
+
+    let deleteCalled = false;
+    window.fetch = vi.fn(async (url, options = {}) => {
+      if (typeof url === 'string' && url.includes('/api/uploads/up-123/share') && options.method === 'DELETE') {
+        deleteCalled = true;
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ upload_id: 'up-123', share_active: false, revoked_at: '2026-10-09T12:30:00' }),
+        };
+      }
+      if (typeof url === 'string' && url.includes('/api/audit/history')) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            code: 200,
+            data: {
+              items: [],
+              total: 0,
+              api_key_masked: 'test-…-token',
+            },
+          }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({ code: 200, data: { webhooks: [], platforms: [], authors: [] } }) };
+    });
+
+    window.eval(authSource);
+    window.VideoTranscriptAuthStorage.writeAuthToken('valid-token', { remember: true });
+    const scriptElements = dom.window.document.querySelectorAll('script');
+    for (const s of scriptElements) {
+      if (!s.src) {
+        window.eval(s.textContent);
+      }
+    }
+
+    await window.loadHistory();
+    await window.stopShare('up-123');
+    expect(window.confirm).toHaveBeenCalledWith(
+      '确认关闭公开分享？关闭后将停止后续阅读、导出与重新处理，但不立即擦除正文，也不取消在途处理与通知。'
+    );
+    expect(deleteCalled).toBe(true);
+  });
+});
diff --git a/tests/browser_server.py b/tests/browser_server.py
index 84027ec6..36919eb3 100644
--- a/tests/browser_server.py
+++ b/tests/browser_server.py
@@ -4,10 +4,13 @@
 
 import argparse
 import ast
+import base64
+import hashlib
 import json
 import mimetypes
 import sqlite3
 import tempfile
+import uuid
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import parse_qs, urlsplit
@@ -20,6 +23,8 @@
 VIEWS_SOURCE = ROOT / "src" / "video_transcript_api" / "api" / "routes" / "views.py"
 FIXTURE_TOKEN = "browser-fixture-token"
 VIEW_TOKEN = "browser-fixture-view"
+UPLOAD_VIEW_TOKEN = "upload_browser_fixture_view_1"
+UPLOAD_ID = "browser-fixture-upload-1"
 
 
 def read_home_page() -> str:
@@ -52,12 +57,21 @@ def initialize_database(db_path: Path) -> None:
         db.execute(
             "CREATE TABLE submissions (payload TEXT NOT NULL)"
         )
+        db.execute(
+            "CREATE TABLE uploads ("
+            "upload_id TEXT PRIMARY KEY, idempotency_key TEXT, task_id TEXT, "
+            "view_token TEXT, filename TEXT, byte_size INTEGER, title TEXT, "
+            "source_url TEXT, retention TEXT, processing_options TEXT, "
+            "share_active INTEGER, revoked_at TEXT, created_at TEXT, state TEXT, "
+            "error_code TEXT, raw_bytes_sha256 TEXT, actual_byte_length INTEGER)"
+        )
         seed_database(db)
 
 
 def seed_database(db: sqlite3.Connection) -> None:
     db.execute("DELETE FROM history")
     db.execute("DELETE FROM submissions")
+    db.execute("DELETE FROM uploads")
     db.execute(
         "INSERT INTO history VALUES (?, ?, ?, ?, ?)",
         (
@@ -68,6 +82,24 @@ def seed_database(db: sqlite3.Connection) -> None:
             "https://www.youtube.com/watch?v=fixture",
         ),
     )
+    db.execute(
+        "INSERT INTO uploads VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, NULL, ?, 'accepted', NULL, ?, ?)",
+        (
+            UPLOAD_ID,
+            "seeded-idempotency-key",
+            "task-fixture-upload-1",
+            UPLOAD_VIEW_TOKEN,
+            "fixture-sample.mp4",
+            1024,
+            "浏览器本地上传样本",
+            "https://example.com/source-ref",
+            "30d",
+            json.dumps({"calibrate": True, "summarize": True, "infer_speaker_names": False, "chapters": True}),
+            "2026-10-08T12:00:00",
+            hashlib.sha256(b"fixture-seed-bytes").hexdigest(),
+            18,
+        ),
+    )
 
 
 class BrowserFixtureHandler(BaseHTTPRequestHandler):
@@ -129,7 +161,14 @@ def do_GET(self) -> None:
             self.send_bytes(404, b"not found", "text/plain; charset=utf-8")
             return
         if path.startswith("/view/"):
+            view_token = path.removeprefix("/view/")
             query = parse_qs(parsed.query)
+            if view_token.startswith("upload_"):
+                with sqlite3.connect(self.db_path) as db:
+                    row = db.execute("SELECT share_active FROM uploads WHERE view_token = ?", (view_token,)).fetchone()
+                if not row or not row[0]:
+                    self.send_bytes(404, b"<!doctype html><html><body><h1>404</h1><p>view_token invalid or expired</p></body></html>", "text/html; charset=utf-8")
+                    return
             if "raw" in query:
                 self.send_bytes(
                     200,
@@ -151,7 +190,77 @@ def do_GET(self) -> None:
                 status = "failed"
             elif path.endswith("cleaned"):
                 status = "file_cleaned"
-            self.serve_view(status)
+            self.serve_view(status, view_token)
+            return
+        if path == "/api/uploads/capabilities":
+            if not self.authorized():
+                self.send_json(401, {"code": 401, "message": "unauthorized"})
+                return
+            self.send_json(
+                200,
+                {
+                    "enabled": True,
+                    "default_retention": "30d",
+                    "retention_options": ["30d", "never"],
+                    "limits": {
+                        "max_file_mib": 500,
+                        "max_media_hours": 3,
+                        "receive_concurrency": 2,
+                        "upload_temp_budget_mib": 2048,
+                    },
+                },
+            )
+            return
+        if path.startswith("/api/uploads/by-idempotency-key/"):
+            if not self.authorized():
+                self.send_json(401, {"code": 401, "message": "unauthorized"})
+                return
+            key = path.removeprefix("/api/uploads/by-idempotency-key/")
+            with sqlite3.connect(self.db_path) as db:
+                row = db.execute(
+                    "SELECT upload_id, state, task_id, view_token, retention, share_active, error_code "
+                    "FROM uploads WHERE idempotency_key = ?",
+                    (key,),
+                ).fetchone()
+            if not row:
+                self.send_json(404, {"detail": "上传回执不存在"})
+                return
+            self.send_json(
+                200,
+                {
+                    "upload_id": row[0],
+                    "state": row[1],
+                    "task_id": row[2],
+                    "view_token": row[3] if row[5] else None,
+                    "retention": row[4],
+                    "expires_at": None,
+                    "share_active": bool(row[5]),
+                    "error_code": row[6],
+                },
+            )
+            return
+        if path == "/__e2e__/last-upload":
+            with sqlite3.connect(self.db_path) as db:
+                row = db.execute(
+                    "SELECT upload_id, idempotency_key, filename, byte_size, title, source_url, "
+                    "retention, processing_options, raw_bytes_sha256, actual_byte_length "
+                    "FROM uploads ORDER BY ROWID DESC LIMIT 1"
+                ).fetchone()
+            if not row:
+                self.send_json(404, {"error": "no uploads"})
+                return
+            self.send_json(200, {
+                "upload_id": row[0],
+                "idempotency_key": row[1],
+                "filename": row[2],
+                "byte_size": row[3],
+                "title": row[4],
+                "source_url": row[5],
+                "retention": row[6],
+                "processing_options": json.loads(row[7]),
+                "raw_bytes_sha256": row[8],
+                "actual_byte_length": row[9],
+            })
             return
         if path == "/api/audit/filter-options":
             if not self.authorized():
@@ -174,24 +283,62 @@ def do_GET(self) -> None:
             if not self.authorized():
                 self.send_json(401, {"code": 401, "message": "unauthorized"})
                 return
+            query = parse_qs(parsed.query)
+            source = query.get("source", [None])[0]
             with sqlite3.connect(self.db_path) as db:
-                rows = db.execute(
-                    "SELECT view_token, title, request_time, status, video_url FROM history "
-                    "ORDER BY request_time DESC"
-                ).fetchall()
-            items = [
-                {
-                    "view_token": row[0],
-                    "title": row[1],
-                    "request_time": row[2],
-                    "status": row[3],
-                    "video_url": row[4],
-                    "author": "浏览器夹具频道",
-                    "platform": "youtube",
-                    "wechat_webhook": None,
-                }
-                for row in rows
-            ]
+                if source == "upload":
+                    rows = db.execute(
+                        "SELECT upload_id, task_id, view_token, filename, title, source_url, "
+                        "retention, share_active, revoked_at, created_at, state "
+                        "FROM uploads ORDER BY created_at DESC"
+                    ).fetchall()
+                    items = [
+                        {
+                            "task_id": row[1],
+                            "video_url": row[5] or "",
+                            "wechat_webhook": None,
+                            "request_time": row[9],
+                            "api_key_masked": "browser-…-token",
+                            "view_token": None,
+                            "upload_view_token": row[2] if row[7] else None,
+                            "title": row[4] or row[3] or "本地上传",
+                            "author": None,
+                            "platform": "local_upload",
+                            "status": "success",
+                            "calibration_status": None,
+                            "summary_status": None,
+                            "chapters_status": None,
+                            "content_expired": not bool(row[7]),
+                            "source": "upload",
+                            "upload_id": row[0],
+                            "filename": row[3],
+                            "source_url": row[5],
+                            "retention": row[6],
+                            "expires_at": None,
+                            "share_active": bool(row[7]),
+                            "share_inactive_reason": "revoked" if not row[7] else None,
+                            "revoked_at": row[8],
+                        }
+                        for row in rows
+                    ]
+                else:
+                    rows = db.execute(
+                        "SELECT view_token, title, request_time, status, video_url FROM history "
+                        "ORDER BY request_time DESC"
+                    ).fetchall()
+                    items = [
+                        {
+                            "view_token": row[0],
+                            "title": row[1],
+                            "request_time": row[2],
+                            "status": row[3],
+                            "video_url": row[4],
+                            "author": "浏览器夹具频道",
+                            "platform": "youtube",
+                            "wechat_webhook": None,
+                        }
+                        for row in rows
+                    ]
             self.send_json(
                 200,
                 {
@@ -239,6 +386,102 @@ def do_POST(self) -> None:
                     "data": {"task_id": "browser-fixture-task", "view_token": VIEW_TOKEN},
                 },
             )
+        if path == "/api/uploads":
+            if not self.authorized():
+                self.send_json(401, {"code": 401, "message": "unauthorized"})
+                return
+            idempotency_key = self.headers.get("Idempotency-Key")
+            metadata_header = self.headers.get("X-Upload-Metadata")
+            if not idempotency_key or not metadata_header:
+                self.send_json(400, {"code": 400, "message": "missing headers"})
+                return
+            encoded = metadata_header.rstrip("=")
+            raw_meta = base64.b64decode(encoded + "=" * (-len(encoded) % 4), altchars=b"-_")
+            metadata = json.loads(raw_meta.decode("utf-8"))
+            content_length = int(self.headers.get("Content-Length", "0"))
+            body_bytes = self.rfile.read(content_length) if content_length > 0 else b""
+            with sqlite3.connect(self.db_path) as db:
+                existing = db.execute(
+                    "SELECT upload_id, task_id, view_token, retention, share_active FROM uploads WHERE idempotency_key = ?",
+                    (idempotency_key,),
+                ).fetchone()
+                if existing:
+                    self.send_json(
+                        202,
+                        {
+                            "upload_id": existing[0],
+                            "state": "accepted",
+                            "task_id": existing[1],
+                            "view_token": existing[2],
+                            "retention": existing[3],
+                            "expires_at": None,
+                            "share_active": bool(existing[4]),
+                            "error_code": None,
+                        },
+                    )
+                    return
+                upload_id = f"upload-{uuid.uuid4().hex[:12]}"
+                task_id = f"task-{upload_id}"
+                view_token = f"upload_view_{upload_id}"
+                db.execute(
+                    "INSERT INTO uploads (upload_id, idempotency_key, task_id, view_token, "
+                    "filename, byte_size, title, source_url, retention, processing_options, "
+                    "share_active, revoked_at, created_at, state, error_code, raw_bytes_sha256, actual_byte_length) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, NULL, ?, 'accepted', NULL, ?, ?)",
+                    (
+                        upload_id,
+                        idempotency_key,
+                        task_id,
+                        view_token,
+                        metadata.get("filename"),
+                        metadata.get("byte_size"),
+                        metadata.get("title"),
+                        metadata.get("source_url"),
+                        metadata.get("retention"),
+                        json.dumps(metadata.get("processing_options")),
+                        "2026-10-09T12:00:00",
+                        hashlib.sha256(body_bytes).hexdigest(),
+                        len(body_bytes),
+                    ),
+                )
+            self.send_json(
+                202,
+                {
+                    "upload_id": upload_id,
+                    "state": "accepted",
+                    "task_id": task_id,
+                    "view_token": view_token,
+                    "retention": metadata.get("retention", "30d"),
+                    "expires_at": None,
+                    "share_active": True,
+                    "error_code": None,
+                },
+            )
+            return
+        self.send_bytes(404, b"not found", "text/plain; charset=utf-8")
+
+    def do_DELETE(self) -> None:
+        parsed = urlsplit(self.path)
+        path = parsed.path
+        if not self.authorized():
+            self.send_json(401, {"code": 401, "message": "unauthorized"})
+            return
+        if path.startswith("/api/uploads/") and path.endswith("/share"):
+            upload_id = path.removeprefix("/api/uploads/").removesuffix("/share")
+            revoked_at = "2026-10-09T12:00:00"
+            with sqlite3.connect(self.db_path) as db:
+                db.execute(
+                    "UPDATE uploads SET share_active = 0, revoked_at = ? WHERE upload_id = ?",
+                    (revoked_at, upload_id),
+                )
+            self.send_json(
+                200,
+                {
+                    "upload_id": upload_id,
+                    "share_active": False,
+                    "revoked_at": revoked_at,
+                },
+            )
             return
         self.send_bytes(404, b"not found", "text/plain; charset=utf-8")
 
@@ -248,7 +491,7 @@ def serve_static(self, path: Path) -> None:
             content_type += "; charset=utf-8"
         self.send_bytes(200, path.read_bytes(), content_type)
 
-    def serve_view(self, status: str) -> None:
+    def serve_view(self, status: str, view_token: str = VIEW_TOKEN) -> None:
         template_name = {
             "processing": "processing.html",
             "failed": "error.html",
@@ -256,9 +499,9 @@ def serve_view(self, status: str) -> None:
         }.get(status, "transcript.html")
         context: dict[str, object] = {
             "request": None,
-            "view_token": VIEW_TOKEN,
+            "view_token": view_token,
             "title": "浏览器回归示例",
-            "platform": "YouTube",
+            "platform": "local_upload" if view_token.startswith("upload_") else "YouTube",
             "url": "https://www.youtube.com/watch?v=fixture",
             "status": status,
             "created_at": "2026-10-08T12:00:00",
diff --git a/tests/integration/test_local_upload_lifecycle.py b/tests/integration/test_local_upload_lifecycle.py
index 3e5ba3b0..fef835a5 100644
--- a/tests/integration/test_local_upload_lifecycle.py
+++ b/tests/integration/test_local_upload_lifecycle.py
@@ -557,11 +557,25 @@ def test_upload_history_filters_owner_before_page_limit(lifecycle_client):
     assert data["total"] == 2
     assert [item["upload_id"] for item in data["items"]] == [newer["upload_id"]]
     assert data["items"][0]["title"] == "Alice newer"
+    assert data["items"][0]["view_token"] is None
+    assert data["items"][0]["upload_view_token"] == newer["view_token"]
+    assert data["items"][0]["share_active"] is True
+    root_task = cache.get_task_by_id(newer["root_task_id"])
+    assert root_task["view_token"] == ""
+
     mismatched_platform = client.get(
         "/api/audit/history?source=upload&platform=youtube&status=all"
     )
     assert mismatched_platform.json()["data"]["total"] == 0
 
+    cache.revoke_local_upload(newer["upload_id"])
+    revoked_resp = client.get("/api/audit/history?source=upload&status=all&limit=1&offset=0")
+    revoked_item = revoked_resp.json()["data"]["items"][0]
+    assert revoked_item["share_active"] is False
+    assert revoked_item["upload_view_token"] is None
+    assert revoked_item["view_token"] is None
+    assert revoked_item["share_inactive_reason"] == "revoked"
+
 
 def test_dispatcher_uses_real_transcriber_then_cleans_owned_media_before_llm(
     tmp_path, monkeypatch,