Quick scan walks /import and enqueues
- new files only (skips paths already on a non-failed ImportTask).
- Deep scan additionally chains a phash backfill
- across the existing library — use after bulk-imports to catch
- near-duplicates that slipped through. Both modes route non-media
- + sidecar pairs through PostAttachment capture.
+ new files only.
+ Deep scan additionally re-walks already-imported
+ files so updated sidecar metadata (post title/date/attribution) and
+ previously-NULL phashes / artist links get refreshed. Use after
+ bulk-downloading fresh sidecars for existing content. Both modes
+ route non-media + sidecar pairs through PostAttachment capture.
An active batch is in progress. Wait for it to finish, or click
diff --git a/frontend/src/stores/import.js b/frontend/src/stores/import.js
index 6b4dd04..64e5146 100644
--- a/frontend/src/stores/import.js
+++ b/frontend/src/stores/import.js
@@ -66,21 +66,42 @@ export const useImportStore = defineStore('import', () => {
// batch flashes 'running' for <100ms then 'complete' before the
// first refreshStatus() lands; UI never sees the active state).
const label = mode === 'deep'
- ? 'Deep scan triggered (pHash backfill chained)'
+ ? 'Deep scan triggered (re-applying sidecar metadata + filling NULL phash/artist on existing rows)'
: mode === 'verify' ? 'Library verify triggered' : 'Quick scan triggered'
window.__fcToast?.({ text: label, type: 'success' })
await refreshStatus()
- // Re-poll twice over ~5s to catch quick-finalize transitions and
- // surface a result toast either way. Skip the "no new files" hint
- // for 'verify' since it doesn't walk the import_root.
+ // Re-poll twice over ~5s and produce an HONEST follow-up toast.
+ // Operator-flagged 2026-05-25: the prior "no new files" message was
+ // misleading because deep scan IS doing work (refresh) even when
+ // there are no new files to import. Surface the real workload count
+ // (imported + refreshed + queued) instead. For quick scan + zero
+ // queued work, fall back to "up to date" instead of the old
+ // implementation-detail-leaking message.
setTimeout(async () => {
await refreshStatus()
await loadTasks(true)
- if (!activeBatch.value && mode !== 'verify') {
+ if (activeBatch.value || mode === 'verify') return
+ // Batch finalized quickly; figure out what actually happened.
+ // The task list was just refreshed; the freshest row(s) carry
+ // the batch outcome.
+ const batchId = tasks.value[0]?.batch_id
+ const sameBatch = batchId
+ ? tasks.value.filter(t => t.batch_id === batchId)
+ : []
+ const refreshedCount = sameBatch.filter(t => t.status === 'complete' && t.result_image_id).length
+ const newImported = sameBatch.filter(t => t.status === 'complete' && t.result_image_id && !t.error).length
+ if (mode === 'deep' && sameBatch.length > 0) {
window.__fcToast?.({
- text: 'Scan complete — no new files (everything already on an ImportTask row)',
+ text: `Deep scan finished — ${sameBatch.length} file(s) processed`,
type: 'info',
})
+ } else if (mode === 'quick' && sameBatch.length > 0) {
+ window.__fcToast?.({
+ text: `Quick scan finished — ${newImported} new file(s) queued`,
+ type: 'info',
+ })
+ } else {
+ window.__fcToast?.({ text: 'Library is up to date', type: 'info' })
}
}, 2000)
} catch (e) {
diff --git a/tests/test_importer_deep.py b/tests/test_importer_deep.py
index b94f722..c54e73d 100644
--- a/tests/test_importer_deep.py
+++ b/tests/test_importer_deep.py
@@ -64,9 +64,13 @@ def test_deep_rederives_phash_and_provenance(db_sync, import_layout):
deep = _mk(db_sync, import_layout, deep=True)
r2 = deep.import_one(src)
- assert r2.status == "skipped"
- assert "deep" in (r2.error or "")
+ # Outcome flipped from "skipped+duplicate_hash" to "refreshed" 2026-05-25
+ # so the UI can surface deep scan's actual work instead of showing it as
+ # a no-op. See ImportResult.status comment + _deep_rederive docstring.
+ assert r2.status == "refreshed"
assert r2.image_id == rec.id
+ assert r2.skip_reason is None
+ assert r2.error is None
db_sync.expire_all()
rec2 = db_sync.get(ImageRecord, rec.id)
diff --git a/tests/test_phash_dedup.py b/tests/test_phash_dedup.py
index 55fde03..83b5725 100644
--- a/tests/test_phash_dedup.py
+++ b/tests/test_phash_dedup.py
@@ -241,3 +241,9 @@ def test_import_task_maps_superseded_to_complete_and_requeues():
assert _map_result_to_status(
ImportResult(status="failed", error="boom")
) == ("failed", False)
+ # Refreshed (deep scan): complete + no ML/thumb re-derive (pixels
+ # unchanged). Added 2026-05-25 alongside ImportBatch.refreshed
+ # counter so deep scan reports "X refreshed" instead of "no work".
+ assert _map_result_to_status(
+ ImportResult(status="refreshed", image_id=5)
+ ) == ("complete", False)
diff --git a/tests/test_scan_deep_requeue.py b/tests/test_scan_deep_requeue.py
new file mode 100644
index 0000000..ff7d2e5
--- /dev/null
+++ b/tests/test_scan_deep_requeue.py
@@ -0,0 +1,109 @@
+"""Deep scan re-queues already-completed ImportTasks.
+
+Operator-flagged 2026-05-25: deep scan used to skip everything that
+already had a non-failed ImportTask row, making a deep re-scan a no-op
+when no new files were added. That defeated the entire point of deep
+scan (re-apply sidecar metadata to existing rows). The skip-set now
+splits by mode — quick keeps the old "any non-failed" semantics; deep
+skips ONLY actively-in-flight statuses.
+"""
+
+import pytest
+from PIL import Image
+from sqlalchemy import func, select
+
+from backend.app.models import ImportBatch, ImportSettings, ImportTask
+from backend.app.tasks.scan import scan_directory
+
+pytestmark = pytest.mark.integration
+
+
+def _img(path):
+ path.parent.mkdir(parents=True, exist_ok=True)
+ Image.new("RGB", (40, 40), (10, 200, 80)).save(path, "JPEG")
+
+
+def test_deep_scan_requeues_completed_task(db_sync, tmp_path, monkeypatch):
+ """Quick scan then deep scan of the same /import: the file completed
+ in the first run should be re-enqueued by the deep run (different
+ ImportTask id, same source_path)."""
+ import_root = tmp_path / "import"
+ settings = db_sync.execute(
+ select(ImportSettings).where(ImportSettings.id == 1)
+ ).scalar_one()
+ settings.import_scan_path = str(import_root)
+ db_sync.commit()
+
+ src = import_root / "Mae" / "p.jpg"
+ _img(src)
+
+ from backend.app import celery_app
+
+ celery_app.celery.conf.task_always_eager = False # explicit
+ try:
+ first_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+ first_task = db_sync.execute(
+ select(ImportTask).where(ImportTask.batch_id == first_batch_id)
+ ).scalar_one()
+ # Simulate the worker having finished it.
+ first_task.status = "complete"
+ db_sync.commit()
+
+ # Now deep scan: the SAME file should get a NEW ImportTask row.
+ second_batch_id = scan_directory.run(triggered_by="manual", mode="deep")
+ assert second_batch_id != first_batch_id
+
+ new_tasks_in_second_batch = db_sync.execute(
+ select(func.count())
+ .select_from(ImportTask)
+ .where(ImportTask.batch_id == second_batch_id)
+ ).scalar_one()
+ assert new_tasks_in_second_batch == 1, (
+ "deep scan did not re-queue the completed file"
+ )
+
+ # And the second batch's task should be for the same source_path
+ # as the first (proves it's a re-queue, not a different file).
+ sp = db_sync.execute(
+ select(ImportTask.source_path)
+ .where(ImportTask.batch_id == second_batch_id)
+ ).scalar_one()
+ assert sp == str(src)
+ finally:
+ celery_app.celery.conf.task_always_eager = False
+
+
+def test_quick_scan_does_not_requeue_completed_task(db_sync, tmp_path):
+ """The flip side: quick scan still keeps the old skip semantics —
+ a file with a completed ImportTask row from a prior batch is NOT
+ re-enqueued on a fresh quick scan."""
+ import_root = tmp_path / "import"
+ settings = db_sync.execute(
+ select(ImportSettings).where(ImportSettings.id == 1)
+ ).scalar_one()
+ settings.import_scan_path = str(import_root)
+ db_sync.commit()
+
+ src = import_root / "Mae" / "q.jpg"
+ _img(src)
+
+ first_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+ first_task = db_sync.execute(
+ select(ImportTask).where(ImportTask.batch_id == first_batch_id)
+ ).scalar_one()
+ first_task.status = "complete"
+ db_sync.commit()
+
+ second_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+ second_batch_count = db_sync.execute(
+ select(func.count())
+ .select_from(ImportTask)
+ .where(ImportTask.batch_id == second_batch_id)
+ ).scalar_one()
+ assert second_batch_count == 0, (
+ "quick scan re-queued an already-completed task — should have skipped"
+ )
+
+ # And the second batch should self-finalize (files_seen=0).
+ second_batch = db_sync.get(ImportBatch, second_batch_id)
+ assert second_batch.status == "complete"