From 11fb3d6c3f2d67b6553d48e2e02ff6e0415afef9 Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 20:53:12 +0800
Subject: [PATCH 01/10] fix(agent): prevent duplicate execute for same plan via
 idempotency key check

Add idempotency_key-based guard in ExecuteService.enqueue_execute to reject 409 when a execute BackgroundJob already exists for the same planJobId. Update test to mock the second scalar return and add test_execute_rejects_repeat_when_existing_execute_job_exists.
---
 .../services/agent/execute_service.py         | 21 +++++++
 app/tests/test_agent_plan_execute_runtime.py  | 58 ++++++++++++++++++-
 2 files changed, 78 insertions(+), 1 deletion(-)

diff --git a/app/src/fileflash/services/agent/execute_service.py b/app/src/fileflash/services/agent/execute_service.py
index b06ace5..e3f7c41 100644
--- a/app/src/fileflash/services/agent/execute_service.py
+++ b/app/src/fileflash/services/agent/execute_service.py
@@ -69,10 +69,31 @@ async def enqueue_execute(
                 data={"highRiskActions": high_risk_actions},
             )
 
+        idempotency_key = f"agent.execute:{plan_job_id}"
+        existing_execute = await self.db.scalar(
+            select(BackgroundJob).where(
+                and_(
+                    BackgroundJob.task_type == "agent.execute",
+                    BackgroundJob.idempotency_key == idempotency_key,
+                )
+            )
+        )
+        if existing_execute is not None:
+            raise ApiError(
+                status_code=409,
+                code=409,
+                message="Plan has already been executed",
+                data={
+                    "jobId": str(existing_execute.job_id),
+                    "status": str(existing_execute.status),
+                },
+            )
+
         job = await self.jobs.enqueue(
             self.db,
             task_type="agent.execute",
             payload=payload.model_dump(by_alias=True, mode="json"),
+            idempotency_key=idempotency_key,
             requested_by=user_id,
             max_attempts=1,
             priority=100,
diff --git a/app/tests/test_agent_plan_execute_runtime.py b/app/tests/test_agent_plan_execute_runtime.py
index a07d5f7..62ba503 100644
--- a/app/tests/test_agent_plan_execute_runtime.py
+++ b/app/tests/test_agent_plan_execute_runtime.py
@@ -272,7 +272,7 @@ async def test_execute_rejects_high_risk_plan_without_confirmation():
 @pytest.mark.asyncio
 async def test_execute_enqueue_serializes_approval_datetime_as_json_string():
     db = DummyDb()
-    db.scalar.return_value = BackgroundJob(
+    plan_job = BackgroundJob(
         job_id=99,
         task_type="agent.plan",
         status="succeeded",
@@ -283,6 +283,7 @@ async def test_execute_enqueue_serializes_approval_datetime_as_json_string():
         created_at=datetime.now(UTC),
         updated_at=datetime.now(UTC),
     )
+    db.scalar = AsyncMock(side_effect=[plan_job, None])
     plans = AgentPlanRepository(db)  # type: ignore[arg-type]
     plans.get_for_execute_binding = AsyncMock(return_value=SimpleNamespace(proposed_actions_json=[]))
     jobs = FakeJobs()
@@ -306,6 +307,61 @@ async def test_execute_enqueue_serializes_approval_datetime_as_json_string():
     approval_payload = jobs.kwargs["payload"]["approval"]
     assert isinstance(approval_payload["confirmedAt"], str)
     assert approval_payload["confirmedAt"] == "2026-05-25T10:00:00Z"
+    assert jobs.kwargs["idempotency_key"] == "agent.execute:99"
+
+
+@pytest.mark.asyncio
+async def test_execute_rejects_repeat_when_existing_execute_job_exists():
+    db = DummyDb()
+    plan_job = BackgroundJob(
+        job_id=99,
+        task_type="agent.plan",
+        status="succeeded",
+        payload={},
+        result={},
+        requested_by=7,
+        scheduled_at=datetime.now(UTC),
+        created_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+    )
+    existing_execute = BackgroundJob(
+        job_id=200,
+        task_type="agent.execute",
+        status="running",
+        payload={},
+        result={},
+        requested_by=7,
+        idempotency_key="agent.execute:99",
+        scheduled_at=datetime.now(UTC),
+        created_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+    )
+    db.scalar = AsyncMock(side_effect=[plan_job, existing_execute])
+    plans = AgentPlanRepository(db)  # type: ignore[arg-type]
+    plans.get_for_execute_binding = AsyncMock(return_value=SimpleNamespace(proposed_actions_json=[]))
+    jobs = FakeJobs()
+    service = ExecuteService(
+        db=db,
+        settings=settings(),
+        jobs=jobs,  # type: ignore[arg-type]
+        plans=plans,
+        work_sessions=AgentWorkSessionRepository(db),  # type: ignore[arg-type]
+    )
+    payload = ExecuteAgentRequest.model_validate(
+        {
+            "planJobId": "99",
+            "planHash": "sha256:test",
+            "approval": {"confirmedBy": "7", "confirmedAt": "2026-05-25T10:00:00Z"},
+        }
+    )
+
+    with pytest.raises(ApiError) as exc:
+        await service.enqueue_execute(user_id=7, payload=payload)
+
+    assert exc.value.status_code == 409
+    assert "already been executed" in exc.value.message.lower() or "already" in exc.value.message.lower()
+    assert exc.value.data["jobId"] == "200"
+    assert jobs.kwargs == {}
 
 
 @pytest.mark.asyncio

From b8b827d98c329009d64707974df64745a570d35a Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 20:53:16 +0800
Subject: [PATCH 02/10] feat(web): add viewport-aware smart placement to Select
 dropdown

compute whether to render menu above or below trigger based on available space. Recalculate on resize/scroll. Add specs for both up and down placements.
---
 web/src/components/molecules/Select.spec.ts | 46 +++++++++++++++-
 web/src/components/molecules/Select.vue     | 61 ++++++++++++++++++---
 2 files changed, 99 insertions(+), 8 deletions(-)

diff --git a/web/src/components/molecules/Select.spec.ts b/web/src/components/molecules/Select.spec.ts
index 04af91b..48aa7c0 100644
--- a/web/src/components/molecules/Select.spec.ts
+++ b/web/src/components/molecules/Select.spec.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from 'vitest';
+import { describe, it, expect, afterEach, vi } from 'vitest';
 import { mount } from '../../test/mount';
 import Select from './Select.vue';
 
@@ -50,4 +50,48 @@ describe('molecules/Select', () => {
     await w.find('.ff-select').trigger('keydown', { key: 'Escape' });
     expect(w.find('.ff-select__menu').exists()).toBe(false);
   });
+
+  it('opens upward when there is not enough room below the trigger', async () => {
+    const originalInner = window.innerHeight;
+    Object.defineProperty(window, 'innerHeight', { value: 600, configurable: true });
+    const w = mount(Select, {
+      props: { modelValue: 'a', options: OPTS },
+      attachTo: document.body,
+    });
+    const root = w.find('.ff-select').element as HTMLElement;
+    vi.spyOn(root, 'getBoundingClientRect').mockReturnValue({
+      x: 0, y: 580, top: 580, bottom: 596,
+      left: 0, right: 120, width: 120, height: 16,
+      toJSON: () => undefined,
+    } as DOMRect);
+
+    await w.find('.ff-select__trigger').trigger('click');
+    const menu = w.find('.ff-select__menu');
+    expect(menu.exists()).toBe(true);
+    expect(menu.classes()).toContain('ff-select__menu--up');
+
+    Object.defineProperty(window, 'innerHeight', { value: originalInner, configurable: true });
+  });
+
+  it('opens downward when there is room below the trigger', async () => {
+    const originalInner = window.innerHeight;
+    Object.defineProperty(window, 'innerHeight', { value: 800, configurable: true });
+    const w = mount(Select, {
+      props: { modelValue: 'a', options: OPTS },
+      attachTo: document.body,
+    });
+    const root = w.find('.ff-select').element as HTMLElement;
+    vi.spyOn(root, 'getBoundingClientRect').mockReturnValue({
+      x: 0, y: 100, top: 100, bottom: 132,
+      left: 0, right: 120, width: 120, height: 32,
+      toJSON: () => undefined,
+    } as DOMRect);
+
+    await w.find('.ff-select__trigger').trigger('click');
+    const menu = w.find('.ff-select__menu');
+    expect(menu.exists()).toBe(true);
+    expect(menu.classes()).toContain('ff-select__menu--down');
+
+    Object.defineProperty(window, 'innerHeight', { value: originalInner, configurable: true });
+  });
 });
diff --git a/web/src/components/molecules/Select.vue b/web/src/components/molecules/Select.vue
index a0a65ad..28330ad 100644
--- a/web/src/components/molecules/Select.vue
+++ b/web/src/components/molecules/Select.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
+import { computed, nextTick, onBeforeUnmount, onMounted, ref } from 'vue';
 import Icon from '../atoms/Icon.vue';
 
 interface SelectOption {
@@ -23,19 +23,45 @@ const emit = defineEmits<{ 'update:modelValue': [value: string | number] }>();
 const rootEl = ref<HTMLElement | null>(null);
 const open = ref(false);
 const activeIndex = ref(-1);
+const placement = ref<'down' | 'up'>('down');
+const menuMaxHeight = ref<number>(240);
 
 const selectedLabel = computed(() => {
   const m = props.options.find((o) => o.value === props.modelValue);
   return m?.label ?? '';
 });
 
+const MENU_HARD_CAP = 240;
+const MENU_MIN_HEIGHT = 80;
+const ROW_HEIGHT = 24;
+const MENU_GAP = 8;
+
+const updatePlacement = () => {
+  if (!rootEl.value || typeof window === 'undefined') return;
+  const rect = rootEl.value.getBoundingClientRect();
+  const vh = window.innerHeight || document.documentElement.clientHeight;
+  const spaceBelow = Math.max(0, vh - rect.bottom - MENU_GAP);
+  const spaceAbove = Math.max(0, rect.top - MENU_GAP);
+  const naturalHeight = Math.min(MENU_HARD_CAP, props.options.length * ROW_HEIGHT + 8);
+
+  if (spaceBelow >= naturalHeight || spaceBelow >= spaceAbove) {
+    placement.value = 'down';
+    menuMaxHeight.value = Math.max(MENU_MIN_HEIGHT, Math.min(MENU_HARD_CAP, spaceBelow));
+  } else {
+    placement.value = 'up';
+    menuMaxHeight.value = Math.max(MENU_MIN_HEIGHT, Math.min(MENU_HARD_CAP, spaceAbove));
+  }
+};
+
 const toggle = () => {
   if (props.disabled) return;
-  open.value = !open.value;
-  if (open.value) {
+  const next = !open.value;
+  if (next) {
+    updatePlacement();
     const i = props.options.findIndex((o) => o.value === props.modelValue);
     activeIndex.value = i >= 0 ? i : 0;
   }
+  open.value = next;
 };
 
 const pick = (value: string | number) => {
@@ -71,8 +97,22 @@ const onDocClick = (e: MouseEvent) => {
   if (!rootEl.value.contains(e.target as Node)) open.value = false;
 };
 
-onMounted(() => document.addEventListener('mousedown', onDocClick));
-onBeforeUnmount(() => document.removeEventListener('mousedown', onDocClick));
+const onViewportChange = () => {
+  if (!open.value) return;
+  // Defer to next frame to let layout settle before remeasure.
+  nextTick(updatePlacement);
+};
+
+onMounted(() => {
+  document.addEventListener('mousedown', onDocClick);
+  window.addEventListener('resize', onViewportChange);
+  window.addEventListener('scroll', onViewportChange, true);
+});
+onBeforeUnmount(() => {
+  document.removeEventListener('mousedown', onDocClick);
+  window.removeEventListener('resize', onViewportChange);
+  window.removeEventListener('scroll', onViewportChange, true);
+});
 </script>
 
 <template>
@@ -94,7 +134,13 @@ onBeforeUnmount(() => document.removeEventListener('mousedown', onDocClick));
       </span>
       <Icon :name="open ? 'chevronUp' : 'chevronDown'" :size="size === 'sm' ? 12 : 14" />
     </button>
-    <ul v-if="open" class="ff-select__menu" role="listbox">
+    <ul
+      v-if="open"
+      class="ff-select__menu"
+      :class="`ff-select__menu--${placement}`"
+      :style="{ maxHeight: `${menuMaxHeight}px` }"
+      role="listbox"
+    >
       <li
         v-for="(opt, i) in options"
         :key="opt.value"
@@ -149,7 +195,6 @@ onBeforeUnmount(() => document.removeEventListener('mousedown', onDocClick));
 
 .ff-select__menu {
   position: absolute; left: 0; right: 0;
-  top: calc(100% + 2px);
   background: var(--surface-raised);
   border: 1px solid var(--border-default);
   border-radius: 0;
@@ -160,6 +205,8 @@ onBeforeUnmount(() => document.removeEventListener('mousedown', onDocClick));
   max-height: 240px;
   overflow: auto;
 }
+.ff-select__menu--down { top: calc(100% + 2px); }
+.ff-select__menu--up { bottom: calc(100% + 2px); }
 .ff-select__option {
   padding: var(--sp-xs) var(--sp-sm);
   color: var(--text-secondary);

From be17bd90d1491c1baf0d485e7dcd61125ec04262 Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 20:53:21 +0800
Subject: [PATCH 03/10] feat(web): hide Execute button on TurnEntry once
 executeJobId is assigned

Add guard to canExecute computed so the Execute button disappears after the turn already has an executeJobId, preventing duplicate action trigger.
---
 web/src/components/organisms/agent/TurnEntry.spec.ts | 12 ++++++++++++
 web/src/components/organisms/agent/TurnEntry.vue     |  3 ++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/web/src/components/organisms/agent/TurnEntry.spec.ts b/web/src/components/organisms/agent/TurnEntry.spec.ts
index f6794bd..f9bdb37 100644
--- a/web/src/components/organisms/agent/TurnEntry.spec.ts
+++ b/web/src/components/organisms/agent/TurnEntry.spec.ts
@@ -47,6 +47,18 @@ describe('organisms/agent/TurnEntry', () => {
     expect(buttons.some((label) => /execute|执行/i.test(label))).toBe(false);
   });
 
+  it('hides Execute button once executeJobId is assigned', () => {
+    const w = mount(TurnEntry, {
+      props: {
+        turn: baseTurn({ executeJobId: 'exec-1' }),
+        policy: 'confirm',
+        focused: false,
+      },
+    });
+    const buttons = w.findAll('button').map((b) => b.text());
+    expect(buttons.some((label) => /execute|执行/i.test(label))).toBe(false);
+  });
+
   it('Cancel button present when running, clicking emits cancel', async () => {
     const w = mount(TurnEntry, {
       props: { turn: baseTurn({ status: 'running' }), policy: 'confirm', focused: false },
diff --git a/web/src/components/organisms/agent/TurnEntry.vue b/web/src/components/organisms/agent/TurnEntry.vue
index 04bc1fc..885533d 100644
--- a/web/src/components/organisms/agent/TurnEntry.vue
+++ b/web/src/components/organisms/agent/TurnEntry.vue
@@ -23,7 +23,8 @@ const canExecute = computed(
   () =>
     Boolean(props.turn.agent.planHash) &&
     props.turn.agent.status === 'succeeded' &&
-    props.policy !== 'planOnly',
+    props.policy !== 'planOnly' &&
+    !props.turn.agent.executeJobId,
 );
 
 const isActive = computed(

From c48bb1630555596c9a564b3234544ecf6cbf654c Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 20:53:25 +0800
Subject: [PATCH 04/10] fix(web): add no-op early-return guards to runExecute

Guard against calling executeAgentPlan when executeJobId is already set or the turn status is not 'succeeded'. Add corresponding specs.
---
 web/src/composables/useAgentSession.spec.ts | 56 +++++++++++++++++++++
 web/src/composables/useAgentSession.ts      |  2 +
 2 files changed, 58 insertions(+)

diff --git a/web/src/composables/useAgentSession.spec.ts b/web/src/composables/useAgentSession.spec.ts
index 44fd916..aeaf117 100644
--- a/web/src/composables/useAgentSession.spec.ts
+++ b/web/src/composables/useAgentSession.spec.ts
@@ -135,6 +135,62 @@ describe('useAgentSession', () => {
     expect(agentApi.planAgentTask).toHaveBeenCalled();
   });
 
+  it('runExecute is a no-op when executeJobId is already set', async () => {
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'succeeded',
+      result: planResult,
+    } as any);
+    vi.mocked(agentApi.executeAgentPlan).mockResolvedValue({
+      jobId: 'job-2',
+      status: 'pending',
+      taskType: 'agent.execute',
+    });
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, runExecute, activeTurns } = useAgentSession();
+    taskInput.value = 'hello';
+    await sendMessage();
+
+    const turn = activeTurns.value[0];
+    turn.agent.executeJobId = 'already-exec-1';
+    await runExecute(turn.agent);
+    expect(agentApi.executeAgentPlan).not.toHaveBeenCalled();
+  });
+
+  it('runExecute is a no-op when the turn is not in succeeded state', async () => {
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'succeeded',
+      result: planResult,
+    } as any);
+    vi.mocked(agentApi.executeAgentPlan).mockResolvedValue({
+      jobId: 'job-2',
+      status: 'pending',
+      taskType: 'agent.execute',
+    });
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, runExecute, activeTurns } = useAgentSession();
+    taskInput.value = 'hello';
+    await sendMessage();
+
+    const turn = activeTurns.value[0];
+    turn.agent.status = 'running';
+    await runExecute(turn.agent);
+    expect(agentApi.executeAgentPlan).not.toHaveBeenCalled();
+  });
+
   it('runExecute calls executeAgentPlan and polls to succeeded', async () => {
     vi.mocked(agentApi.planAgentTask).mockResolvedValue({
       jobId: 'job-1',
diff --git a/web/src/composables/useAgentSession.ts b/web/src/composables/useAgentSession.ts
index 7719998..80964fd 100644
--- a/web/src/composables/useAgentSession.ts
+++ b/web/src/composables/useAgentSession.ts
@@ -382,6 +382,8 @@ export default function useAgentSession() {
 
   async function runExecute(msg: ChatMessage): Promise<void> {
     if (!msg.planResult || !msg.planHash) return;
+    if (msg.executeJobId) return;
+    if (msg.status !== 'succeeded') return;
     const highRisk = msg.planResult.proposedActions.some(
       (action) => action.riskLevel === 'high' || action.requiresConfirmation,
     );

From 0c9148761185a4c6cbafcee4fecb5933fe6ade1e Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:14:39 +0800
Subject: [PATCH 05/10] feat(agent): add drive.countFiles tool with
 categorization and execution answer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add drive.countFiles tool for counting files by folder and category (video/audio/image/document/archive)
- Build natural-language execution answer (e.g. '你上传了 3 部电影')
- Retry LLM plan without reasoning on empty/invalid output with safe read-only fallback
- Simplify cancel route to mark any running job as canceled immediately
- Skip job result/error persistence when worker detects cancellation
- Add answer field to AgentExecutionResult schema
---
 app/src/fileflash/agents/harness/router.py    | 213 ++++++++++++++++++
 .../agents/runtime/execute_runner.py          |  36 +++
 app/src/fileflash/agents/runtime/llm.py       | 113 ++++++++--
 .../fileflash/agents/runtime/plan_runner.py   | 108 ++++++++-
 app/src/fileflash/agents/worker.py            |   4 +
 app/src/fileflash/routers/agent.py            |   7 +-
 app/src/fileflash/schemas/agent.py            |   1 +
 7 files changed, 453 insertions(+), 29 deletions(-)

diff --git a/app/src/fileflash/agents/harness/router.py b/app/src/fileflash/agents/harness/router.py
index 95318ed..3c46f39 100644
--- a/app/src/fileflash/agents/harness/router.py
+++ b/app/src/fileflash/agents/harness/router.py
@@ -3,9 +3,13 @@
 from dataclasses import dataclass
 from typing import Any
 
+from sqlalchemy import and_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ...core.errors import ApiError
+from ...core.mime import resolve_file_mime_type
+from ...models import File, Folder
+from ...models.enums import FileStatus, FolderStatus, FolderType
 from ...schemas.file import (
     CreateFolderRequest,
     GetFolderContentsQuery,
@@ -54,6 +58,9 @@ async def dispatch(self, call: ToolCall) -> dict[str, Any]:
                 )
             return result.model_dump(by_alias=True, mode="json")
 
+        if tool == "drive.countFiles":
+            return await self._count_files(args)
+
         if tool == "drive.createFolder":
             name = _required_text(args, "name", "folderName")
             parent_id = _first_value(args, "parentFolderId", "targetParentId", "folderId") or "root"
@@ -126,6 +133,85 @@ async def dispatch(self, call: ToolCall) -> dict[str, Any]:
 
         raise ApiError(status_code=400, code=400, message=f"Unsupported agent tool: {tool}")
 
+    async def _count_files(self, args: dict[str, Any]) -> dict[str, Any]:
+        folder_id = str(_first_value(args, "folderId", "parentFolderId") or "root")
+        recursive = _bool_arg(args.get("recursive"), default=True)
+        category = _normalize_category(args.get("category"))
+        search = str(args.get("search") or "").strip().lower()
+        root_folder_id = await _resolve_folder_id(
+            self.db,
+            user_id=self.user_id,
+            folder_id=folder_id,
+        )
+        folder_ids = (
+            await _active_descendant_folder_ids(
+                self.db,
+                user_id=self.user_id,
+                root_folder_id=root_folder_id,
+            )
+            if recursive
+            else [root_folder_id]
+        )
+
+        statement = select(
+            File.file_id,
+            File.file_name,
+            File.file_size,
+            File.mime_type,
+            File.file_ext,
+            File.folder_id,
+        ).where(
+            and_(
+                File.owner_id == self.user_id,
+                File.folder_id.in_(folder_ids),
+                File.status == FileStatus.ACTIVE,
+                File.is_latest.is_(True),
+            )
+        )
+        if search:
+            statement = statement.where(File.file_name.ilike(f"%{search}%"))
+        statement = statement.order_by(File.file_name.asc())
+
+        rows = (await self.db.execute(statement)).all()
+        by_mime_type: dict[str, int] = {}
+        sample_items: list[dict[str, Any]] = []
+        total_items = 0
+        for row in rows:
+            file_id, file_name, file_size, mime_type, file_ext, row_folder_id = row
+            resolved_mime = resolve_file_mime_type(
+                mime_type=mime_type,
+                file_ext=file_ext,
+                file_name=file_name,
+            )
+            if category is not None and _category_for_file(
+                mime_type=resolved_mime,
+                file_ext=file_ext,
+                file_name=file_name,
+            ) != category:
+                continue
+
+            total_items += 1
+            by_mime_type[resolved_mime] = by_mime_type.get(resolved_mime, 0) + 1
+            if len(sample_items) < 5:
+                sample_items.append(
+                    {
+                        "id": str(file_id),
+                        "name": str(file_name),
+                        "size": int(file_size or 0),
+                        "mimeType": resolved_mime,
+                        "folderId": str(row_folder_id),
+                    }
+                )
+
+        return {
+            "totalItems": total_items,
+            "category": category,
+            "recursive": recursive,
+            "folderId": str(root_folder_id),
+            "byMimeType": dict(sorted(by_mime_type.items())),
+            "sampleItems": sample_items,
+        }
+
 
 def _first_value(args: dict[str, Any], *keys: str) -> Any:
     for key in keys:
@@ -143,3 +229,130 @@ def _required_text(args: dict[str, Any], *keys: str) -> str:
     if not text:
         raise ApiError(status_code=400, code=400, message=f"Missing required tool input: {keys[0]}")
     return text
+
+
+def _bool_arg(value: Any, *, default: bool) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    text = str(value).strip().lower()
+    if text in {"1", "true", "yes", "y"}:
+        return True
+    if text in {"0", "false", "no", "n"}:
+        return False
+    return default
+
+
+async def _resolve_folder_id(db: AsyncSession, *, user_id: int, folder_id: str) -> int:
+    if not folder_id or folder_id == "root":
+        root_id = await db.scalar(
+            select(Folder.folder_id).where(
+                and_(
+                    Folder.owner_id == user_id,
+                    Folder.parent_folder_id.is_(None),
+                    Folder.folder_type == FolderType.ROOT,
+                    Folder.status == FolderStatus.ACTIVE,
+                )
+            )
+        )
+        if root_id is None:
+            raise ApiError(status_code=404, code=404, message="Root folder not found")
+        return int(root_id)
+    try:
+        parsed = int(folder_id)
+    except ValueError as exc:
+        raise ApiError(status_code=400, code=400, message="Invalid folderId") from exc
+    exists = await db.scalar(
+        select(Folder.folder_id).where(
+            and_(
+                Folder.folder_id == parsed,
+                Folder.owner_id == user_id,
+                Folder.status == FolderStatus.ACTIVE,
+            )
+        )
+    )
+    if exists is None:
+        raise ApiError(status_code=404, code=404, message="Folder not found")
+    return parsed
+
+
+async def _active_descendant_folder_ids(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    root_folder_id: int,
+) -> list[int]:
+    descendants = (
+        select(Folder.folder_id)
+        .where(
+            and_(
+                Folder.folder_id == root_folder_id,
+                Folder.owner_id == user_id,
+                Folder.status == FolderStatus.ACTIVE,
+            )
+        )
+        .cte(name="agent_count_descendants", recursive=True)
+    )
+    descendants = descendants.union_all(
+        select(Folder.folder_id).where(
+            and_(
+                Folder.parent_folder_id == descendants.c.folder_id,
+                Folder.owner_id == user_id,
+                Folder.status == FolderStatus.ACTIVE,
+            )
+        )
+    )
+    folder_ids = list(await db.scalars(select(descendants.c.folder_id)))
+    return [int(folder_id) for folder_id in folder_ids]
+
+
+def _normalize_category(value: Any) -> str | None:
+    text = str(value or "").strip().lower()
+    aliases = {
+        "movies": "video",
+        "movie": "video",
+        "film": "video",
+        "films": "video",
+        "视频": "video",
+        "影片": "video",
+        "电影": "video",
+        "videos": "video",
+        "documents": "document",
+        "docs": "document",
+        "images": "image",
+        "pictures": "image",
+        "archives": "archive",
+        "compressed": "archive",
+    }
+    text = aliases.get(text, text)
+    if text in {"video", "audio", "image", "document", "archive", "other"}:
+        return text
+    return None
+
+
+def _category_for_file(*, mime_type: str, file_ext: str | None, file_name: str | None) -> str:
+    mime = (mime_type or "").lower()
+    ext = _normalized_extension(file_ext) or _filename_extension(file_name)
+    if mime.startswith("video/") or ext in {"mp4", "mov", "avi", "mkv", "webm", "m4v"}:
+        return "video"
+    if mime.startswith("audio/") or ext in {"mp3", "wav", "flac", "m4a", "aac", "ogg"}:
+        return "audio"
+    if mime.startswith("image/") or ext in {"jpg", "jpeg", "png", "gif", "webp", "svg", "bmp"}:
+        return "image"
+    if mime in {"application/pdf"} or ext in {"pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt", "md"}:
+        return "document"
+    if ext in {"zip", "rar", "7z", "tar", "gz", "bz2", "xz"}:
+        return "archive"
+    return "other"
+
+
+def _normalized_extension(value: str | None) -> str:
+    return str(value or "").strip().lower().lstrip(".")
+
+
+def _filename_extension(value: str | None) -> str:
+    name = str(value or "").strip().lower()
+    if "." not in name:
+        return ""
+    return name.rsplit(".", 1)[-1]
diff --git a/app/src/fileflash/agents/runtime/execute_runner.py b/app/src/fileflash/agents/runtime/execute_runner.py
index 1e045d6..499b489 100644
--- a/app/src/fileflash/agents/runtime/execute_runner.py
+++ b/app/src/fileflash/agents/runtime/execute_runner.py
@@ -146,10 +146,12 @@ async def run(self, *, db: AsyncSession, job: BackgroundJob) -> AgentExecutionRe
             warnings.append(f"{skipped} action(s) were skipped.")
         await work_sessions.close_session(job_id=int(job.job_id), status="closed")
         await db.commit()
+        answer = _build_execution_answer(actions=actions, step_outputs=step_outputs)
         return AgentExecutionResult(
             plan_job_id=str(plan_job_id),
             execute_job_id=str(job.job_id),
             summary=f"Execution completed with {applied} applied action(s).",
+            answer=answer,
             applied_actions=applied,
             skipped_actions=skipped,
             warnings=warnings,
@@ -222,3 +224,37 @@ def _resolve_references(
             for key, item in value.items()
         }
     return value
+
+
+def _build_execution_answer(
+    *,
+    actions: list[AgentProposedAction],
+    step_outputs: dict[int, dict[str, Any]],
+) -> str | None:
+    for action in actions:
+        if action.tool != "drive.countFiles":
+            continue
+        output = step_outputs.get(action.step)
+        if not isinstance(output, dict):
+            continue
+        return _count_files_answer(output)
+
+    if actions and all(action.side_effect == "read" for action in actions):
+        return f"已完成 {len(step_outputs)} 个只读操作。"
+    return None
+
+
+def _count_files_answer(output: dict[str, Any]) -> str:
+    total_items = int(output.get("totalItems") or 0)
+    category = str(output.get("category") or "").strip().lower()
+    if category == "video":
+        return f"你上传了 {total_items} 部电影（按视频文件统计）。"
+    if category == "audio":
+        return f"你上传了 {total_items} 个音频文件。"
+    if category == "image":
+        return f"你上传了 {total_items} 张图片。"
+    if category == "document":
+        return f"你上传了 {total_items} 个文档。"
+    if category == "archive":
+        return f"你上传了 {total_items} 个压缩包。"
+    return f"你上传了 {total_items} 个文件。"
diff --git a/app/src/fileflash/agents/runtime/llm.py b/app/src/fileflash/agents/runtime/llm.py
index d4b157f..4a268ee 100644
--- a/app/src/fileflash/agents/runtime/llm.py
+++ b/app/src/fileflash/agents/runtime/llm.py
@@ -46,8 +46,24 @@ async def create_plan(
             "timeout": 60.0,
         }
         request_kwargs.update(_reasoning_params(reasoning_effort))
+        message = await self._request_plan(api_key=api_key, request_kwargs=request_kwargs)
         try:
-            message = await self._get_client(api_key).messages.create(**request_kwargs)
+            parsed, usage = _parse_plan_message(message)
+        except ApiError as exc:
+            if not _is_retryable_output_error(exc):
+                raise
+            degraded_kwargs = dict(request_kwargs)
+            degraded_kwargs.pop("thinking", None)
+            degraded_kwargs.pop("output_config", None)
+            message = await self._request_plan(api_key=api_key, request_kwargs=degraded_kwargs)
+            parsed, usage = _parse_plan_message(message)
+        if isinstance(usage, dict):
+            parsed["_usage"] = usage
+        return parsed
+
+    async def _request_plan(self, *, api_key: str, request_kwargs: dict[str, Any]) -> Any:
+        try:
+            return await self._get_client(api_key).messages.create(**request_kwargs)
         except anthropic.APIStatusError as exc:
             raise ApiError(
                 status_code=503,
@@ -66,13 +82,6 @@ async def create_plan(
                 message=f"Agent LLM request failed: {type(exc).__name__}",
             ) from exc
 
-        text = _extract_text(message)
-        parsed = _parse_json_text(text)
-        usage = _usage_payload(message)
-        if isinstance(usage, dict):
-            parsed["_usage"] = usage
-        return parsed
-
     def _get_client(self, api_key: str) -> AsyncAnthropic:
         if self._client is None:
             base_url = (self.settings.agent_llm_base_url or "").strip() or None
@@ -87,22 +96,80 @@ def _get_client(self, api_key: str) -> AsyncAnthropic:
 
 def _extract_text(message: Any) -> str:
     chunks = getattr(message, "content", None)
+    if isinstance(chunks, str):
+        text = chunks.strip()
+        if text:
+            return text
+        raise ApiError(status_code=502, code=502, message="Agent LLM returned an empty response")
     if not isinstance(chunks, list):
         raise ApiError(status_code=502, code=502, message="Agent LLM returned an invalid response")
     parts: list[str] = []
     for chunk in chunks:
-        if isinstance(chunk, dict):
-            if chunk.get("type") == "text":
-                parts.append(str(chunk.get("text") or ""))
-            continue
-        if getattr(chunk, "type", None) == "text":
-            parts.append(str(getattr(chunk, "text", "") or ""))
+        parts.extend(_extract_text_parts(chunk))
     text = "\n".join(part for part in parts if part).strip()
     if not text:
         raise ApiError(status_code=502, code=502, message="Agent LLM returned an empty response")
     return text
 
 
+def _extract_text_parts(chunk: Any) -> list[str]:
+    if chunk is None:
+        return []
+    if isinstance(chunk, str):
+        candidate = chunk.strip()
+        return [candidate] if candidate else []
+    if isinstance(chunk, dict):
+        return _extract_text_parts_from_mapping(chunk)
+    if hasattr(chunk, "model_dump"):
+        dumped = chunk.model_dump()
+        if isinstance(dumped, dict):
+            return _extract_text_parts_from_mapping(dumped)
+    return _extract_text_parts_from_mapping(
+        {
+            "type": getattr(chunk, "type", None),
+            "text": getattr(chunk, "text", None),
+            "output_text": getattr(chunk, "output_text", None),
+            "content": getattr(chunk, "content", None),
+        }
+    )
+
+
+def _extract_text_parts_from_mapping(payload: dict[str, Any]) -> list[str]:
+    out: list[str] = []
+    if payload.get("type") == "text":
+        out.extend(_flatten_text_value(payload.get("text")))
+    for key in ("text", "output_text", "content"):
+        out.extend(_flatten_text_value(payload.get(key)))
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for item in out:
+        if not item or item in seen:
+            continue
+        deduped.append(item)
+        seen.add(item)
+    return deduped
+
+
+def _flatten_text_value(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        candidate = value.strip()
+        return [candidate] if candidate else []
+    if isinstance(value, list):
+        out: list[str] = []
+        for item in value:
+            out.extend(_flatten_text_value(item))
+        return out
+    if isinstance(value, dict):
+        if value.get("type") == "text":
+            return _flatten_text_value(value.get("text"))
+        if "text" in value:
+            return _flatten_text_value(value.get("text"))
+        return []
+    return []
+
+
 def _usage_payload(message: Any) -> dict[str, Any] | None:
     usage = getattr(message, "usage", None)
     if usage is None:
@@ -144,6 +211,24 @@ def _response_details(error: anthropic.APIStatusError) -> str:
     return str(text or "")[:800]
 
 
+def _parse_plan_message(message: Any) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    text = _extract_text(message)
+    parsed = _parse_json_text(text)
+    usage = _usage_payload(message)
+    return parsed, usage
+
+
+def _is_retryable_output_error(error: ApiError) -> bool:
+    if error.status_code != 502:
+        return False
+    return error.message in {
+        "Agent LLM returned an invalid response",
+        "Agent LLM returned an empty response",
+        "Agent LLM did not return valid JSON",
+        "Agent LLM JSON must be an object",
+    }
+
+
 def _parse_json_text(text: str) -> dict[str, Any]:
     candidate = text.strip()
     if candidate.startswith("```"):
diff --git a/app/src/fileflash/agents/runtime/plan_runner.py b/app/src/fileflash/agents/runtime/plan_runner.py
index 7181cf1..e3421d0 100644
--- a/app/src/fileflash/agents/runtime/plan_runner.py
+++ b/app/src/fileflash/agents/runtime/plan_runner.py
@@ -29,6 +29,7 @@
 
 DEFAULT_AGENT_TOOLS = (
     "drive.listFolder",
+    "drive.countFiles",
     "drive.createFolder",
     "drive.moveFile",
     "drive.moveFolder",
@@ -63,17 +64,26 @@ async def run(self, *, db: AsyncSession, job: BackgroundJob) -> AgentPlanResult:
         )
         metadata = await _collect_context_metadata(db, user_id=user_id, request=request)
         allowed_tools = _skill_tool_whitelist(skill)
-        llm_payload = await self.planner_client.create_plan(
-            system_prompt=_system_prompt(),
-            user_prompt=_user_prompt(
+        try:
+            llm_payload = await self.planner_client.create_plan(
+                system_prompt=_system_prompt(),
+                user_prompt=_user_prompt(
+                    request=request,
+                    skill=skill,
+                    allowed_tools=allowed_tools,
+                    metadata=metadata,
+                ),
+                max_tokens=request.hints.budget_tokens,
+                reasoning_effort=request.hints.reasoning_effort,
+            )
+        except ApiError as exc:
+            if exc.status_code != 502:
+                raise
+            llm_payload = _safe_fallback_payload(
                 request=request,
-                skill=skill,
-                allowed_tools=allowed_tools,
                 metadata=metadata,
-            ),
-            max_tokens=request.hints.budget_tokens,
-            reasoning_effort=request.hints.reasoning_effort,
-        )
+                allowed_tools=allowed_tools,
+            )
 
         actions = _normalize_actions(
             llm_payload=llm_payload,
@@ -182,7 +192,10 @@ def _skill_tool_whitelist(skill: AgentSkill | AgentSkillCatalogEntry | None) ->
     elif skill is not None:
         raw = skill.tool_whitelist_json
     if isinstance(raw, list) and raw:
-        return tuple(str(item) for item in raw if str(item).strip())
+        tools = tuple(str(item) for item in raw if str(item).strip())
+        if "drive.countFiles" not in tools:
+            return (*tools, "drive.countFiles")
+        return tools
     return DEFAULT_AGENT_TOOLS
 
 
@@ -356,7 +369,8 @@ def _folder_metadata(row: Folder) -> dict[str, Any]:
 def _system_prompt() -> str:
     return (
         "You are FileFlash Agent Planner. Return only JSON. "
-        "Plan file-organization actions using the provided tools and metadata. "
+        "Plan file-management actions or read-only answers using the provided tools and metadata. "
+        "For count/how many questions, prefer drive.countFiles over listing folders. "
         "Do not read or infer file contents. Deletions are high risk and must be explicit. "
         "Cross-step dependencies must use '$stepN.field' references only and never symbolic placeholders "
         "like 'newFolderId'."
@@ -437,6 +451,10 @@ def _skill_payload(skill: AgentSkill | AgentSkillCatalogEntry | None) -> dict[st
 def _tool_schemas(allowed_tools: tuple[str, ...]) -> list[dict[str, Any]]:
     descriptions = {
         "drive.listFolder": "List direct folder contents by folderId.",
+        "drive.countFiles": (
+            "Count files under folderId. Supports recursive=true and category values "
+            "video, audio, image, document, archive, other. Use category=video for movie/电影 questions."
+        ),
         "drive.createFolder": "Create a folder under parentFolderId with name.",
         "drive.moveFile": "Move fileId into targetFolderId.",
         "drive.moveFolder": "Move folderId into targetParentId.",
@@ -448,6 +466,74 @@ def _tool_schemas(allowed_tools: tuple[str, ...]) -> list[dict[str, Any]]:
     return [{"tool": tool, "description": descriptions.get(tool, "")} for tool in allowed_tools]
 
 
+def _safe_fallback_payload(
+    *,
+    request: PlanAgentRequest,
+    metadata: dict[str, Any],
+    allowed_tools: tuple[str, ...],
+) -> dict[str, Any]:
+    fallback_actions: list[dict[str, Any]] = []
+    if "drive.countFiles" in allowed_tools and _looks_like_count_question(request.input):
+        fallback_actions.append(
+            {
+                "step": 1,
+                "tool": "drive.countFiles",
+                "input": {
+                    "folderId": metadata.get("rootFolderId") or request.context.root_folder_id or "root",
+                    "recursive": True,
+                    "category": _fallback_count_category(request.input),
+                },
+                "sideEffect": "read",
+                "riskLevel": "low",
+                "requiresConfirmation": False,
+            }
+        )
+        return {
+            "summary": "Planner fallback mode: generated a safe read-only count plan.",
+            "proposedActions": fallback_actions,
+        }
+    if "drive.listFolder" in allowed_tools:
+        root_folder_id = str(
+            metadata.get("rootFolderId")
+            or request.context.root_folder_id
+            or "root"
+        )
+        fallback_actions.append(
+            {
+                "step": 1,
+                "tool": "drive.listFolder",
+                "input": {"folderId": root_folder_id},
+                "sideEffect": "read",
+                "riskLevel": "low",
+                "requiresConfirmation": False,
+            }
+        )
+    return {
+        "summary": "Planner fallback mode: generated a safe read-only plan.",
+        "proposedActions": fallback_actions,
+    }
+
+
+def _looks_like_count_question(text: str) -> bool:
+    normalized = text.lower()
+    return any(token in normalized for token in ("多少", "几个", "几部", "count", "how many", "number of"))
+
+
+def _fallback_count_category(text: str) -> str | None:
+    normalized = text.lower()
+    if any(token in normalized for token in ("电影", "影片", "视频", "movie", "film", "video")):
+        return "video"
+    if any(token in normalized for token in ("图片", "照片", "image", "photo", "picture")):
+        return "image"
+    if any(token in normalized for token in ("音频", "音乐", "audio", "music")):
+        return "audio"
+    if any(token in normalized for token in ("文档", "document", "doc")):
+        return "document"
+    if any(token in normalized for token in ("压缩", "archive", "zip")):
+        return "archive"
+    return None
+
+
 def _normalize_actions(
     *,
     llm_payload: dict[str, Any],
diff --git a/app/src/fileflash/agents/worker.py b/app/src/fileflash/agents/worker.py
index 871c214..6fd4e89 100644
--- a/app/src/fileflash/agents/worker.py
+++ b/app/src/fileflash/agents/worker.py
@@ -143,6 +143,8 @@ async def _mark_succeeded(self, *, job_id: int, result: dict[str, Any], phase: s
                 )
                 if job is None:
                     return
+                if job.status == "canceled" or job.cancel_requested_at is not None:
+                    return
                 now = datetime.now(UTC)
                 job.status = "succeeded"
                 job.result = jsonable_encoder(result)
@@ -161,6 +163,8 @@ async def _mark_failed(self, *, job_id: int, error: Exception) -> None:
                 )
                 if job is None:
                     return
+                if job.status == "canceled" or job.cancel_requested_at is not None:
+                    return
                 now = datetime.now(UTC)
                 job.status = "failed"
                 job.agent_phase = "failed"
diff --git a/app/src/fileflash/routers/agent.py b/app/src/fileflash/routers/agent.py
index 218976a..2e56108 100644
--- a/app/src/fileflash/routers/agent.py
+++ b/app/src/fileflash/routers/agent.py
@@ -71,11 +71,10 @@ async def cancel_agent_job(
     canceled_at = datetime.now(UTC)
     if job.status not in {"succeeded", "failed", "canceled"}:
         job.cancel_requested_at = canceled_at
+        job.status = "canceled"
+        job.agent_phase = "canceled"
+        job.finished_at = canceled_at
         job.updated_at = canceled_at
-        if job.status in {"pending", "retrying"}:
-            job.status = "canceled"
-            job.agent_phase = "canceled"
-            job.finished_at = canceled_at
     await db.commit()
     await db.refresh(job)
 
diff --git a/app/src/fileflash/schemas/agent.py b/app/src/fileflash/schemas/agent.py
index 96ce47b..e253be0 100644
--- a/app/src/fileflash/schemas/agent.py
+++ b/app/src/fileflash/schemas/agent.py
@@ -116,6 +116,7 @@ class AgentExecutionResult(CamelModel):
     plan_job_id: str
     execute_job_id: str
     summary: str
+    answer: str | None = None
     applied_actions: int = Field(ge=0)
     skipped_actions: int = Field(ge=0)
     warnings: list[str] = Field(default_factory=list)

From 0c927bdd1dc5851290ed744870d924dfd22d0b49 Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:14:47 +0800
Subject: [PATCH 06/10] test(agent): add tests for countFiles tool, LLM retry,
 fallback, cancel, and execution answer

- Test drive.countFiles dispatches recursive video counting with mime-type sampling
- Test ExecuteRunner returns natural-language answer for countFiles actions
- Test AnthropicPlannerClient retries without reasoning on empty output
- Test PlanRunner falls back to safe read-only plan when LLM returns invalid output
- Test PlanRunner fallback detects movie-count questions and uses drive.countFiles
- Test cancel route marks running jobs as canceled
---
 app/tests/test_agent_plan_execute_runtime.py | 265 +++++++++++++++++++
 app/tests/test_agent_routes.py               |  27 ++
 app/tests/test_agent_worker.py               |  84 ++++++
 3 files changed, 376 insertions(+)
 create mode 100644 app/tests/test_agent_worker.py

diff --git a/app/tests/test_agent_plan_execute_runtime.py b/app/tests/test_agent_plan_execute_runtime.py
index 62ba503..46fd8ef 100644
--- a/app/tests/test_agent_plan_execute_runtime.py
+++ b/app/tests/test_agent_plan_execute_runtime.py
@@ -197,6 +197,48 @@ async def create(self, **kwargs):  # noqa: ANN003
     assert fake_messages.kwargs["output_config"] == {"effort": "xhigh"}
 
 
+@pytest.mark.asyncio
+async def test_anthropic_planner_client_retries_without_reasoning_on_empty_output():
+    class FakeMessages:
+        def __init__(self) -> None:
+            self.calls: list[dict[str, object]] = []
+
+        async def create(self, **kwargs):  # noqa: ANN003
+            self.calls.append(dict(kwargs))
+            if len(self.calls) == 1:
+                return SimpleNamespace(
+                    content=[SimpleNamespace(type="thinking", thinking="...")],
+                    usage={},
+                )
+            return SimpleNamespace(
+                content=[SimpleNamespace(type="text", text='{"summary":"fallback","proposedActions":[]}')],
+                usage={},
+            )
+
+    fake_messages = FakeMessages()
+    client = AnthropicPlannerClient(
+        settings=settings(
+            agent_llm_api_key="test-key",
+            agent_llm_model="claude-test",
+        ),
+        client=SimpleNamespace(messages=fake_messages),  # type: ignore[arg-type]
+    )
+
+    result = await client.create_plan(
+        system_prompt="system",
+        user_prompt="user",
+        max_tokens=1024,
+        reasoning_effort="high",
+    )
+
+    assert len(fake_messages.calls) == 2
+    assert "thinking" in fake_messages.calls[0]
+    assert "output_config" in fake_messages.calls[0]
+    assert "thinking" not in fake_messages.calls[1]
+    assert "output_config" not in fake_messages.calls[1]
+    assert result["summary"] == "fallback"
+
+
 def test_anthropic_planner_client_uses_configured_base_url(monkeypatch: pytest.MonkeyPatch):
     captured: dict[str, object] = {}
 
@@ -528,6 +570,118 @@ async def test_plan_runner_rolls_back_when_commit_fails(monkeypatch: pytest.Monk
     db.rollback.assert_awaited_once()
 
 
+@pytest.mark.asyncio
+async def test_plan_runner_uses_safe_read_only_fallback_when_planner_returns_invalid_output(
+    monkeypatch: pytest.MonkeyPatch,
+):
+    monkeypatch.setattr(plan_module, "_choose_skill", AsyncMock(return_value=None))
+    monkeypatch.setattr(
+        plan_module,
+        "_collect_context_metadata",
+        AsyncMock(return_value={"scope": "currentFolder", "rootFolderId": "root", "files": [], "folders": []}),
+    )
+    monkeypatch.setattr(plan_module, "_upsert_agent_plan", AsyncMock(return_value=None))
+
+    planner = AsyncMock(
+        side_effect=ApiError(
+            status_code=502,
+            code=502,
+            message="Agent LLM returned an empty response",
+        )
+    )
+    runner = PlanRunner(
+        settings=settings(),
+        planner_client=SimpleNamespace(create_plan=planner),  # type: ignore[arg-type]
+    )
+    request = PlanAgentRequest.model_validate(
+        {
+            "input": "organize",
+            "context": {
+                "rootFolderId": "root",
+                "selectedFileIds": [],
+                "selectedFolderIds": [],
+                "currentPath": "/My Files",
+            },
+            "executionPolicy": "autopilot",
+        }
+    )
+    job = BackgroundJob(
+        job_id=333,
+        task_type="agent.plan",
+        status="running",
+        payload=request.model_dump(by_alias=True),
+        result={},
+        requested_by=7,
+        scheduled_at=datetime.now(UTC),
+        created_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+    )
+    db = DummyDb()
+
+    result = await runner.run(db=db, job=job)  # type: ignore[arg-type]
+
+    assert "fallback mode" in result.summary.lower()
+    assert len(result.proposed_actions) == 1
+    assert result.proposed_actions[0].tool == "drive.listFolder"
+    assert result.proposed_actions[0].side_effect == "read"
+    assert result.requires_confirmation is False
+
+
+@pytest.mark.asyncio
+async def test_plan_runner_fallback_uses_count_files_for_movie_count_question(
+    monkeypatch: pytest.MonkeyPatch,
+):
+    monkeypatch.setattr(plan_module, "_choose_skill", AsyncMock(return_value=None))
+    monkeypatch.setattr(
+        plan_module,
+        "_collect_context_metadata",
+        AsyncMock(return_value={"scope": "currentFolder", "rootFolderId": "root", "files": [], "folders": []}),
+    )
+    monkeypatch.setattr(plan_module, "_upsert_agent_plan", AsyncMock(return_value=None))
+
+    planner = AsyncMock(
+        side_effect=ApiError(
+            status_code=502,
+            code=502,
+            message="Agent LLM returned an empty response",
+        )
+    )
+    runner = PlanRunner(
+        settings=settings(),
+        planner_client=SimpleNamespace(create_plan=planner),  # type: ignore[arg-type]
+    )
+    request = PlanAgentRequest.model_validate(
+        {
+            "input": "我上传了多少部电影？",
+            "context": {
+                "rootFolderId": "root",
+                "selectedFileIds": [],
+                "selectedFolderIds": [],
+                "currentPath": "/My Files",
+            },
+            "executionPolicy": "confirm",
+        }
+    )
+    job = BackgroundJob(
+        job_id=334,
+        task_type="agent.plan",
+        status="running",
+        payload=request.model_dump(by_alias=True),
+        result={},
+        requested_by=7,
+        scheduled_at=datetime.now(UTC),
+        created_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+    )
+
+    result = await runner.run(db=DummyDb(), job=job)  # type: ignore[arg-type]
+
+    assert len(result.proposed_actions) == 1
+    assert result.proposed_actions[0].tool == "drive.countFiles"
+    assert result.proposed_actions[0].input["category"] == "video"
+    assert result.proposed_actions[0].side_effect == "read"
+
+
 def test_normalize_actions_rejects_symbolic_placeholder_target_folder():
     with pytest.raises(ApiError) as exc:
         plan_module._normalize_actions(
@@ -650,6 +804,39 @@ async def test_tool_router_dispatches_move_file():
     router.file_service.move_file.assert_awaited_once()
 
 
+@pytest.mark.asyncio
+async def test_tool_router_count_files_counts_recursive_videos():
+    db = DummyDb()
+    db.scalar = AsyncMock(return_value=1)
+    db.scalars = AsyncMock(return_value=[1, 2])
+    db.execute = AsyncMock(
+        return_value=SimpleNamespace(
+            all=lambda: [
+                (10, "movie.mp4", 100, "application/octet-stream", "mp4", 1),
+                (11, "clip.mkv", 200, "video/x-matroska", "mkv", 2),
+                (12, "notes.txt", 10, "text/plain", "txt", 1),
+            ]
+        )
+    )
+    router = ToolRouter(db=db, user_id=7)  # type: ignore[arg-type]
+
+    result = await router.dispatch(
+        ToolCall(
+            tool_name="drive.countFiles",
+            arguments={"folderId": "root", "recursive": True, "category": "video"},
+        )
+    )
+
+    assert result["totalItems"] == 2
+    assert result["category"] == "video"
+    assert result["recursive"] is True
+    assert result["byMimeType"] == {"video/mp4": 1, "video/x-matroska": 1}
+    assert [item["name"] for item in result["sampleItems"]] == ["movie.mp4", "clip.mkv"]
+    executed_statement = str(db.execute.await_args.args[0])
+    assert "file.status" in executed_statement
+    assert "file.is_latest" in executed_statement
+
+
 @pytest.mark.asyncio
 async def test_execute_runner_normalizes_tool_output_before_action_log(monkeypatch: pytest.MonkeyPatch):
     started = datetime.now(UTC)
@@ -728,3 +915,81 @@ async def test_execute_runner_normalizes_tool_output_before_action_log(monkeypat
     assert isinstance(outputs_json, dict)
     assert isinstance(outputs_json["createdAt"], str)
     assert outputs_json["createdAt"] == output_time.isoformat()
+
+
+@pytest.mark.asyncio
+async def test_execute_runner_returns_count_files_answer(monkeypatch: pytest.MonkeyPatch):
+    started = datetime.now(UTC)
+    job = BackgroundJob(
+        job_id=601,
+        task_type="agent.execute",
+        status="running",
+        payload={
+            "planJobId": "501",
+            "planHash": "sha256:test",
+            "approval": {
+                "confirmedBy": "7",
+                "confirmedAt": started.isoformat(),
+                "highRiskConfirmed": False,
+            },
+        },
+        result={},
+        requested_by=7,
+        scheduled_at=started,
+        created_at=started,
+        updated_at=started,
+    )
+    action = {
+        "step": 1,
+        "tool": "drive.countFiles",
+        "input": {"folderId": "root", "recursive": True, "category": "video"},
+        "sideEffect": "read",
+        "riskLevel": "low",
+        "requiresConfirmation": False,
+    }
+    db = DummyDb()
+    db.refresh = AsyncMock()
+
+    mock_plan_repo = SimpleNamespace(
+        get_for_execute_binding=AsyncMock(
+            return_value=SimpleNamespace(
+                proposed_actions_json=[action],
+            )
+        )
+    )
+    monkeypatch.setattr(execute_module, "AgentPlanRepository", lambda _db: mock_plan_repo)
+
+    mock_work_sessions = SimpleNamespace(
+        create_for_job=AsyncMock(return_value=None),
+        close_session=AsyncMock(return_value=None),
+    )
+    monkeypatch.setattr(execute_module, "AgentWorkSessionRepository", lambda _db: mock_work_sessions)
+    monkeypatch.setattr(
+        execute_module,
+        "AgentActionLogRepository",
+        lambda _db: SimpleNamespace(
+            append_step=AsyncMock(return_value=None),
+            finish_step=AsyncMock(return_value=None),
+        ),
+    )
+    monkeypatch.setattr(
+        execute_module,
+        "ToolRouter",
+        lambda **kwargs: SimpleNamespace(
+            dispatch=AsyncMock(
+                return_value={
+                    "totalItems": 3,
+                    "category": "video",
+                    "recursive": True,
+                    "folderId": "1",
+                    "byMimeType": {"video/mp4": 3},
+                    "sampleItems": [],
+                }
+            )
+        ),
+    )
+
+    result = await ExecuteRunner().run(db=db, job=job)  # type: ignore[arg-type]
+
+    assert result.answer == "你上传了 3 部电影（按视频文件统计）。"
+    assert result.applied_actions == 1
diff --git a/app/tests/test_agent_routes.py b/app/tests/test_agent_routes.py
index f2a0506..6b50f90 100644
--- a/app/tests/test_agent_routes.py
+++ b/app/tests/test_agent_routes.py
@@ -49,6 +49,12 @@ async def refresh(self, _job: BackgroundJob) -> None:
         return None
 
 
+class RunningJobDb(StubDb):
+    def __init__(self) -> None:
+        super().__init__()
+        self.job.status = "running"
+
+
 def _user() -> User:
     return User(user_id=7, username="u7", email="u7@example.com", password_hash="x")
 
@@ -64,6 +70,17 @@ def _client() -> TestClient:
     return TestClient(app)
 
 
+def _client_with_running_job() -> TestClient:
+    app = FastAPI()
+    app.include_router(router, prefix="/api/v1")
+    app.add_exception_handler(ApiError, api_error_handler)
+    app.dependency_overrides[get_current_user] = _user
+    app.dependency_overrides[get_agent_plan_service] = lambda: StubPlanService()
+    app.dependency_overrides[get_agent_execute_service] = lambda: StubExecuteService()
+    app.dependency_overrides[get_db] = lambda: RunningJobDb()
+    return TestClient(app)
+
+
 def test_plan_route_returns_response_shell():
     response = _client().post(
         "/api/v1/agent/plan",
@@ -123,3 +140,13 @@ def test_cancel_route_returns_response_shell():
     assert body["data"]["jobId"] == "12"
     assert body["data"]["status"] == "canceled"
     assert body["data"]["canceledAt"]
+
+
+def test_cancel_route_marks_running_job_as_canceled():
+    response = _client_with_running_job().post("/api/v1/agent/cancel/12")
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["success"] is True
+    assert body["data"]["jobId"] == "12"
+    assert body["data"]["status"] == "canceled"
diff --git a/app/tests/test_agent_worker.py b/app/tests/test_agent_worker.py
new file mode 100644
index 0000000..65b15b0
--- /dev/null
+++ b/app/tests/test_agent_worker.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from fileflash.agents.worker import AgentWorkerConsumer
+from fileflash.models import BackgroundJob
+
+
+class _AsyncContextManager:
+    def __init__(self, value):
+        self._value = value
+
+    async def __aenter__(self):
+        return self._value
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return None
+
+
+class DummySession:
+    def __init__(self, job: BackgroundJob):
+        self._job = job
+
+    def begin(self):
+        return _AsyncContextManager(SimpleNamespace())
+
+    async def scalar(self, _query):  # noqa: ANN001
+        return self._job
+
+
+def _job(*, status: str, cancel_requested_at: datetime | None) -> BackgroundJob:
+    now = datetime.now(UTC)
+    return BackgroundJob(
+        job_id=65,
+        task_type="agent.plan",
+        status=status,
+        payload={},
+        result={},
+        requested_by=7,
+        cancel_requested_at=cancel_requested_at,
+        scheduled_at=now,
+        created_at=now,
+        updated_at=now,
+    )
+
+
+@pytest.mark.asyncio
+async def test_mark_succeeded_does_not_override_canceled_job(monkeypatch: pytest.MonkeyPatch):
+    canceled_at = datetime.now(UTC)
+    job = _job(status="canceled", cancel_requested_at=canceled_at)
+    session = DummySession(job)
+    consumer = AgentWorkerConsumer(
+        queue=SimpleNamespace(),
+        session_factory=lambda: _AsyncContextManager(session),  # type: ignore[arg-type]
+    )
+    monkeypatch.setattr("fileflash.agents.worker.apply_local_lock_timeout", AsyncMock(return_value=None))
+
+    await consumer._mark_succeeded(job_id=65, result={"summary": "ok"}, phase="completed")
+
+    assert job.status == "canceled"
+    assert job.cancel_requested_at == canceled_at
+    assert job.result == {}
+
+
+@pytest.mark.asyncio
+async def test_mark_failed_does_not_override_job_with_cancel_request(monkeypatch: pytest.MonkeyPatch):
+    canceled_at = datetime.now(UTC)
+    job = _job(status="running", cancel_requested_at=canceled_at)
+    session = DummySession(job)
+    consumer = AgentWorkerConsumer(
+        queue=SimpleNamespace(),
+        session_factory=lambda: _AsyncContextManager(session),  # type: ignore[arg-type]
+    )
+    monkeypatch.setattr("fileflash.agents.worker.apply_local_lock_timeout", AsyncMock(return_value=None))
+
+    await consumer._mark_failed(job_id=65, error=RuntimeError("boom"))
+
+    assert job.status == "running"
+    assert job.cancel_requested_at == canceled_at
+    assert job.error_message is None

From 41ac26537462f69327c2cedf9961c5f216a2d3ab Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:14:56 +0800
Subject: [PATCH 07/10] refactor(web): rewrite polling to generation-based loop
 with cancel safety

- Replace setInterval-based polling with generation-gated async loop to prevent race conditions
- Add canceledTurns set for immediate local cancellation before API response arrives
- Guard all async boundaries (poll tick, execute dispatch) against stale generations and canceled turns
- Auto-execute read-only low-risk plans even under confirm policy via isReadOnlyAutoExecutable
- Replace window.confirm with ui.confirm dialog for high-risk action confirmation
- Clean up polling timers and cancel state on session delete/reset
---
 web/src/composables/useAgentSession.ts | 191 ++++++++++++++++++++-----
 1 file changed, 155 insertions(+), 36 deletions(-)

diff --git a/web/src/composables/useAgentSession.ts b/web/src/composables/useAgentSession.ts
index 80964fd..a8a14b4 100644
--- a/web/src/composables/useAgentSession.ts
+++ b/web/src/composables/useAgentSession.ts
@@ -6,6 +6,8 @@ import {
   planAgentTask,
 } from '../api/agent';
 import { useUserStore } from '../store/user';
+import { useLocaleStore } from '../store/locale';
+import { ui } from '../utils/ui';
 import type {
   AgentExecutionPolicy,
   AgentExecutionResult,
@@ -44,12 +46,22 @@ export interface AgentTurn {
 }
 
 const STORAGE_KEY = 'fileflash.agent.sessions.v1';
+const POLL_INTERVAL_MS = 1200;
 
 const isTerminalStatus = (s?: string | null) =>
   s === 'succeeded' || s === 'failed' || s === 'canceled';
 
 const isEmptySession = (session: Session) => session.messages.length === 0;
 
+const isReadOnlyAutoExecutable = (plan: AgentPlanResult): boolean =>
+  plan.proposedActions.length > 0 &&
+  plan.proposedActions.every(
+    (action) =>
+      action.sideEffect === 'read' &&
+      action.riskLevel === 'low' &&
+      !action.requiresConfirmation,
+  );
+
 const toTurns = (messages: ChatMessage[]): AgentTurn[] => {
   const out: AgentTurn[] = [];
   let i = 0;
@@ -127,7 +139,9 @@ interface SessionState {
   reasoningEffort: Ref<AgentReasoningEffort>;
   taskInput: Ref<string>;
   isSending: Ref<boolean>;
-  pollTimers: Map<string, ReturnType<typeof setInterval>>;
+  pollGenerations: Map<string, number>;
+  pollSleepTimers: Map<string, ReturnType<typeof setTimeout>>;
+  canceledTurns: Set<string>;
 }
 
 let _state: SessionState | null = null;
@@ -141,19 +155,33 @@ const getState = (): SessionState => {
   const reasoningEffort = ref<AgentReasoningEffort>('adaptive');
   const taskInput = ref<string>('');
   const isSending = ref<boolean>(false);
-  const pollTimers = new Map<string, ReturnType<typeof setInterval>>();
+  const pollGenerations = new Map<string, number>();
+  const pollSleepTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  const canceledTurns = new Set<string>();
 
   watch(sessions, (v) => persistSessions(v), { deep: true });
   if (loaded.shouldPersist) persistSessions(sessions.value);
 
-  _state = { sessions, activeSessionId, policy, reasoningEffort, taskInput, isSending, pollTimers };
+  _state = {
+    sessions,
+    activeSessionId,
+    policy,
+    reasoningEffort,
+    taskInput,
+    isSending,
+    pollGenerations,
+    pollSleepTimers,
+    canceledTurns,
+  };
   return _state;
 };
 
 export const __resetForTests = () => {
   if (_state) {
-    _state.pollTimers.forEach((t) => clearInterval(t));
-    _state.pollTimers.clear();
+    _state.pollSleepTimers.forEach((t) => clearTimeout(t));
+    _state.pollSleepTimers.clear();
+    _state.pollGenerations.clear();
+    _state.canceledTurns.clear();
   }
   _state = null;
 };
@@ -202,6 +230,8 @@ const extractErrorMessage = (error: unknown, fallback: string): string => {
 export default function useAgentSession() {
   const s = getState();
   const userStore = useUserStore();
+  const localeStore = useLocaleStore();
+  const t = localeStore.t;
 
   const activeSession = computed(() => {
     if (!s.activeSessionId.value) return null;
@@ -210,17 +240,70 @@ export default function useAgentSession() {
 
   const activeTurns = computed<AgentTurn[]>(() => toTurns(activeSession.value?.messages ?? []));
 
+  const nextPollGeneration = (key: string): number => {
+    const generation = (s.pollGenerations.get(key) ?? 0) + 1;
+    s.pollGenerations.set(key, generation);
+    return generation;
+  };
+
+  const clearSleepTimer = (key: string) => {
+    const timer = s.pollSleepTimers.get(key);
+    if (!timer) return;
+    clearTimeout(timer);
+    s.pollSleepTimers.delete(key);
+  };
+
   const stopPolling = (key: string) => {
-    const t = s.pollTimers.get(key);
-    if (t) {
-      clearInterval(t);
-      s.pollTimers.delete(key);
-    }
+    nextPollGeneration(key);
+    clearSleepTimer(key);
   };
 
   const stopAllPolling = () => {
-    s.pollTimers.forEach((t) => clearInterval(t));
-    s.pollTimers.clear();
+    s.pollSleepTimers.forEach((t) => clearTimeout(t));
+    s.pollSleepTimers.clear();
+    s.pollGenerations.clear();
+  };
+
+  const isTurnCanceled = (msg: ChatMessage): boolean => s.canceledTurns.has(msg.id);
+
+  const clearTurnCanceled = (msg: ChatMessage) => {
+    s.canceledTurns.delete(msg.id);
+  };
+
+  const markTurnCanceled = (msg: ChatMessage) => {
+    s.canceledTurns.add(msg.id);
+  };
+
+  const ensureTurnNotCanceled = (msg: ChatMessage): boolean =>
+    !isTurnCanceled(msg) && msg.status !== 'canceled';
+
+  const startPollLoop = async (
+    key: string,
+    msg: ChatMessage,
+    tick: (generation: number) => Promise<boolean>,
+  ): Promise<void> => {
+    const generation = nextPollGeneration(key);
+    const run = async (): Promise<void> => {
+      if (s.pollGenerations.get(key) !== generation) return;
+      if (!ensureTurnNotCanceled(msg)) {
+        stopPolling(key);
+        return;
+      }
+      const shouldContinue = await tick(generation);
+      if (s.pollGenerations.get(key) !== generation) return;
+      if (!shouldContinue) {
+        stopPolling(key);
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (s.pollSleepTimers.get(key) === timer) {
+          s.pollSleepTimers.delete(key);
+        }
+        void run();
+      }, POLL_INTERVAL_MS);
+      s.pollSleepTimers.set(key, timer);
+    };
+    await run();
   };
 
   const createSession = () => {
@@ -258,6 +341,12 @@ export default function useAgentSession() {
   const deleteSession = (id: string) => {
     const idx = s.sessions.value.findIndex((c) => c.id === id);
     if (idx === -1) return;
+    const target = s.sessions.value[idx];
+    target.messages.forEach((msg) => {
+      clearTurnCanceled(msg);
+      stopPolling(`${msg.id}:plan`);
+      stopPolling(`${msg.id}:execute`);
+    });
     s.sessions.value.splice(idx, 1);
     if (s.activeSessionId.value === id) {
       stopAllPolling();
@@ -269,6 +358,11 @@ export default function useAgentSession() {
 
   const resetActiveSession = () => {
     if (!activeSession.value) return;
+    activeSession.value.messages.forEach((msg) => {
+      clearTurnCanceled(msg);
+      stopPolling(`${msg.id}:plan`);
+      stopPolling(`${msg.id}:execute`);
+    });
     stopAllPolling();
     activeSession.value.messages = [];
     activeSession.value.title = 'New session';
@@ -279,11 +373,10 @@ export default function useAgentSession() {
 
   async function pollPlanJob(msg: ChatMessage, jobId: string): Promise<void> {
     const timerKey = `${msg.id}:plan`;
-    stopPolling(timerKey);
-
-    const tick = async () => {
+    await startPollLoop(timerKey, msg, async (generation) => {
       try {
         const job = await getAgentJob<AgentPlanResult>(jobId);
+        if (s.pollGenerations.get(timerKey) !== generation || !ensureTurnNotCanceled(msg)) return false;
         msg.status = (job.status as MsgStatus) || 'running';
 
         if (job.status === 'succeeded' && job.result) {
@@ -294,29 +387,29 @@ export default function useAgentSession() {
           msg.errorMessage = job.errorMessage || 'Plan failed.';
         }
         if (isTerminalStatus(job.status)) {
-          stopPolling(timerKey);
-          if (msg.planResult && s.policy.value === 'autopilot' && !msg.planResult.requiresConfirmation) {
+          const shouldAutoExecute =
+            msg.planResult &&
+            ((s.policy.value === 'autopilot' && !msg.planResult.requiresConfirmation) ||
+              (s.policy.value === 'confirm' && isReadOnlyAutoExecutable(msg.planResult)));
+          if (shouldAutoExecute) {
             await runExecute(msg);
           }
+          return false;
         }
+        return true;
       } catch {
         // network blips: skip this tick
+        return true;
       }
-    };
-
-    await tick();
-    if (!isTerminalStatus(msg.status)) {
-      s.pollTimers.set(timerKey, setInterval(tick, 1200));
-    }
+    });
   }
 
   async function pollExecuteJob(msg: ChatMessage, jobId: string): Promise<void> {
     const timerKey = `${msg.id}:execute`;
-    stopPolling(timerKey);
-
-    const tick = async () => {
+    await startPollLoop(timerKey, msg, async (generation) => {
       try {
         const job = await getAgentJob<AgentExecutionResult>(jobId);
+        if (s.pollGenerations.get(timerKey) !== generation || !ensureTurnNotCanceled(msg)) return false;
         msg.status = (job.status as MsgStatus) || 'running';
 
         if (job.status === 'succeeded' && job.result) {
@@ -325,16 +418,13 @@ export default function useAgentSession() {
         if (job.status === 'failed' || job.status === 'canceled') {
           msg.errorMessage = job.errorMessage || 'Execute failed.';
         }
-        if (isTerminalStatus(job.status)) stopPolling(timerKey);
+        if (isTerminalStatus(job.status)) return false;
+        return true;
       } catch {
         // skip
+        return true;
       }
-    };
-
-    await tick();
-    if (!isTerminalStatus(msg.status)) {
-      s.pollTimers.set(timerKey, setInterval(tick, 1200));
-    }
+    });
   }
 
   async function sendMessage(): Promise<void> {
@@ -366,13 +456,23 @@ export default function useAgentSession() {
     s.taskInput.value = '';
 
     const reactiveAgent = session.messages[session.messages.length - 1];
+    clearTurnCanceled(reactiveAgent);
 
     try {
       const res = await planAgentTask(buildPlanPayload(input, s.policy.value, s.reasoningEffort.value));
       reactiveAgent.planJobId = res.jobId;
+      if (isTurnCanceled(reactiveAgent) || reactiveAgent.status === 'canceled') {
+        try {
+          await cancelAgentJob(res.jobId);
+        } catch {
+          // ignore cancellation sync errors after local cancel
+        }
+        return;
+      }
       reactiveAgent.status = 'pending';
       await pollPlanJob(reactiveAgent, res.jobId);
     } catch (error) {
+      if (isTurnCanceled(reactiveAgent) || reactiveAgent.status === 'canceled') return;
       reactiveAgent.status = 'failed';
       reactiveAgent.errorMessage = extractErrorMessage(error, 'Plan failed.');
     } finally {
@@ -384,6 +484,7 @@ export default function useAgentSession() {
     if (!msg.planResult || !msg.planHash) return;
     if (msg.executeJobId) return;
     if (msg.status !== 'succeeded') return;
+    if (isTurnCanceled(msg)) return;
     const highRisk = msg.planResult.proposedActions.some(
       (action) => action.riskLevel === 'high' || action.requiresConfirmation,
     );
@@ -391,9 +492,17 @@ export default function useAgentSession() {
     if (highRisk) {
       const reason =
         msg.planResult.proposedActions.find((action) => action.riskLevel === 'high' || action.requiresConfirmation)
-          ?.confirmationReason || 'This plan contains high-risk actions. Continue?';
-      if (typeof window !== 'undefined' && !window.confirm(reason)) return;
+          ?.confirmationReason || t('agent.v2.confirm.highRisk.message');
+      const ok = await ui.confirm({
+        title: t('agent.v2.confirm.highRisk.title'),
+        message: reason,
+        confirmText: t('agent.v2.confirm.highRisk.confirm'),
+        cancelText: t('agent.v2.confirm.highRisk.cancel'),
+        danger: true,
+      });
+      if (!ok) return;
     }
+    if (!ensureTurnNotCanceled(msg)) return;
     msg.status = 'running';
     msg.errorMessage = '';
     msg.executeResult = undefined;
@@ -410,21 +519,31 @@ export default function useAgentSession() {
         },
       });
       msg.executeJobId = res.jobId;
+      if (!ensureTurnNotCanceled(msg)) {
+        try {
+          await cancelAgentJob(res.jobId);
+        } catch {
+          // ignore cancellation sync errors after local cancel
+        }
+        return;
+      }
       await pollExecuteJob(msg, res.jobId);
     } catch (error) {
+      if (!ensureTurnNotCanceled(msg)) return;
       msg.status = 'failed';
       msg.errorMessage = extractErrorMessage(error, 'Execute failed.');
     }
   }
 
   async function cancel(msg: ChatMessage): Promise<void> {
+    markTurnCanceled(msg);
+    msg.status = 'canceled';
     const jobId = msg.executeJobId || msg.planJobId;
     stopPolling(`${msg.id}:plan`);
     stopPolling(`${msg.id}:execute`);
     if (!jobId) return;
     try {
       await cancelAgentJob(jobId);
-      msg.status = 'canceled';
     } catch (error) {
       msg.errorMessage = extractErrorMessage(error, 'Cancel failed.');
     }

From 85eb326ca2d6a820c00b311b454b06f286292a9c Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:15:05 +0800
Subject: [PATCH 08/10] test(web): add tests for cancel safety, auto-execute
 read-only plans, and answer rendering

- Test cancel before planJobId arrives keeps turn canceled and does not start polling
- Test in-flight poll response after cancel cannot overwrite canceled status
- Test auto-execute of read-only low-risk plans in confirm policy
- Test write plans are not auto-executed in confirm policy
- Test read-only plans are not auto-executed in planOnly policy
- Test TurnEntry renders execution answer before plan summary
- Test StorageStatus normalizes ratio-like storagePercentage in (0,1]
---
 .../components/layout/StorageStatus.spec.ts   |  15 ++
 .../organisms/agent/TurnEntry.spec.ts         |  23 +++
 web/src/composables/useAgentSession.spec.ts   | 187 ++++++++++++++++++
 3 files changed, 225 insertions(+)

diff --git a/web/src/components/layout/StorageStatus.spec.ts b/web/src/components/layout/StorageStatus.spec.ts
index 7a8db2d..d19666f 100644
--- a/web/src/components/layout/StorageStatus.spec.ts
+++ b/web/src/components/layout/StorageStatus.spec.ts
@@ -66,4 +66,19 @@ describe('layout/StorageStatus', () => {
     const style = wrapper.find('.progress-bar-fill').attributes('style');
     expect(style).toContain('width: 100%;');
   });
+
+  it('converts ratio-like storagePercentage to percent when value is in (0, 1]', () => {
+    const wrapper = mount(StorageStatus, {
+      props: {
+        stats: buildStats({
+          storageUsed: 426,
+          storageLimit: 1000,
+          storageAvailable: 574,
+          storagePercentage: 0.426,
+        }),
+      },
+    });
+    const style = wrapper.find('.progress-bar-fill').attributes('style');
+    expect(style).toContain('width: 42.6%;');
+  });
 });
diff --git a/web/src/components/organisms/agent/TurnEntry.spec.ts b/web/src/components/organisms/agent/TurnEntry.spec.ts
index f9bdb37..bd18def 100644
--- a/web/src/components/organisms/agent/TurnEntry.spec.ts
+++ b/web/src/components/organisms/agent/TurnEntry.spec.ts
@@ -39,6 +39,29 @@ describe('organisms/agent/TurnEntry', () => {
     expect(w.text()).toContain('plan summary text');
   });
 
+  it('renders execution answer before the plan summary', () => {
+    const w = mount(TurnEntry, {
+      props: {
+        turn: baseTurn({
+          executeResult: {
+            planJobId: 'p-1',
+            executeJobId: 'e-1',
+            summary: 'execution summary text',
+            answer: '你上传了 3 部电影（按视频文件统计）。',
+            appliedActions: 1,
+            skippedActions: 0,
+            warnings: [],
+            finishedAt: '2026-05-20T00:01:00Z',
+          },
+        }),
+        policy: 'confirm',
+        focused: false,
+      },
+    });
+    expect(w.text()).toContain('3 部电影');
+    expect(w.text()).not.toContain('plan summary text');
+  });
+
   it('hides Execute button when policy=planOnly', () => {
     const w = mount(TurnEntry, {
       props: { turn: baseTurn(), policy: 'planOnly', focused: false },
diff --git a/web/src/composables/useAgentSession.spec.ts b/web/src/composables/useAgentSession.spec.ts
index aeaf117..ef1b101 100644
--- a/web/src/composables/useAgentSession.spec.ts
+++ b/web/src/composables/useAgentSession.spec.ts
@@ -12,6 +12,10 @@ vi.mock('../store/user', () => ({
   useUserStore: () => ({ user: { userId: 'u-1' } }),
 }));
 
+vi.mock('../store/locale', () => ({
+  useLocaleStore: () => ({ t: (key: string) => key }),
+}));
+
 import * as agentApi from '../api/agent';
 
 const STORAGE_KEY = 'fileflash.agent.sessions.v1';
@@ -26,10 +30,43 @@ const planResult = {
   costEstimate: { tokens: 10, toolCalls: 1, durationSecEstimate: 1 },
 };
 
+const readOnlyPlanResult = {
+  ...planResult,
+  proposedActions: [
+    {
+      step: 1,
+      tool: 'drive.countFiles',
+      input: { folderId: 'root', recursive: true, category: 'video' },
+      sideEffect: 'read',
+      riskLevel: 'low',
+      requiresConfirmation: false,
+      confirmationReason: null,
+    },
+  ],
+  requiresConfirmation: true,
+};
+
+const writePlanResult = {
+  ...planResult,
+  proposedActions: [
+    {
+      step: 1,
+      tool: 'drive.createFolder',
+      input: { parentFolderId: 'root', name: 'Movies' },
+      sideEffect: 'write',
+      riskLevel: 'medium',
+      requiresConfirmation: false,
+      confirmationReason: null,
+    },
+  ],
+  requiresConfirmation: true,
+};
+
 const execResult = {
   planJobId: 'job-1',
   executeJobId: 'job-2',
   summary: 'done',
+  answer: '你上传了 3 部电影（按视频文件统计）。',
   appliedActions: 1,
   skippedActions: 0,
   warnings: [],
@@ -41,6 +78,16 @@ const loadComposable = async () => {
   return mod;
 };
 
+const deferred = <T>() => {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 describe('useAgentSession', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -218,6 +265,79 @@ describe('useAgentSession', () => {
     expect(turn.agent.status).toBe('succeeded');
   });
 
+  it('auto-executes read-only low-risk plans in confirm policy', async () => {
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob)
+      .mockResolvedValueOnce({ jobId: 'job-1', status: 'succeeded', result: readOnlyPlanResult } as any)
+      .mockResolvedValueOnce({ jobId: 'job-2', status: 'succeeded', result: execResult } as any);
+    vi.mocked(agentApi.executeAgentPlan).mockResolvedValue({
+      jobId: 'job-2',
+      status: 'pending',
+      taskType: 'agent.execute',
+    });
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, activeTurns } = useAgentSession();
+    taskInput.value = '我上传了多少部电影？';
+    await sendMessage();
+
+    const turn = activeTurns.value[0];
+    expect(agentApi.executeAgentPlan).toHaveBeenCalled();
+    expect(turn.agent.executeResult?.answer).toContain('3 部电影');
+    expect(turn.agent.status).toBe('succeeded');
+  });
+
+  it('does not auto-execute write plans in confirm policy', async () => {
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'succeeded',
+      result: writePlanResult,
+    } as any);
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, activeTurns } = useAgentSession();
+    taskInput.value = '整理电影';
+    await sendMessage();
+
+    const turn = activeTurns.value[0];
+    expect(agentApi.executeAgentPlan).not.toHaveBeenCalled();
+    expect(turn.agent.executeJobId).toBeUndefined();
+    expect(turn.agent.status).toBe('succeeded');
+  });
+
+  it('does not auto-execute read-only plans in planOnly policy', async () => {
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'succeeded',
+      result: readOnlyPlanResult,
+    } as any);
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, policy, sendMessage, activeTurns } = useAgentSession();
+    policy.value = 'planOnly';
+    taskInput.value = '我上传了多少部电影？';
+    await sendMessage();
+
+    const turn = activeTurns.value[0];
+    expect(agentApi.executeAgentPlan).not.toHaveBeenCalled();
+    expect(turn.agent.executeResult).toBeUndefined();
+    expect(turn.agent.status).toBe('succeeded');
+  });
+
   it('runExecute surfaces backend response message when execute returns 409', async () => {
     vi.mocked(agentApi.planAgentTask).mockResolvedValue({
       jobId: 'job-1',
@@ -327,6 +447,73 @@ describe('useAgentSession', () => {
     expect(callsAfter).toBe(callsBefore);
   });
 
+  it('cancel before plan job id arrives keeps turn canceled and does not start polling', async () => {
+    const planGate = deferred<any>();
+    vi.mocked(agentApi.planAgentTask).mockReturnValue(planGate.promise);
+    vi.mocked(agentApi.cancelAgentJob).mockResolvedValue({
+      jobId: 'job-late',
+      status: 'canceled',
+      canceledAt: '2026-05-20T00:00:00Z',
+    });
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, cancel, activeTurns } = useAgentSession();
+    taskInput.value = 'hello';
+
+    const sendTask = sendMessage();
+    await Promise.resolve();
+    const turn = activeTurns.value[0];
+    await cancel(turn.agent);
+    expect(turn.agent.status).toBe('canceled');
+
+    planGate.resolve({
+      jobId: 'job-late',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    await sendTask;
+
+    expect(agentApi.getAgentJob).not.toHaveBeenCalled();
+    expect(agentApi.cancelAgentJob).toHaveBeenCalledWith('job-late');
+    expect(turn.agent.status).toBe('canceled');
+  });
+
+  it('in-flight poll response after cancel cannot overwrite canceled status', async () => {
+    const firstPoll = deferred<any>();
+    vi.mocked(agentApi.planAgentTask).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'pending',
+      taskType: 'agent.plan',
+    });
+    vi.mocked(agentApi.getAgentJob).mockReturnValue(firstPoll.promise);
+    vi.mocked(agentApi.cancelAgentJob).mockResolvedValue({
+      jobId: 'job-1',
+      status: 'canceled',
+      canceledAt: '2026-05-20T00:00:00Z',
+    });
+
+    const { default: useAgentSession } = await loadComposable();
+    const { taskInput, sendMessage, cancel, activeTurns } = useAgentSession();
+    taskInput.value = 'hello';
+
+    const sendTask = sendMessage();
+    await Promise.resolve();
+    await Promise.resolve();
+    const turn = activeTurns.value[0];
+    await cancel(turn.agent);
+    expect(turn.agent.status).toBe('canceled');
+
+    firstPoll.resolve({
+      jobId: 'job-1',
+      status: 'running',
+    });
+    await sendTask;
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(turn.agent.status).toBe('canceled');
+    expect(vi.mocked(agentApi.getAgentJob).mock.calls.length).toBe(1);
+  });
+
   it('reload — sessions persist via localStorage', async () => {
     const { default: useAgentSession, __resetForTests } = await loadComposable();
     const a = useAgentSession();

From f68fb8794d6f6652ffaa55a3f67dc9d59c82973e Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:15:14 +0800
Subject: [PATCH 09/10] feat(web): wire execution answer display, i18n confirm
 dialogs, and countFiles mock

- Add optional answer field to AgentExecutionResult type
- Add i18n keys for high-risk confirm and delete-session confirm (zh/en)
- Update mock handler to return countFiles actions and execution answer
- Render execution answer as primary result text in TurnEntry, hiding plan summary
- Add ui.confirm-based delete session dialog in AgentWorkspace
---
 .../components/organisms/agent/TurnEntry.vue  | 23 ++++++++----
 web/src/i18n/messages.ts                      | 24 +++++++++++++
 web/src/mock/handlers/agent.ts                | 35 +++++++++++++++++++
 .../pages/agent/workspace/AgentWorkspace.vue  | 19 +++++++++-
 web/src/types/agent.d.ts                      |  1 +
 5 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/web/src/components/organisms/agent/TurnEntry.vue b/web/src/components/organisms/agent/TurnEntry.vue
index 885533d..0173611 100644
--- a/web/src/components/organisms/agent/TurnEntry.vue
+++ b/web/src/components/organisms/agent/TurnEntry.vue
@@ -31,6 +31,10 @@ const isActive = computed(
   () => props.turn.agent.status === 'pending' || props.turn.agent.status === 'running',
 );
 
+const resultText = computed(
+  () => props.turn.agent.executeResult?.answer || props.turn.agent.executeResult?.summary || '',
+);
+
 const statusLabel = computed(() => {
   const key = `agent.v2.turn.status.${props.turn.agent.status}` as LocaleKey;
   return t(key);
@@ -67,11 +71,15 @@ const formatTime = (iso: string) => {
 
         <div v-if="isActive" class="ff-te__progress" />
 
-        <p v-if="turn.agent.planResult?.summary" class="ff-te__sum">
+        <p v-if="resultText" class="ff-te__sum ff-te__answer">
+          {{ resultText }}
+        </p>
+
+        <p v-else-if="turn.agent.planResult?.summary" class="ff-te__sum">
           {{ turn.agent.planResult.summary }}
         </p>
 
-        <section v-if="turn.agent.planResult?.proposedActions?.length" class="ff-te__actions">
+        <section v-if="!resultText && turn.agent.planResult?.proposedActions?.length" class="ff-te__actions">
           <PlanActionRow
             v-for="a in turn.agent.planResult.proposedActions"
             :key="a.step"
@@ -140,7 +148,7 @@ const formatTime = (iso: string) => {
 .ff-te__user-content { white-space: pre-wrap; color: var(--text-primary); }
 .ff-te__user-time {
   align-self: flex-end;
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   color: var(--text-tertiary); letter-spacing: var(--tracking-wide);
 }
 
@@ -156,12 +164,12 @@ const formatTime = (iso: string) => {
 
 .ff-te__agent-head { display: flex; align-items: center; justify-content: space-between; }
 .ff-te__role {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   text-transform: uppercase; letter-spacing: var(--tracking-wide);
   color: var(--text-tertiary);
 }
 .ff-te__status {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   text-transform: uppercase; letter-spacing: var(--tracking-wide);
 }
 .ff-te__status--pending, .ff-te__status--running { color: var(--ac); }
@@ -181,6 +189,7 @@ const formatTime = (iso: string) => {
 }
 
 .ff-te__sum { margin: 0; color: var(--text-primary); }
+.ff-te__answer { white-space: pre-wrap; }
 
 .ff-te__actions {
   border: 1px solid var(--border-subtle);
@@ -189,7 +198,7 @@ const formatTime = (iso: string) => {
 
 .ff-te__cost {
   display: flex; gap: var(--sp-md); align-items: baseline;
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
@@ -202,7 +211,7 @@ const formatTime = (iso: string) => {
 }
 .ff-te__warn { border-color: var(--status-warning); color: var(--status-warning); }
 .ff-te__warn-label {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
 }
 .ff-te__warn ul { margin: 4px 0 0; padding-left: 16px; }
diff --git a/web/src/i18n/messages.ts b/web/src/i18n/messages.ts
index 740ca2d..8d27119 100644
--- a/web/src/i18n/messages.ts
+++ b/web/src/i18n/messages.ts
@@ -564,6 +564,14 @@ export type LocaleKey =
   | 'agent.v2.skills.import.resultsLabel'
   | 'agent.v2.skills.import.error.readFailed'
   | 'agent.v2.skills.import.error.emptyJson'
+  | 'agent.v2.confirm.highRisk.title'
+  | 'agent.v2.confirm.highRisk.message'
+  | 'agent.v2.confirm.highRisk.confirm'
+  | 'agent.v2.confirm.highRisk.cancel'
+  | 'agent.v2.confirm.deleteSession.title'
+  | 'agent.v2.confirm.deleteSession.message'
+  | 'agent.v2.confirm.deleteSession.confirm'
+  | 'agent.v2.confirm.deleteSession.cancel'
   | 'footer.termsOfService'
   | 'footer.privacyPolicy';
 
@@ -1136,6 +1144,14 @@ export const LOCALE_MESSAGES: Record<AppLanguage, LocaleMessages> = {
     'agent.v2.skills.import.resultsLabel': '导入结果',
     'agent.v2.skills.import.error.readFailed': '读取文件失败。',
     'agent.v2.skills.import.error.emptyJson': '请先粘贴 JSON 或拖入文件。',
+    'agent.v2.confirm.highRisk.title': '高风险操作确认',
+    'agent.v2.confirm.highRisk.message': '本计划包含高风险动作，是否继续？',
+    'agent.v2.confirm.highRisk.confirm': '继续执行',
+    'agent.v2.confirm.highRisk.cancel': '取消',
+    'agent.v2.confirm.deleteSession.title': '删除会话',
+    'agent.v2.confirm.deleteSession.message': '将删除会话「{title}」及其全部回合，此操作无法撤销。',
+    'agent.v2.confirm.deleteSession.confirm': '删除',
+    'agent.v2.confirm.deleteSession.cancel': '取消',
     'footer.termsOfService': '使用条款',
     'footer.privacyPolicy': '隐私政策',
   },
@@ -1703,6 +1719,14 @@ export const LOCALE_MESSAGES: Record<AppLanguage, LocaleMessages> = {
     'agent.v2.skills.import.resultsLabel': 'RESULTS',
     'agent.v2.skills.import.error.readFailed': 'Failed to read file.',
     'agent.v2.skills.import.error.emptyJson': 'Paste JSON or drop a file first.',
+    'agent.v2.confirm.highRisk.title': 'High-risk action',
+    'agent.v2.confirm.highRisk.message': 'This plan contains high-risk actions. Continue?',
+    'agent.v2.confirm.highRisk.confirm': 'Continue',
+    'agent.v2.confirm.highRisk.cancel': 'Cancel',
+    'agent.v2.confirm.deleteSession.title': 'Delete session',
+    'agent.v2.confirm.deleteSession.message': 'Delete session "{title}" and all of its turns? This cannot be undone.',
+    'agent.v2.confirm.deleteSession.confirm': 'Delete',
+    'agent.v2.confirm.deleteSession.cancel': 'Cancel',
     'footer.termsOfService': 'Terms of Service',
     'footer.privacyPolicy': 'Privacy Policy',
   },
diff --git a/web/src/mock/handlers/agent.ts b/web/src/mock/handlers/agent.ts
index 525111b..09feeeb 100644
--- a/web/src/mock/handlers/agent.ts
+++ b/web/src/mock/handlers/agent.ts
@@ -15,6 +15,31 @@ const isTerminal = (status: string) => ['succeeded', 'failed', 'canceled'].inclu
 
 const pickPlanActions = (input: string): AgentProposedAction[] => {
   const normalized = input.toLowerCase();
+  if (
+    normalized.includes('多少') ||
+    normalized.includes('几部') ||
+    normalized.includes('how many') ||
+    normalized.includes('count')
+  ) {
+    return [
+      {
+        step: 1,
+        tool: 'drive.countFiles',
+        sideEffect: 'read',
+        riskLevel: 'low',
+        requiresConfirmation: false,
+        confirmationReason: null,
+        input: {
+          folderId: 'root',
+          recursive: true,
+          category:
+            normalized.includes('电影') || normalized.includes('视频') || normalized.includes('movie')
+              ? 'video'
+              : undefined,
+        },
+      },
+    ];
+  }
   if (normalized.includes('delete') || normalized.includes('删除')) {
     return [
       {
@@ -234,6 +259,7 @@ const scheduleExecuteLifecycle = (job: AgentBackgroundJob, plan: AgentPlanResult
       planJobId: plan.planJobId,
       executeJobId: job.jobId,
       summary: `Execution completed with ${plan.proposedActions.length} planned actions.`,
+      answer: mockExecutionAnswer(plan),
       appliedActions: plan.proposedActions.length,
       skippedActions: 0,
       warnings: [],
@@ -243,6 +269,15 @@ const scheduleExecuteLifecycle = (job: AgentBackgroundJob, plan: AgentPlanResult
   }, 1900);
 };
 
+const mockExecutionAnswer = (plan: AgentPlanResult) => {
+  const countAction = plan.proposedActions.find((action) => action.tool === 'drive.countFiles');
+  if (!countAction) return null;
+  if (countAction.input.category === 'video') {
+    return '你上传了 7 部电影（按视频文件统计）。';
+  }
+  return '你上传了 12 个文件。';
+};
+
 export const setupAgentMocks = () => {
   Mock.mock(/\/api\/v1\/agent\/plan$/, 'post', (options) => {
     const payload = JSON.parse(options.body || '{}') as PlanAgentRequest;
diff --git a/web/src/pages/agent/workspace/AgentWorkspace.vue b/web/src/pages/agent/workspace/AgentWorkspace.vue
index 69fa412..a713cb7 100644
--- a/web/src/pages/agent/workspace/AgentWorkspace.vue
+++ b/web/src/pages/agent/workspace/AgentWorkspace.vue
@@ -8,6 +8,8 @@ import SessionList from '../../../components/organisms/agent/SessionList.vue';
 import TaskTimeline from '../../../components/organisms/agent/TaskTimeline.vue';
 import TaskInputDock from '../../../components/organisms/agent/TaskInputDock.vue';
 import PlanInspector from '../../../components/organisms/agent/PlanInspector.vue';
+import { useLocaleStore } from '../../../store/locale';
+import { ui } from '../../../utils/ui';
 
 const {
   sessions, activeSessionId, activeTurns, policy, reasoningEffort, taskInput, isSending,
@@ -15,6 +17,9 @@ const {
   sendMessage, runExecute, cancel,
 } = useAgentSession();
 
+const localeStore = useLocaleStore();
+const t = localeStore.t;
+
 const focusedTurnId = ref<string | null>(null);
 
 const focusedTurn = computed<AgentTurn | null>(() =>
@@ -27,6 +32,18 @@ const turnOf = (id: string): ChatMessage | null =>
 const onExecute = (id: string) => { const m = turnOf(id); if (m) runExecute(m); };
 const onCancel  = (id: string) => { const m = turnOf(id); if (m) cancel(m); };
 const onHint = (text: string) => { taskInput.value = text; sendMessage(); };
+
+const onDeleteSession = async (id: string) => {
+  const target = sessions.value.find((s) => s.id === id);
+  const ok = await ui.confirm({
+    title: t('agent.v2.confirm.deleteSession.title'),
+    message: t('agent.v2.confirm.deleteSession.message').replace('{title}', target?.title || ''),
+    confirmText: t('agent.v2.confirm.deleteSession.confirm'),
+    cancelText: t('agent.v2.confirm.deleteSession.cancel'),
+    danger: true,
+  });
+  if (ok) deleteSession(id);
+};
 </script>
 
 <template>
@@ -37,7 +54,7 @@ const onHint = (text: string) => { taskInput.value = text; sendMessage(); };
       :active-id="activeSessionId"
       @select="switchSession"
       @create="createSession"
-      @delete="deleteSession"
+      @delete="onDeleteSession"
     />
     <div class="aw__center">
       <TaskTimeline
diff --git a/web/src/types/agent.d.ts b/web/src/types/agent.d.ts
index d55fe90..f143e2b 100644
--- a/web/src/types/agent.d.ts
+++ b/web/src/types/agent.d.ts
@@ -105,6 +105,7 @@ export interface AgentExecutionResult {
   planJobId: string;
   executeJobId: string;
   summary: string;
+  answer?: string | null;
   appliedActions: number;
   skippedActions: number;
   warnings: string[];

From b17a7c9637666ce923f74d443d73612912af98b9 Mon Sep 17 00:00:00 2001
From: 0neStep <146049978+AperturePlus@users.noreply.github.com>
Date: Mon, 25 May 2026 23:15:25 +0800
Subject: [PATCH 10/10] fix(web): normalize storagePercentage ratio in (0,1]
 and update typography tokens
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Normalize storagePercentage in (0,1] range by multiplying by 100; fall back to used/limit ratio when percentage is missing
- Add border-radius inheritance to progress-bar-fill; move margin to wrapper
- Update typography scale: body 13.5px→14px, small 12px→12.5px, label 10px→10.5px, data 12px→12.5px
- Add fallback CJK font to mono stack for better Chinese character rendering
- Replace hardcoded font-size values (9px, 11px, 10px) with CSS custom property references across agent components
- Guard planHash display behind isAdmin check in PlanInspector
---
 web/src/components/layout/StorageStatus.vue   | 27 ++++++++++++++-----
 web/src/components/molecules/Avatar.vue       |  4 +--
 web/src/components/molecules/Button.vue       |  2 +-
 web/src/components/molecules/Select.vue       |  3 ++-
 .../organisms/agent/PlanActionRow.vue         |  4 +--
 .../organisms/agent/PlanInspector.vue         | 13 +++++----
 .../organisms/agent/SessionItem.vue           |  2 +-
 .../organisms/agent/SessionList.vue           |  4 +--
 .../components/organisms/agent/SkillCard.vue  |  2 +-
 .../organisms/agent/SkillEditorPanel.vue      |  4 +--
 .../organisms/agent/SkillImportPanel.vue      |  2 +-
 .../organisms/agent/TaskTimeline.vue          |  4 +--
 web/src/components/templates/AgentLayout.vue  |  2 +-
 web/src/pages/agent/skills/AgentSkills.vue    |  2 +-
 web/src/styles/tokens/type.css                | 12 ++++-----
 15 files changed, 53 insertions(+), 34 deletions(-)

diff --git a/web/src/components/layout/StorageStatus.vue b/web/src/components/layout/StorageStatus.vue
index b1cbc51..0eaa011 100644
--- a/web/src/components/layout/StorageStatus.vue
+++ b/web/src/components/layout/StorageStatus.vue
@@ -17,10 +17,23 @@ const isLoading = ref(false);
 
 const storageData = computed(() => props.stats || localStats.value);
 const progressPercentage = computed(() => {
-  if (!storageData.value) return 0;
-  const raw = Number(storageData.value.storagePercentage);
-  if (!Number.isFinite(raw)) return 0;
-  return Math.min(100, Math.max(0, raw));
+  const stats = storageData.value;
+  if (!stats) return 0;
+
+  const raw = Number(stats.storagePercentage);
+  let normalizedPercentage: number;
+
+  if (Number.isFinite(raw)) {
+    normalizedPercentage = raw > 0 && raw <= 1 && stats.storageUsed > 0
+      ? raw * 100
+      : raw;
+  } else if (stats.storageLimit > 0) {
+    normalizedPercentage = (stats.storageUsed / stats.storageLimit) * 100;
+  } else {
+    normalizedPercentage = 0;
+  }
+
+  return Math.min(100, Math.max(0, normalizedPercentage));
 });
 const progressWidthPercentage = computed(() => {
   const stats = storageData.value;
@@ -105,17 +118,19 @@ onUnmounted(() => {
   padding: var(--spacing-sm) 0;
 }
 .progress-bar-wrapper {
+  margin-bottom: var(--spacing-sm);
+}
+.progress-bar {
   width: 100%;
   height: 12px;
   background-color: var(--color-bg-tertiary);
   border-radius: 6px;
   overflow: hidden;
-  margin-bottom: var(--spacing-sm);
 }
 .progress-bar-fill {
   height: 100%;
   background-color: var(--color-primary);
-  border-radius: 6px;
+  border-radius: inherit;
   transition: width 0.5s ease-in-out;
 }
 .stats-text {
diff --git a/web/src/components/molecules/Avatar.vue b/web/src/components/molecules/Avatar.vue
index 9b947b4..643f675 100644
--- a/web/src/components/molecules/Avatar.vue
+++ b/web/src/components/molecules/Avatar.vue
@@ -34,7 +34,7 @@ const initials = computed(() => {
   overflow: hidden;
   flex-shrink: 0;
 }
-.ff-avatar--md { width: 28px; height: 28px; font-size: 11px; }
-.ff-avatar--sm { width: 20px; height: 20px; font-size: 9px; }
+.ff-avatar--md { width: 28px; height: 28px; font-size: var(--text-small); }
+.ff-avatar--sm { width: 20px; height: 20px; font-size: var(--text-label); }
 .ff-avatar img { width: 100%; height: 100%; object-fit: cover; }
 </style>
diff --git a/web/src/components/molecules/Button.vue b/web/src/components/molecules/Button.vue
index 5ed969f..a9a20ae 100644
--- a/web/src/components/molecules/Button.vue
+++ b/web/src/components/molecules/Button.vue
@@ -50,7 +50,7 @@ defineEmits<{ click: [event: MouseEvent] }>();
 .ff-btn:disabled { opacity: 0.5; cursor: not-allowed; }
 
 .ff-btn--md { height: 32px; }
-.ff-btn--sm { height: 24px; padding: 0 10px; font-size: 9px; }
+.ff-btn--sm { height: 24px; padding: 0 10px; font-size: var(--text-label); }
 
 .ff-btn--primary { background: var(--ac); color: var(--ac-fg); }
 .ff-btn--primary:hover:not(:disabled) { filter: brightness(1.1); box-shadow: var(--mo-hover-bloom); }
diff --git a/web/src/components/molecules/Select.vue b/web/src/components/molecules/Select.vue
index 28330ad..324e53b 100644
--- a/web/src/components/molecules/Select.vue
+++ b/web/src/components/molecules/Select.vue
@@ -185,7 +185,8 @@ onBeforeUnmount(() => {
   cursor: pointer;
   transition: border-color var(--mo-duration-fast) var(--mo-easing);
 }
-.ff-select--sm .ff-select__trigger { height: 24px; font-size: 9px; }
+.ff-select--sm { font-size: var(--text-small); }
+.ff-select--sm .ff-select__trigger { height: 24px; }
 .ff-select--md .ff-select__trigger { height: 32px; }
 .ff-select__trigger:hover:not(:disabled),
 .ff-select.is-open .ff-select__trigger { border-color: var(--ac); }
diff --git a/web/src/components/organisms/agent/PlanActionRow.vue b/web/src/components/organisms/agent/PlanActionRow.vue
index d623058..c608f82 100644
--- a/web/src/components/organisms/agent/PlanActionRow.vue
+++ b/web/src/components/organisms/agent/PlanActionRow.vue
@@ -35,7 +35,7 @@ const expanded = ref(false);
   cursor: pointer;
   color: var(--text-secondary);
   font-family: var(--font-mono);
-  font-size: var(--text-label);
+  font-size: var(--text-small);
   letter-spacing: var(--tracking-wide);
   text-align: left;
 }
@@ -45,7 +45,7 @@ const expanded = ref(false);
   min-width: 20px;
 }
 .ff-par__tool { flex: 1; color: var(--text-primary); }
-.ff-par__se { font-size: 9px; padding: 1px 6px; }
+.ff-par__se { font-size: var(--text-small); padding: 1px 6px; }
 .ff-par__se--write { color: var(--status-warning); border-color: var(--status-warning); }
 .ff-par__input {
   margin: 0;
diff --git a/web/src/components/organisms/agent/PlanInspector.vue b/web/src/components/organisms/agent/PlanInspector.vue
index 1af2e86..29762be 100644
--- a/web/src/components/organisms/agent/PlanInspector.vue
+++ b/web/src/components/organisms/agent/PlanInspector.vue
@@ -2,12 +2,15 @@
 import { computed, ref } from 'vue';
 import StatBlock from '../../molecules/StatBlock.vue';
 import { useLocaleStore } from '../../../store/locale';
+import { useUserStore } from '../../../store/user';
 import type { AgentTurn } from '../../../composables/useAgentSession';
 
 const props = defineProps<{ turn?: AgentTurn | null }>();
 
 const localeStore = useLocaleStore();
 const t = localeStore.t;
+const userStore = useUserStore();
+const isAdmin = computed(() => userStore.isAdmin);
 
 const plan = computed(() => props.turn?.agent.planResult ?? null);
 const skillName = computed(() => plan.value?.chosenSkill?.name ?? '—');
@@ -38,7 +41,7 @@ const copyHash = async () => {
         <span class="ff-pi__key">{{ t('agent.v2.inspector.skill') }}</span>
         <span class="ff-pi__val">{{ skillName }}</span>
       </section>
-      <section class="ff-pi__sect">
+      <section v-if="isAdmin" class="ff-pi__sect">
         <span class="ff-pi__key">{{ t('agent.v2.inspector.planHash') }}</span>
         <button
           type="button"
@@ -82,21 +85,21 @@ const copyHash = async () => {
 .ff-pi__label {
   padding: var(--sp-sm) var(--sp-lg);
   border-bottom: 1px solid var(--border-default);
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
 .ff-pi__empty {
   padding: var(--sp-xl) var(--sp-lg);
   color: var(--text-tertiary);
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   text-align: center;
 }
 .ff-pi__body { padding: var(--sp-lg); display: flex; flex-direction: column; gap: var(--sp-md); }
 .ff-pi__sect { display: flex; flex-direction: column; gap: 2px; }
 .ff-pi__key {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
@@ -119,7 +122,7 @@ const copyHash = async () => {
 .ff-pi__hash:disabled { opacity: 0.5; cursor: not-allowed; }
 .ff-pi__hash:hover:not(:disabled) { border-color: var(--ac); }
 .ff-pi__copied {
-  font-size: 9px; color: var(--ac);
+  font-size: var(--text-small); color: var(--ac);
   letter-spacing: var(--tracking-wide);
 }
 .ff-pi__cost {
diff --git a/web/src/components/organisms/agent/SessionItem.vue b/web/src/components/organisms/agent/SessionItem.vue
index d6be769..d26dae3 100644
--- a/web/src/components/organisms/agent/SessionItem.vue
+++ b/web/src/components/organisms/agent/SessionItem.vue
@@ -67,7 +67,7 @@ const relativeTime = (iso: string): string => {
   overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
 }
 .ff-si__time {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   color: var(--text-tertiary);
   letter-spacing: var(--tracking-wide);
 }
diff --git a/web/src/components/organisms/agent/SessionList.vue b/web/src/components/organisms/agent/SessionList.vue
index 075e38d..1586462 100644
--- a/web/src/components/organisms/agent/SessionList.vue
+++ b/web/src/components/organisms/agent/SessionList.vue
@@ -51,7 +51,7 @@ const t = localeStore.t;
 }
 .ff-sl__label {
   font-family: var(--font-mono);
-  font-size: var(--text-label);
+  font-size: var(--text-small);
   letter-spacing: var(--tracking-wide);
   text-transform: uppercase;
   color: var(--text-tertiary);
@@ -61,7 +61,7 @@ const t = localeStore.t;
   padding: var(--sp-lg) var(--sp-md);
   color: var(--text-tertiary);
   font-family: var(--font-mono);
-  font-size: var(--text-label);
+  font-size: var(--text-small);
   letter-spacing: var(--tracking-wide);
   text-transform: uppercase;
   text-align: center;
diff --git a/web/src/components/organisms/agent/SkillCard.vue b/web/src/components/organisms/agent/SkillCard.vue
index 4ba8955..a3465fb 100644
--- a/web/src/components/organisms/agent/SkillCard.vue
+++ b/web/src/components/organisms/agent/SkillCard.vue
@@ -47,7 +47,7 @@ const t = localeStore.t;
   font-weight: var(--weight-bold);
   color: var(--text-primary);
 }
-.ff-sc__vis { font-size: 9px; letter-spacing: var(--tracking-wide); text-transform: uppercase; }
+.ff-sc__vis { font-size: var(--text-label); letter-spacing: var(--tracking-wide); text-transform: uppercase; }
 .ff-sc__vis--global { color: var(--ac); border-color: var(--ac); }
 .ff-sc__vis--private { color: var(--status-warning); border-color: var(--status-warning); }
 .ff-sc__key {
diff --git a/web/src/components/organisms/agent/SkillEditorPanel.vue b/web/src/components/organisms/agent/SkillEditorPanel.vue
index e3eee95..6a631c4 100644
--- a/web/src/components/organisms/agent/SkillEditorPanel.vue
+++ b/web/src/components/organisms/agent/SkillEditorPanel.vue
@@ -132,7 +132,7 @@ const onSubmit = () => {
 }
 .ff-sep__field { display: flex; flex-direction: column; gap: 6px; }
 .ff-sep__lbl {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-secondary);
 }
@@ -157,7 +157,7 @@ const onSubmit = () => {
 }
 .ff-sep__sum {
   cursor: pointer;
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
   padding: var(--sp-xs) 0;
diff --git a/web/src/components/organisms/agent/SkillImportPanel.vue b/web/src/components/organisms/agent/SkillImportPanel.vue
index 824cba2..7739a9d 100644
--- a/web/src/components/organisms/agent/SkillImportPanel.vue
+++ b/web/src/components/organisms/agent/SkillImportPanel.vue
@@ -101,7 +101,7 @@ const onSubmit = () => {
   display: flex; align-items: center; justify-content: space-between; gap: var(--sp-sm);
 }
 .ff-sip__label, .ff-sip__lbl {
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
diff --git a/web/src/components/organisms/agent/TaskTimeline.vue b/web/src/components/organisms/agent/TaskTimeline.vue
index 39c2758..912febe 100644
--- a/web/src/components/organisms/agent/TaskTimeline.vue
+++ b/web/src/components/organisms/agent/TaskTimeline.vue
@@ -79,7 +79,7 @@ watch(
   padding: var(--sp-sm) var(--sp-lg);
   background: var(--surface-base);
   border-bottom: 1px solid var(--border-default);
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
@@ -90,7 +90,7 @@ watch(
 .ff-tt__hint {
   margin: 0;
   font-family: var(--font-mono);
-  font-size: var(--text-label);
+  font-size: var(--text-small);
   letter-spacing: var(--tracking-wide);
   text-transform: uppercase;
   color: var(--text-tertiary);
diff --git a/web/src/components/templates/AgentLayout.vue b/web/src/components/templates/AgentLayout.vue
index 8e234d6..f5d6159 100644
--- a/web/src/components/templates/AgentLayout.vue
+++ b/web/src/components/templates/AgentLayout.vue
@@ -59,7 +59,7 @@ const onTab = (v: string | number) =>
 }
 .agent-layout__brand {
   font-family: var(--font-mono);
-  font-size: var(--text-label);
+  font-size: var(--text-small);
   letter-spacing: var(--tracking-wide);
   text-transform: uppercase;
   color: var(--text-tertiary);
diff --git a/web/src/pages/agent/skills/AgentSkills.vue b/web/src/pages/agent/skills/AgentSkills.vue
index 0822dd4..7f202bc 100644
--- a/web/src/pages/agent/skills/AgentSkills.vue
+++ b/web/src/pages/agent/skills/AgentSkills.vue
@@ -88,7 +88,7 @@ onMounted(() => { s.loadMarketplace(); s.loadMySkills(); });
 .as__grid { display: grid; gap: var(--sp-md); grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); }
 .as__empty {
   grid-column: 1 / -1; padding: var(--sp-xl); text-align: center;
-  font-family: var(--font-mono); font-size: var(--text-label);
+  font-family: var(--font-mono); font-size: var(--text-small);
   letter-spacing: var(--tracking-wide); text-transform: uppercase;
   color: var(--text-tertiary);
 }
diff --git a/web/src/styles/tokens/type.css b/web/src/styles/tokens/type.css
index 27f9fd8..8b0b873 100644
--- a/web/src/styles/tokens/type.css
+++ b/web/src/styles/tokens/type.css
@@ -1,22 +1,22 @@
 /* web/src/styles/tokens/type.css
  * Font stacks + size scale + weight + line-height + letter-spacing.
  * Sizes follow a deliberate non-linear ratio aligned to the Industrial
- * Dashboard identity. Body 13.5px is the anchor; everything else scales
+ * Dashboard identity. Body 14px is the anchor; everything else scales
  * around it.
  */
 
 :root {
   --font-sans: 'IBM Plex Sans', 'IBM Plex Sans SC', 'PingFang SC', system-ui, -apple-system, sans-serif;
-  --font-mono: 'JetBrains Mono', 'Consolas', 'Monaco', 'Courier New', monospace;
+  --font-mono: 'JetBrains Mono', 'IBM Plex Sans SC', 'PingFang SC', 'Consolas', 'Monaco', 'Courier New', monospace;
 
   /* Size scale */
   --text-display:   32px;
   --text-h1:        22px;
   --text-h2:        17px;
-  --text-body:      13.5px;
-  --text-small:     12px;
-  --text-label:     10px;
-  --text-data:      12px;
+  --text-body:      14px;
+  --text-small:     12.5px;
+  --text-label:     10.5px;
+  --text-data:      12.5px;
   --text-data-big:  22px;
 
   /* Weight scale */