OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
fix: cherry pick sync warning fix (#2421)
Wallgaubd8b5a0dd5d7
diff --git a/frontend/components/task-dialog/file-list.tsx b/frontend/components/task-dialog/file-list.tsxindex c6b082b32..a72cb0218 100644--- a/frontend/components/task-dialog/file-list.tsx+++ b/frontend/components/task-dialog/file-list.tsx@@ -7,6 +7,7 @@ import { useIsCloudBrand } from "@/contexts/brand-context";import type { Task } from "@/contexts/task-context";import { analyzeTaskFileIngestionFailure } from "@/lib/task-error-display";import {+ getDeletedAtSourceMessage,getTaskFileDialogStatusLabel,getTaskFileName,isTaskFileFailed,@@ -231,10 +232,12 @@ export function TaskDialogFileList({? "text-muted-foreground": failed? "text-destructive"- : rowStatusLabel === "Complete"+ : rowStatusLabel === "Complete" ||+ rowStatusLabel === "Removed"? "text-emerald-600 dark:text-emerald-400": "text-muted-foreground",)}+ title={getDeletedAtSourceMessage(fileInfo)}>{statusLabel}</span>diff --git a/frontend/components/task-error-content.test.tsx b/frontend/components/task-error-content.test.tsxindex 6e1bcd4d1..befffac5f 100644--- a/frontend/components/task-error-content.test.tsx+++ b/frontend/components/task-error-content.test.tsx@@ -99,6 +99,28 @@ describe("TaskErrorContent — cancellation display", () => {expect(container.firstChild).toBeNull();});+ it("does not treat a source-deleted file as a warning", () => {+ const task = makeTask({+ status: "completed",+ successful_files: 1,+ files: {+ "gone.pdf": {+ status: "completed",+ result: {+ reason: "deleted_at_source",+ message:+ "File no longer exists at source; removed from index (1 chunk(s) deleted).",+ },+ },+ },+ });++ const { container } = renderWithProviders(<TaskErrorContent task={task} />);++ expect(container.firstChild).toBeNull();+ expect(screen.queryByText("Warning")).not.toBeInTheDocument();+ });+it("shows 'Failed' label when there are real (non-cancellation) failures", () => {const task = makeTask({status: "failed",diff --git a/frontend/contexts/task-context.test.tsx b/frontend/contexts/task-context.test.tsxindex f51e30857..19b351608 100644--- a/frontend/contexts/task-context.test.tsx+++ b/frontend/contexts/task-context.test.tsx@@ -696,3 +696,81 @@ describe("TaskProvider — skipped files (duplicate detection)", () => {);});});++describe("TaskProvider — source-deleted overlays", () => {+ it("does not create a knowledge overlay for a source-deleted file", async () => {+ const qc = createTestQueryClient();+ const task = makeTask({+ status: "running",+ files: {+ "file-id-1": {+ status: "completed",+ filename: "gone.pdf",+ result: { reason: "deleted_at_source" },+ },+ },+ });+ server.use(+ http.get("/api/tasks/enhanced", () =>+ HttpResponse.json({ tasks: [task] }),+ ),+ );++ const { result } = renderHook(() => useTask(), { wrapper: wrapper(qc) });++ await waitFor(() => expect(result.current.tasks).toHaveLength(1));+ expect(+ result.current.files.some((file) => file.source_url === "file-id-1"),+ ).toBe(false);+ });++ it("drops a processing overlay when the file is later deleted at the source", async () => {+ const qc = createTestQueryClient();+ let callCount = 0;+ const runningTask = makeTask({+ status: "running",+ files: {+ "file-id-1": { status: "running", filename: "gone.pdf" },+ },+ });+ const deletedTask = makeTask({+ status: "running",+ files: {+ "file-id-1": {+ status: "completed",+ filename: "gone.pdf",+ result: { reason: "deleted_at_source" },+ },+ },+ });++ server.use(+ http.get("/api/tasks/enhanced", () => {+ callCount++;+ return HttpResponse.json({+ tasks: [callCount === 1 ? runningTask : deletedTask],+ });+ }),+ );++ const { result } = renderHook(() => useTask(), { wrapper: wrapper(qc) });++ await waitFor(() =>+ expect(+ result.current.files.some((file) => file.source_url === "file-id-1"),+ ).toBe(true),+ );++ await waitFor(() => expect(callCount).toBeGreaterThanOrEqual(2), {+ timeout: 5000,+ });++ await waitFor(+ () =>+ expect(+ result.current.files.some((file) => file.source_url === "file-id-1"),+ ).toBe(false),+ { timeout: 5000 },+ );+ });+});diff --git a/frontend/contexts/task-context.tsx b/frontend/contexts/task-context.tsxindex 405c3bf16..fdd8a4f6f 100644--- a/frontend/contexts/task-context.tsx+++ b/frontend/contexts/task-context.tsx@@ -45,6 +45,7 @@ import {getSkippedFileCount,getSuccessfulFileCount,hasFailedFileEntries,+ isDeletedAtSourceFile,isTaskInProgressStatus,isTerminalFailedTask,} from "@/lib/task-utils";@@ -381,6 +382,27 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {// Use the filename from backend if available, otherwise extract from pathconst fileName =fileInfoEntry.filename || filePath.split("/").pop() || filePath;++ // Source-deleted cleanup is completed, not an ingest. Drop any+ // processing overlay so the knowledge table does not show a ghost row.+ if (isDeletedAtSourceFile(fileInfoEntry)) {+ setFiles((prevFiles) => {+ const existingFileIndex = findTaskFileOverlayIndex(+ prevFiles,+ currentTask.task_id,+ filePath,+ fileName,+ );+ if (existingFileIndex < 0) {+ return prevFiles;+ }+ return prevFiles.filter(+ (_, index) => index !== existingFileIndex,+ );+ });+ return;+ }+const fileStatus = fileInfoEntry.status ?? "processing";// Map backend file status to our TaskFile status.diff --git a/frontend/lib/task-utils.test.ts b/frontend/lib/task-utils.test.tsindex 5def23fd7..add17514a 100644--- a/frontend/lib/task-utils.test.ts+++ b/frontend/lib/task-utils.test.ts@@ -1,8 +1,13 @@import { describe, expect, it } from "vitest";-import type { TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";+import type { Task, TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";import {countTaskFileEntriesByCategory,+ finalizeProcessingOverlaysForEnhancedTask,+ getDeletedAtSourceMessage,getTaskFileDialogStatusLabel,+ getTaskIssueFileEntries,+ isDeletedAtSourceFile,+ isTaskFileWarning,isTerminalTaskStatus,} from "./task-utils";@@ -74,6 +79,183 @@ describe("countTaskFileEntriesByCategory — cancelled bucket", () => {});});+describe("deleted_at_source is successful cleanup, not a warning", () => {+ const deletedAtSource = entry({+ status: "completed",+ result: {+ reason: "deleted_at_source",+ message:+ "File no longer exists at source; removed from index (1 chunk(s) deleted).",+ },+ });++ it("does not classify a source-deleted file as a warning", () => {+ expect(isDeletedAtSourceFile(deletedAtSource)).toBe(true);+ expect(isTaskFileWarning(deletedAtSource)).toBe(false);+ expect(isTaskFileWarning(entry({ status: "skipped" }))).toBe(true);+ });++ it("still does not treat a leftover skipped source-deleted file as a warning", () => {+ expect(+ isTaskFileWarning(+ entry({+ status: "skipped",+ result: { reason: "deleted_at_source" },+ }),+ ),+ ).toBe(false);+ });++ it("labels a source-deleted file Removed and keeps the cleanup message", () => {+ expect(getTaskFileDialogStatusLabel(deletedAtSource)).toBe("Removed");+ expect(getDeletedAtSourceMessage(deletedAtSource)).toContain(+ "removed from index",+ );+ expect(getDeletedAtSourceMessage(entry({ status: "completed" }))).toBe(+ undefined,+ );+ expect(+ getDeletedAtSourceMessage(+ entry({+ status: "completed",+ result: { reason: "deleted_at_source", message: " " },+ }),+ ),+ ).toBeUndefined();+ });++ it("buckets a source-deleted file as completed, not warning", () => {+ const counts = countTaskFileEntriesByCategory([+ ["gone.pdf", deletedAtSource],+ ]);+ expect(counts.completed).toBe(1);+ expect(counts.warning).toBe(0);+ });++ it("omits source-deleted files from the issue list", () => {+ const task: Task = {+ task_id: "t1",+ status: "completed",+ created_at: "2026-09-16T10:00:00Z",+ updated_at: "2026-09-16T10:00:00Z",+ successful_files: 1,+ files: { "gone.pdf": deletedAtSource },+ };+ expect(getTaskIssueFileEntries(task)).toEqual([]);+ });++ it("drops processing overlays instead of promoting them to active", () => {+ const task: Task = {+ task_id: "task-1",+ status: "running",+ created_at: "2026-09-16T10:00:00Z",+ updated_at: "2026-09-16T10:00:00Z",+ files: { "file-id-1": deletedAtSource },+ };+ const overlays = [+ {+ task_id: "task-1",+ source_url: "file-id-1",+ status: "processing" as const,+ },+ {+ task_id: "task-1",+ source_url: "other.pdf",+ status: "processing" as const,+ },+ ];++ const next = finalizeProcessingOverlaysForEnhancedTask(overlays, task, [+ "file-id-1",+ ]);++ expect(next).toEqual([+ {+ task_id: "task-1",+ source_url: "other.pdf",+ status: "processing",+ },+ ]);+ });++ it("drops source-deleted overlays when the whole task completes", () => {+ const task: Task = {+ task_id: "task-1",+ status: "completed",+ created_at: "2026-09-16T10:00:00Z",+ updated_at: "2026-09-16T10:00:00Z",+ files: { "file-id-1": deletedAtSource },+ };+ const overlays = [+ {+ task_id: "task-1",+ source_url: "file-id-1",+ status: "processing" as const,+ },+ ];++ expect(finalizeProcessingOverlaysForEnhancedTask(overlays, task)).toEqual(+ [],+ );+ });++ it("leaves overlays for other tasks and already-active files unchanged", () => {+ const task: Task = {+ task_id: "task-1",+ status: "running",+ created_at: "2026-09-16T10:00:00Z",+ updated_at: "2026-09-16T10:00:00Z",+ files: { "file-id-1": deletedAtSource },+ };+ const overlays = [+ {+ task_id: "other-task",+ source_url: "file-id-1",+ status: "processing" as const,+ },+ {+ task_id: "task-1",+ source_url: "already.pdf",+ status: "active" as const,+ },+ ];++ expect(+ finalizeProcessingOverlaysForEnhancedTask(overlays, task, ["file-id-1"]),+ ).toEqual(overlays);+ });++ it("promotes a disappeared completed ingest overlay to active", () => {+ const task: Task = {+ task_id: "task-1",+ status: "running",+ created_at: "2026-09-16T10:00:00Z",+ updated_at: "2026-09-16T10:00:00Z",+ files: {},+ };+ const overlays = [+ {+ task_id: "task-1",+ source_url: "ingested.pdf",+ status: "processing" as const,+ },+ ];++ expect(+ finalizeProcessingOverlaysForEnhancedTask(overlays, task, [+ "ingested.pdf",+ ]),+ ).toEqual([+ {+ task_id: "task-1",+ source_url: "ingested.pdf",+ status: "active",+ error: undefined,+ },+ ]);+ });+});+describe("isTerminalTaskStatus — cancelled status", () => {it("treats 'cancelled' as a terminal status", () => {expect(isTerminalTaskStatus("cancelled")).toBe(true);diff --git a/frontend/lib/task-utils.ts b/frontend/lib/task-utils.tsindex 9f1f7a375..d934adb5d 100644--- a/frontend/lib/task-utils.ts+++ b/frontend/lib/task-utils.ts@@ -24,8 +24,33 @@ export type TaskFileFilterOptions = {task?: Task;};+function getFileResultReason(fileInfo: TaskFileEntry): string | undefined {+ const result = fileInfo.result;+ if (!result || typeof result !== "object" || Array.isArray(result)) {+ return undefined;+ }+ const reason = (result as { reason?: unknown }).reason;+ return typeof reason === "string" ? reason : undefined;+}++export function isDeletedAtSourceFile(fileInfo: TaskFileEntry): boolean {+ return getFileResultReason(fileInfo) === "deleted_at_source";+}++export function getDeletedAtSourceMessage(+ fileInfo: TaskFileEntry,+): string | undefined {+ if (!isDeletedAtSourceFile(fileInfo)) {+ return undefined;+ }+ const message = (fileInfo.result as { message?: unknown }).message;+ return typeof message === "string" && message.trim()+ ? message.trim()+ : undefined;+}+function isTaskFileCompleted(fileInfo: TaskFileEntry): boolean {- return fileInfo.status === "completed";+ return fileInfo.status === "completed" || isDeletedAtSourceFile(fileInfo);}export function isTaskFileFailed(fileInfo: TaskFileEntry): boolean {@@ -33,7 +58,8 @@ export function isTaskFileFailed(fileInfo: TaskFileEntry): boolean {}export function isTaskFileWarning(fileInfo: TaskFileEntry): boolean {- return fileInfo.status === "skipped";+ // Source-deleted files are successful cleanup, not a skip warning.+ return fileInfo.status === "skipped" && !isDeletedAtSourceFile(fileInfo);}export function getTaskFileDialogStatusLabel(@@ -54,6 +80,9 @@ export function getTaskFileDialogStatusLabel(}return buildRowStatusLabel("unknown");}+ if (isDeletedAtSourceFile(fileInfo)) {+ return "Removed";+ }if (isTaskFileWarning(fileInfo)) {return "Warning";}@@ -153,7 +182,7 @@ function getTaskFileStatusCategory(return "indexing";}- if (status === "completed") {+ if (isTaskFileCompleted(fileInfo)) {return "completed";}@@ -284,8 +313,8 @@ export function getSuccessfulFileCount(task: Task): number {const skipped = getSkippedFileCount(task);return Math.max(0, task.successful_files - skipped);}- return Object.values(task.files || {}).filter(- (fileInfo) => fileInfo?.status === "completed",+ return Object.values(task.files || {}).filter((fileInfo) =>+ fileInfo ? isTaskFileCompleted(fileInfo) : false,).length;}@@ -414,6 +443,9 @@ interface ProcessingFileOverlay {* Promote local processing overlays when the enhanced list omits completed files.* Pass `disappearedPaths` while the task is in progress; omit it when the task completes* to finalize every remaining processing file for that task.+ *+ * Source-deleted cleanups are completed-but-visible: drop their overlay instead+ * of promoting it to `active`, or the knowledge table would show a ghost ingest.*/export function finalizeProcessingOverlaysForEnhancedTask<T extends ProcessingFileOverlay,@@ -422,19 +454,27 @@ export function finalizeProcessingOverlaysForEnhancedTask<disappearedPaths === undefined ? null : new Set(disappearedPaths);let changed = false;- const updated = prevFiles.map((file) => {+ const updated: T[] = [];+ for (const file of prevFiles) {if (file.task_id !== currentTask.task_id) {- return file;+ updated.push(file);+ continue;}if (pathsFilter !== null && !pathsFilter.has(file.source_url)) {- return file;+ updated.push(file);+ continue;}// Overlays can still be "failed" until the list poll sees a retry as running.if (file.status !== "processing" && file.status !== "failed") {- return file;+ updated.push(file);+ continue;}const entry = currentTask.files?.[file.source_url];+ if (entry && isDeletedAtSourceFile(entry)) {+ changed = true;+ continue;+ }if (entry && isTaskFileFailed(entry)) {if (file.status === "failed") {const error =@@ -442,7 +482,8 @@ export function finalizeProcessingOverlaysForEnhancedTask<? entry.error.trim(): file.error;if (error === file.error) {- return file;+ updated.push(file);+ continue;}}changed = true;@@ -450,13 +491,14 @@ export function finalizeProcessingOverlaysForEnhancedTask<typeof entry.error === "string" && entry.error.trim().length > 0? entry.error.trim(): file.error;- return { ...file, status: "failed" as const, error };+ updated.push({ ...file, status: "failed" as const, error });+ continue;}// Left the enhanced list (completed files are omitted) or task finished.changed = true;- return { ...file, status: "active" as const, error: undefined };- });+ updated.push({ ...file, status: "active" as const, error: undefined });+ }- return changed ? (updated as T[]) : prevFiles;+ return changed ? updated : prevFiles;}diff --git a/src/models/processors.py b/src/models/processors.pyindex bdee0021a..0c1026828 100644--- a/src/models/processors.py+++ b/src/models/processors.py@@ -416,13 +416,18 @@ class TaskProcessor:keep_filenames: list[str] | None = None,shared: bool = False,connector_type: str | None = None,+ *,+ ignore_errors: bool = True,) -> int:"""Delete indexed chunks for a connector file by its STABLE id.Deletion semantics (dual-field id match, connector/owner/shared scoping,- rename ``keep_filenames``) live in ``connectors.chunk_cleanup``. This- wrapper is best-effort: logs and returns 0 on failure so a cleanup miss- never fails the task.+ rename ``keep_filenames``) live in ``connectors.chunk_cleanup``.++ Rename cleanup is best-effort (``ignore_errors=True``): logs and returns+ 0 so a miss never fails an ingest that can still re-index the new name.+ Source-deleted cleanup passes ``ignore_errors=False`` so a real index+ failure fails the file task instead of reporting success.``connector_type`` scopes the match to one connector type — the samevalue the chunks were indexed under — so an id that collides with a@@ -456,7 +461,9 @@ class TaskProcessor:file_id=file_id,error=str(e),)- return 0+ if ignore_errors:+ return 0+ raiseasync def process_document_standard(self,@@ -1159,32 +1166,46 @@ class ConnectorFileProcessor(TaskProcessor):self.user_id, self.jwt_token))- deleted_chunks = await self._delete_connector_chunks(- file_id,- opensearch_client,- self.user_id,- shared=await self._resolve_shared(- file_id, opensearch_client, connector_type- ),- connector_type=connector_type,- )+ try:+ deleted_chunks = await self._delete_connector_chunks(+ file_id,+ opensearch_client,+ self.user_id,+ shared=await self._resolve_shared(+ file_id, opensearch_client, connector_type+ ),+ connector_type=connector_type,+ ignore_errors=False,+ )+ except Exception:+ file_task.status = TaskStatus.FAILED+ file_task.error = (+ "File no longer exists at source, but removing it "+ "from the index failed."+ )+ file_task.updated_at = time.time()+ upload_task.failed_files += 1+ return- logger.warning(+ logger.info("File no longer exists at source — removed from index",file_id=file_id,connection_id=self.connection_id,deleted_chunks=deleted_chunks,- error=str(e),+ source_error=str(e),)- file_task.status = TaskStatus.SKIPPED+ # Successful cleanup: the file is gone at the source and its+ # chunks were removed. Mark completed (not skipped) so the+ # tasks view does not treat this as a warning. Enhanced+ # listing still surfaces this reason so the dialog can show+ # it as Removed instead of omitting it like a normal ingest.+ file_task.status = TaskStatus.COMPLETED+ file_task.error = Nonefile_task.result = {- "status": "skipped",+ "status": "completed","reason": "deleted_at_source","deleted_chunks": deleted_chunks,- # Human-readable message so the tasks view shows this- # successful cleanup instead of falling back to- # "Unknown error" for a skip with no message.- "warning": (+ "message": (f"File no longer exists at source; removed from index "f"({deleted_chunks} chunk(s) deleted)."),diff --git a/src/services/task_service.py b/src/services/task_service.pyindex 931eb9e6f..e0b966d41 100644--- a/src/services/task_service.py+++ b/src/services/task_service.py@@ -1104,6 +1104,17 @@ class TaskService:"status": "accepted",}+ @staticmethod+ def _keep_completed_file_in_list(file_task: FileTask) -> bool:+ """Source-deleted cleanups stay visible so the UI can show Removed.++ Normal completed ingests are omitted from the task file list to keep it+ tidy. A file that was removed from the index because it disappeared at+ the source is also completed, but dropping it would hide the cleanup.+ """+ result = file_task.result or {}+ return result.get("reason") == "deleted_at_source"+def _serialize_file_task(self, file_task: FileTask) -> dict:"""Serialize a FileTask to the standard dict shape."""return {@@ -1483,7 +1494,13 @@ class TaskService:# the list tidy. Preview-mode tasks instead need every file# (including completed ones) so the live preview carousel can# still enumerate them and render their cached Docling layout.- if file_task.status != TaskStatus.COMPLETED or upload_task.preview_mode:+ # Source-deleted cleanups are completed but must stay visible+ # as successful removals, not vanish like a normal ingest.+ if (+ file_task.status != TaskStatus.COMPLETED+ or upload_task.preview_mode+ or self._keep_completed_file_in_list(file_task)+ ):entry = self._serialize_file_task(file_task)if file_task.status == TaskStatus.FAILED:metadata = self._infer_failure_metadata(file_task)@@ -1544,7 +1561,9 @@ class TaskService:file_statuses = {}for file_path, file_task in upload_task.file_tasks.items():- if file_task.status.value != "completed":+ if file_task.status.value != "completed" or self._keep_completed_file_in_list(+ file_task+ ):file_statuses[file_path] = {"status": file_task.status.value,"result": file_task.result,diff --git a/tests/unit/test_connector_processor_filename_dedupe.py b/tests/unit/test_connector_processor_filename_dedupe.pyindex 84423de08..39f61f104 100644--- a/tests/unit/test_connector_processor_filename_dedupe.py+++ b/tests/unit/test_connector_processor_filename_dedupe.py@@ -219,9 +219,11 @@ async def test_connector_processor_deletes_chunks_when_source_returns_404(await processor.process_item(upload_task, "file-id-1", file_task)- assert file_task.status == TaskStatus.SKIPPED+ assert file_task.status == TaskStatus.COMPLETEDassert (file_task.result or {}).get("reason") == "deleted_at_source"assert (file_task.result or {}).get("deleted_chunks") == 1+ assert "warning" not in (file_task.result or {})+ assert "removed from index" in ((file_task.result or {}).get("message") or "")assert upload_task.successful_files == 1# Concrete chunk deletes go through the backend write client.backend_write_client.delete.assert_awaited_once()@@ -241,6 +243,42 @@ async def test_connector_processor_deletes_chunks_when_source_returns_404(assert {"connector_type": "sharepoint"} in terms+async def test_connector_processor_fails_when_source_deleted_chunk_cleanup_errors(+ monkeypatch,+):+ """If the file is gone at source but index cleanup raises, the file task+ must fail so the UI does not report a successful removal."""+ monkeypatch.setattr("config.settings.DISABLE_INGEST_WITH_LANGFLOW", True)+ processor = _build_connector_processor(replace_duplicates=False)++ connector = MagicMock()+ connector.get_file_content = AsyncMock(side_effect=FileNotFoundError("404 Not Found"))+ processor.connector_service.get_connector = AsyncMock(return_value=connector)+ connection = MagicMock()+ connection.connector_type = "sharepoint"+ processor.connector_service.connection_manager = MagicMock()+ processor.connector_service.connection_manager.get_connection = AsyncMock(+ return_value=connection+ )++ file_task = _make_file_task()+ upload_task = _make_upload_task()++ with patch(+ "connectors.chunk_cleanup.delete_connector_file_chunks",+ new=AsyncMock(side_effect=RuntimeError("opensearch unavailable")),+ ):+ await processor.process_item(upload_task, "file-id-1", file_task)++ assert file_task.status == TaskStatus.FAILED+ assert file_task.error == (+ "File no longer exists at source, but removing it from the index failed."+ )+ assert upload_task.failed_files == 1+ assert upload_task.successful_files == 0++@pytest.mark.asyncioasync def test_connector_processor_indexes_cleaned_filename(monkeypatch):"""MIME-enforced extensions must be indexed under the same name used for dedupe."""@@ -473,9 +511,11 @@ async def test_langflow_connector_processor_deletes_chunks_when_source_returns_4await processor.process_item(upload_task, "file-id-1", file_task)- assert file_task.status == TaskStatus.SKIPPED+ assert file_task.status == TaskStatus.COMPLETEDassert (file_task.result or {}).get("reason") == "deleted_at_source"assert (file_task.result or {}).get("deleted_chunks") == 1+ assert "warning" not in (file_task.result or {})+ assert "removed from index" in ((file_task.result or {}).get("message") or "")assert file_task.error is Noneassert upload_task.successful_files == 1assert upload_task.failed_files == 0diff --git a/tests/unit/test_task_service.py b/tests/unit/test_task_service.pyindex 62b787ef3..b77f15eac 100644--- a/tests/unit/test_task_service.py+++ b/tests/unit/test_task_service.py@@ -326,6 +326,37 @@ def test_enhanced_keeps_completed_files_for_preview_tasks(task_service):assert "fileB" in files+def test_enhanced_keeps_source_deleted_completed_files(task_service):+ """Successful source-deletion cleanup stays in the file list as Removed."""+ task = UploadTask(+ task_id="sync_task",+ total_files=2,+ file_tasks={+ "fileA": FileTask(+ file_path="fileA",+ status=TaskStatus.COMPLETED,+ result={+ "status": "completed",+ "reason": "deleted_at_source",+ "deleted_chunks": 1,+ "message": "File no longer exists at source; removed from index (1 chunk(s) deleted).",+ },+ ),+ "fileB": FileTask(file_path="fileB", status=TaskStatus.COMPLETED),+ },+ status=TaskStatus.COMPLETED,+ )+ task_service.task_store["user1"] = {"sync_task": task}++ tasks = task_service.get_all_tasks2("user1")++ files = tasks[0]["files"]+ assert "fileA" in files+ assert files["fileA"]["status"] == "completed"+ assert files["fileA"]["result"]["reason"] == "deleted_at_source"+ assert "fileB" not in files++# ---------------------------------------------------------------------------# delete_task# ---------------------------------------------------------------------------