pinokiod 8.0.47 → 8.0.49

package/test/vault-ui.test.js

@@ -76,12 +76,12 @@ describe('vault dashboard backend (phase 4)', () => {
     }
 
     const accepted = await vault.perform('scan', {
-      candidate_size: CANDIDATE_SIZE_OPTIONS[1]
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
     })
     assert.deepStrictEqual(accepted, { started: true })
     assert.deepStrictEqual(startedWith, {
       scopeId: null,
-      sizeThreshold: CANDIDATE_SIZE_OPTIONS[1]
+      sizeThreshold: CANDIDATE_SIZE_OPTIONS[0]
     })
 
     startedWith = null
@@ -674,7 +674,8 @@ describe('vault dashboard backend (phase 4)', () => {
     await vault.sweeper.scan()
     const status = await vault.status()
     assert.strictEqual(status.enabled, true)
-    assert.strictEqual(status.bytes_on_disk, content.length)
+    assert.strictEqual(status.bytes_on_disk, content.length * 2)
+    assert.strictEqual(status.bytes_without_sharing, content.length * 2)
     assert.ok(status.last_scan && status.last_scan.files > 0)
     assert.strictEqual(status.excluded.length, 1)
     assert.strictEqual(status.excluded[0].size, content.length)
@@ -705,6 +706,79 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.strictEqual(status.saved_by_sharing, 0)
   })
 
+  test('global storage metrics include scanned files below the candidate threshold', async () => {
+    const { home, vault } = await makeEnv()
+    const { content } = await makeSharedPair(home, vault)
+    const small = crypto.randomBytes(512)
+    await writeFile(path.resolve(home, 'api', 'appA', 'config.json'), small)
+    await vault.sweeper.scan()
+
+    const status = await vault.status()
+    assert.strictEqual(status.last_scan.bytes_total, (content.length * 2) + small.length)
+    assert.strictEqual(status.bytes_on_disk, content.length + small.length)
+    assert.strictEqual(status.bytes_without_sharing, (content.length * 2) + small.length)
+    assert.strictEqual(status.saved_by_sharing, content.length)
+  })
+
+  test('global storage metrics do not disappear when every scanned file is below the candidate threshold', async () => {
+    const { home, vault } = await makeEnv()
+    const first = crypto.randomBytes(511)
+    const second = crypto.randomBytes(257)
+    await writeFile(path.resolve(home, 'api', 'appA', 'config.json'), first)
+    await writeFile(path.resolve(home, 'api', 'appB', 'notes.txt'), second)
+    await vault.sweeper.scan()
+
+    const status = await vault.status()
+    const total = first.length + second.length
+    assert.strictEqual(status.last_scan.bytes_total, total)
+    assert.strictEqual(status.bytes_on_disk, total)
+    assert.strictEqual(status.bytes_without_sharing, total)
+    assert.strictEqual(status.saved_by_sharing, 0)
+  })
+
+  test('global storage metrics include below-threshold files from external locations', async (t) => {
+    const { home, vault } = await makeEnv()
+    const external = await fs.promises.mkdtemp(path.resolve(os.tmpdir(), 'pinokio-ui-size-external-'))
+    homes.push(external)
+    const local = crypto.randomBytes(401)
+    const imported = crypto.randomBytes(607)
+    await writeFile(path.resolve(home, 'api', 'appA', 'local.json'), local)
+    await writeFile(path.resolve(external, 'external.json'), imported)
+    try {
+      await vault.addExternalSource(external)
+    } catch (error) {
+      t.skip(`directory links unavailable: ${error.message}`)
+      return
+    }
+    await vault.sweeper.scan()
+
+    const status = await vault.status()
+    const total = local.length + imported.length
+    assert.strictEqual(status.last_scan.home_bytes_total, local.length)
+    assert.strictEqual(status.last_scan.bytes_total, total)
+    assert.strictEqual(status.bytes_on_disk, total)
+    assert.strictEqual(status.bytes_without_sharing, total)
+    assert.strictEqual(status.saved_by_sharing, 0)
+  })
+
+  test('global storage metrics add unused managed files without double-counting scanned files', async () => {
+    const { home, vault } = await makeEnv()
+    const managed = crypto.randomBytes(4096)
+    const small = crypto.randomBytes(379)
+    const managedPath = await writeFile(path.resolve(home, 'api', 'appA', 'unused.bin'), managed)
+    await vault.adopt(managedPath, sha256(managed), { app: 'appA' })
+    await fs.promises.unlink(managedPath)
+    await writeFile(path.resolve(home, 'api', 'appA', 'settings.json'), small)
+    await vault.sweeper.scan()
+
+    const status = await vault.status()
+    assert.strictEqual(status.last_scan.bytes_total, small.length)
+    assert.strictEqual(status.reclaimable, managed.length)
+    assert.strictEqual(status.bytes_on_disk, managed.length + small.length)
+    assert.strictEqual(status.bytes_without_sharing, managed.length + small.length)
+    assert.strictEqual(status.saved_by_sharing, 0)
+  })
+
   test('app status exposes only that app while retaining its matching locations', async () => {
     const { home, vault } = await makeEnv()
     const content = crypto.randomBytes(4096)
@@ -1061,6 +1135,81 @@ describe('vault dashboard backend (phase 4)', () => {
     }
   })
 
+  test('an older status response cannot replace newer scan progress', async () => {
+    const views = path.resolve(__dirname, '..', 'server', 'views')
+    const publicRoot = path.resolve(__dirname, '..', 'server', 'public')
+    const workspace = await ejs.renderFile(
+      path.resolve(views, 'partials', 'vault_workspace.ejs'),
+      { appMode: false }
+    )
+    const baseStatus = {
+      enabled: true,
+      mode: 'link',
+      last_scan: null,
+      bytes_on_disk: 0,
+      bytes_without_sharing: 0,
+      saved_by_sharing: 0,
+      lifetime_bytes_saved: 0,
+      pending_bytes: 0,
+      reclaimable: 0,
+      file_action: null,
+      activity_error: null,
+      cloud_sync_warning: null,
+      sources: [{
+        id: 'pinokio', kind: 'pinokio', label: 'Pinokio', root: '/pinokio',
+        display_path: '/pinokio', parent_id: null, available: true, shareable: true
+      }],
+      blobs: [], duplicates: [], excluded: [], events: [], undo_batches: []
+    }
+    const scan = (queued, currentFile) => ({
+      active: true, pending: false, phase: 'analyzing', scope_id: null,
+      dirs: 4, files: 8, total_files: 8, bytes_total: 8000,
+      hash_total: 937, queued, current_file: currentFile,
+      current_file_bytes: 0, current_file_size: 1000,
+      started: 123
+    })
+    const response = (data) => ({ ok: true, json: async () => data })
+    let requestCount = 0
+    let resolveOlder
+    const olderResponse = new Promise((resolve) => { resolveOlder = resolve })
+    const dom = new JSDOM(
+      `<body data-platform="darwin" data-vault-mode="global">${workspace}</body>`,
+      { url: 'http://localhost/vault', runScripts: 'dangerously' }
+    )
+    dom.window.fetch = async () => {
+      requestCount += 1
+      if (requestCount === 1) {
+        return response(Object.assign({}, baseStatus, {
+          scan: { active: false, pending: false, queued: 0, phase: 'idle', scope_id: null }
+        }))
+      }
+      if (requestCount === 2) return olderResponse
+      return response(Object.assign({}, baseStatus, { scan: scan(115, 'newer.bin') }))
+    }
+    try {
+      const formatter = await fs.promises.readFile(path.resolve(publicRoot, 'storage-size.js'), 'utf8')
+      const source = await fs.promises.readFile(path.resolve(publicRoot, 'vault.js'), 'utf8')
+      dom.window.eval(formatter)
+      dom.window.eval(source.replace(/\nrefresh\(\)\s*$/, '\nwindow.__testVaultRefresh = refresh\nrefresh()'))
+      await new Promise((resolve) => setTimeout(resolve, 25))
+
+      const olderRefresh = dom.window.__testVaultRefresh()
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      const newerRefresh = dom.window.__testVaultRefresh()
+      await newerRefresh
+      assert.strictEqual(dom.window.document.querySelector('.vault-scan-percent').textContent, '87.7%')
+      assert.match(dom.window.document.querySelector('.vault-scan-detail').textContent, /822 of 937 large files checked/)
+
+      resolveOlder(response(Object.assign({}, baseStatus, { scan: scan(204, 'older.bin') })))
+      await olderRefresh
+      assert.strictEqual(dom.window.document.querySelector('.vault-scan-percent').textContent, '87.7%')
+      assert.match(dom.window.document.querySelector('.vault-scan-detail').textContent, /822 of 937 large files checked/)
+      assert.doesNotMatch(dom.window.document.querySelector('.vault-scan-detail').textContent, /older\.bin/)
+    } finally {
+      dom.window.close()
+    }
+  })
+
   test('item 16: vocabulary lint — vault page copy avoids forbidden terms', async () => {
     const forbidden = /hard.?link|junction|symlink|inode|\bblob\b|\bstore\b|\bdedupe\b|\bvault\b/i
     const vaultPage = await vaultPageSource()
@@ -1086,24 +1235,33 @@ describe('vault dashboard backend (phase 4)', () => {
   test('copy-mode tracking never claims physical sharing savings', async () => {
     const { home, vault } = await makeEnv()
     const content = crypto.randomBytes(4096)
+    const small = crypto.randomBytes(383)
     const hash = sha256(content)
     const first = await writeFile(path.resolve(home, 'api', 'appA', 'm.bin'), content)
     const second = await writeFile(path.resolve(home, 'api', 'appB', 'm.bin'), content)
+    await writeFile(path.resolve(home, 'api', 'appA', 'config.json'), small)
     const firstStat = await fs.promises.stat(first)
     const secondStat = await fs.promises.stat(second)
     vault.registry.addBlob(hash, { size: content.length })
     vault.registry.addLink(first, { hash, app: 'appA', dev: firstStat.dev, ino: firstStat.ino, mode: 'copy' })
     vault.registry.addLink(second, { hash, app: 'appB', dev: secondStat.dev, ino: secondStat.ino, mode: 'copy' })
+    vault.registry.setLastScan({
+      ts: Date.now(),
+      files: 3,
+      bytes_total: (content.length * 2) + small.length,
+      home_bytes_total: (content.length * 2) + small.length
+    })
 
     const status = await vault.status()
-    assert.strictEqual(status.bytes_on_disk, content.length * 2)
+    assert.strictEqual(status.bytes_on_disk, (content.length * 2) + small.length)
+    assert.strictEqual(status.bytes_without_sharing, (content.length * 2) + small.length)
     assert.strictEqual(status.saved_by_sharing, 0)
   })
 
   test('repair is advanced, metrics distinguish detected and explicit savings, and refresh retries', async () => {
     const vaultPage = await vaultPageSource()
     assert.match(vaultPage, /disk_space_saved:\s*"of disk space saved"/)
-    assert.match(vaultPage, /before_help:\s*"Estimated space if every app stored its own copy\."/)
+    assert.match(vaultPage, /before_help:\s*"Estimated size of every scanned location if each app stored its own copy\. File Explorer may count deduplicated files differently\."/)
     assert.match(vaultPage, /nothing_more_to_save:\s*"Nothing else to save"/)
     assert.match(vaultPage, /more_can_be_saved:\s*"\{size\} more can be saved"/)
     assert.match(vaultPage, /fmt\(data\.saved_by_sharing\)/)
@@ -1186,7 +1344,8 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.match(vaultPage, /pinokio:vault:reviewed-scan/)
     assert.match(vaultPage, /completed \|\| incomplete \|\| \(!state\.scanResult && unreviewed\)/)
     assert.match(vaultPage, /state\.data\.undo_batches/)
-    assert.match(vaultPage, /data-undo="\$\{attr\(batch\.batch_id\)\}"/)
+    assert.match(vaultPage, /data-undo="\$\{attr\(item\.batch_id\)\}"/)
+    assert.match(vaultPage, /data-undo="\$\{attr\(event\.batch_id\)\}"/)
     assert.match(vaultPage, /last_scan && data\.last_scan\.hash_failures/)
     assert.match(vaultPage, /scan_not_analyzed:\s*"could not be analyzed"/)
     assert.match(vaultPage, /\.vault-progress-bar\.determinate \{[\s\S]*?transform:\s*scaleX/)
@@ -1323,7 +1482,7 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.match(dom.window.document.getElementById('btn-scan').textContent, /Scan this app/)
     const candidateSize = dom.window.document.getElementById('vault-candidate-size')
     assert.deepStrictEqual([...candidateSize.options].map((option) => option.textContent),
-      ['10 MB+', '50 MB+', '100 MB+', '500 MB+', '1 GB+'])
+      ['1 MB+', '10 MB+', '50 MB+', '100 MB+', '500 MB+', '1 GB+'])
     assert.strictEqual(candidateSize.value, '100000000')
     candidateSize.value = '50000000'
     candidateSize.dispatchEvent(new dom.window.Event('change', { bubbles: true }))
@@ -1387,11 +1546,14 @@ describe('vault dashboard backend (phase 4)', () => {
     const formatter = await fs.promises.readFile(
       path.resolve(__dirname, '..', 'server', 'public', 'storage-size.js'), 'utf8')
     dom.window.eval(formatter)
+    const screenshotFolderBytes = 2_002_022_055_452
     assert.strictEqual(dom.window.PinokioFormatStorageSize(7.05e9), '7.05 GB')
     assert.strictEqual(dom.window.PinokioFormatStorageSize(5.3e9), '5.3 GB')
     assert.strictEqual(dom.window.PinokioFormatStorageSize(1024 ** 3), '1.07 GB')
+    assert.strictEqual(dom.window.PinokioFormatStorageSize(screenshotFolderBytes), '2 TB')
     dom.window.document.body.dataset.platform = 'win32'
     assert.strictEqual(dom.window.PinokioFormatStorageSize(1024 ** 3), '1 GB')
+    assert.strictEqual(dom.window.PinokioFormatStorageSize(screenshotFolderBytes), '1.82 TB')
 
     const appView = await fs.promises.readFile(
       path.resolve(__dirname, '..', 'server', 'views', 'app.ejs'), 'utf8')
@@ -1443,7 +1605,8 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.deepStrictEqual([...dom.window.document.querySelectorAll('.vault-compare-label')].map((node) => node.firstChild.textContent.trim()), ['Before', 'After'])
     assert.deepStrictEqual([...dom.window.document.querySelectorAll('.vault-compare-value')].map((node) => node.textContent), ['661.75 GB', '404.8 GB'])
     assert.match(dom.window.document.querySelector('.vault-compare-fill.after').getAttribute('style'), /--vault-after-ratio:61\.17%/)
-    assert.strictEqual(dom.window.document.getElementById('vault-before-help').textContent, 'Estimated space if every app stored its own copy.')
+    assert.strictEqual(dom.window.document.getElementById('vault-before-help').textContent,
+      'Estimated size of every scanned location if each app stored its own copy. File Explorer may count deduplicated files differently.')
     assert.strictEqual(dom.window.document.querySelector('.vault-compare-info').getAttribute('tabindex'), '0')
     assert.match(dom.window.document.querySelector('.vault-summary-side').textContent, /13\.31 GB more can be saved/)
     assert.strictEqual(dom.window.document.getElementById('btn-review-metric').textContent, 'Review files')
@@ -1451,12 +1614,21 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.strictEqual(dom.window.document.getElementById('btn-scan').classList.contains('primary'), false)
     assert.match(dom.window.document.getElementById('vault-storage-details').textContent, /Pinokio folder\s*166\.22 GB/)
     assert.match(dom.window.document.getElementById('vault-storage-details').textContent, /Saved by your actions\s*258\.77 GB/)
+    const cleanupNotice = dom.window.document.getElementById('vault-cleanup-notice')
+    assert.strictEqual(cleanupNotice.classList.contains('show'), true)
+    assert.match(cleanupNotice.textContent, /ready to clean up/)
+    assert.match(cleanupNotice.textContent, /1 private link left/)
+    dom.window.document.getElementById('btn-review-cleanup').click()
+    assert.strictEqual(dom.window.document.querySelector('[data-view="reclaimable"]').classList.contains('selected'), true)
+    assert.strictEqual(cleanupNotice.classList.contains('show'), false)
+    dom.window.document.querySelector('[data-view="all"]').click()
     const viewDescriptions = {
       all: 'Every scanned file and its current deduplication status.',
       duplicates: 'Identical files waiting to be deduplicated or kept separate.',
       shared: 'Files that share disk storage across multiple locations.',
+      tracked: 'Files with no duplicate action required.',
       independent: 'Duplicate files that remain as separate copies.',
-      reclaimable: 'Stored copies no longer used by any configured location.',
+      reclaimable: 'Private links no longer used by any linked file.',
       activity: 'A history of scans and changes made by Save space.'
     }
     for (const [view, description] of Object.entries(viewDescriptions)) {
@@ -1472,9 +1644,10 @@ describe('vault dashboard backend (phase 4)', () => {
     const unusedView = dom.window.document.querySelector('[data-view="reclaimable"]')
     assert.strictEqual(unusedView.querySelector('.vault-nav-name').textContent, 'Unused files')
     unusedView.click()
-    assert.strictEqual(dom.window.document.getElementById('btn-reclaim-all').textContent, 'Delete all')
-    assert.strictEqual(dom.window.document.querySelector('[data-reclaim]').textContent, 'Delete')
-    assert.match(dom.window.document.getElementById('vault-pane-footer').textContent, /Deleting them frees disk space/)
+    assert.strictEqual(dom.window.document.getElementById('btn-reclaim-all').textContent, 'Clean up all')
+    assert.strictEqual(dom.window.document.querySelector('[data-reclaim]').textContent, 'Clean up')
+    assert.match(dom.window.document.getElementById('vault-pane-footer').textContent,
+      /Cleaning them up frees disk space/)
     dom.window.close()
   })
 
@@ -1517,6 +1690,7 @@ describe('vault dashboard backend (phase 4)', () => {
       ['10 GB', '7 GB'])
     assert.match(dom.window.document.querySelector('.vault-summary-side').textContent,
       /1 GB more can be saved.*Not scanned yet/)
+    assert.strictEqual(dom.window.document.getElementById('vault-cleanup-notice').classList.contains('show'), false)
     dom.window.close()
   })
 
@@ -1549,8 +1723,8 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.match(source, /headers = \[COPY\.name, COPY\.size, COPY\.can_free, ""\]/)
     assert.match(source, /headers = \[COPY\.name, COPY\.size, COPY\.last_scanned, ""\]/)
     assert.match(source, /reclaimable:\s*"Unused files"/)
-    assert.match(source, /reclaim:\s*"Delete"/)
-    assert.match(source, /reclaim_all:\s*"Delete all"/)
+    assert.match(source, /reclaim:\s*"Clean up"/)
+    assert.match(source, /reclaim_all:\s*"Clean up all"/)
     assert.match(source, /data-sort-size/)
     assert.match(source, /data-display-mode="folders"/)
     assert.match(source, /data-display-mode="files"/)
@@ -1853,6 +2027,244 @@ describe('vault dashboard backend (phase 4)', () => {
     }
   })
 
+  test('No action needed is a counted, filtered, paginated file view', async () => {
+    const views = path.resolve(__dirname, '..', 'server', 'views')
+    const html = await ejs.renderFile(path.resolve(views, 'vault_app.ejs'), {
+      theme: 'light', platform: 'darwin', agent: 'electron', scope_id: 'app:appB'
+    })
+    const dom = new JSDOM(html, {
+      url: 'http://localhost/vault/app/appB',
+      runScripts: 'dangerously'
+    })
+    const blobs = Array.from({ length: 501 }, (_, index) => {
+      const name = `tracked-${String(index).padStart(4, '0')}.bin`
+      return {
+        hash: index.toString(16).padStart(64, '0'),
+        size: 1024 + index,
+        orphan: false,
+        nlink: 2,
+        names: [{
+          path: `/pinokio/api/appB/${name}`,
+          relative_path: name,
+          source_id: 'app:appB',
+          source_label: 'appB',
+          mode: 'link'
+        }]
+      }
+    })
+    const status = {
+      enabled: true,
+      mode: 'link',
+      scan: { active: false, pending: false, queued: 0, phase: 'idle', scope_id: null },
+      last_scan: { ts: Date.now(), bytes_total: 1024 * 502 },
+      tracked_bytes: 1024 * 502,
+      effective_bytes: 1024 * 502,
+      shared_bytes: 0,
+      pending_bytes: 1024,
+      activity_error: null,
+      cloud_sync_warning: null,
+      sources: [{
+        id: 'app:appB', kind: 'app', label: 'appB', root: '/pinokio/api/appB',
+        display_path: '/pinokio/api/appB', parent_id: null, available: true, shareable: true
+      }],
+      blobs,
+      duplicates: [{
+        path: '/pinokio/api/appB/duplicate.bin',
+        relative_path: 'duplicate.bin',
+        source_id: 'app:appB',
+        source_label: 'appB',
+        size: 1024,
+        shareable: true,
+        match: { path: '/pinokio/api/appA/duplicate.bin' }
+      }],
+      excluded: [],
+      events: [],
+      undo_batches: []
+    }
+    dom.window.fetch = async () => ({ ok: true, json: async () => status })
+    await runVaultScript(dom)
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    const trackedView = dom.window.document.querySelector('[data-view="tracked"]')
+    assert.strictEqual(trackedView.querySelector('.vault-nav-name').textContent, 'No action needed')
+    assert.strictEqual(trackedView.querySelector('.vault-nav-count').textContent, '501')
+    trackedView.click()
+
+    const rows = () => [...dom.window.document.querySelectorAll('.vault-table .vault-file-row')]
+    assert.strictEqual(rows().length, 500)
+    assert.strictEqual(dom.window.document.getElementById('vault-search').placeholder,
+      'Search files with no action needed')
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '1–500 of 501')
+    assert.doesNotMatch(dom.window.document.getElementById('vault-table-wrap').textContent, /duplicate\.bin/)
+
+    dom.window.document.querySelector('[data-page="next"]').click()
+    assert.strictEqual(rows().length, 1)
+    assert.strictEqual(rows()[0].querySelector('.vault-file-name').textContent, 'tracked-0500.bin')
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '501–501 of 501')
+    dom.window.close()
+  })
+
+  test('Activity is paginated without repeating a batch undo action', async () => {
+    const views = path.resolve(__dirname, '..', 'server', 'views')
+    const html = await ejs.renderFile(path.resolve(views, 'vault_app.ejs'), {
+      theme: 'light', platform: 'darwin', agent: 'electron', scope_id: 'app:appB'
+    })
+    const dom = new JSDOM(html, {
+      url: 'http://localhost/vault/app/appB',
+      runScripts: 'dangerously'
+    })
+    const events = Array.from({ length: 501 }, (_, index) => ({
+      kind: 'convert',
+      path: `/pinokio/api/appB/event-${String(index).padStart(4, '0')}.bin`,
+      relative_path: `event-${String(index).padStart(4, '0')}.bin`,
+      source_id: 'app:appB',
+      source_label: 'appB',
+      batch_id: 'batch-large',
+      undoable: index !== 0,
+      bytes_saved: 1024 + index,
+      ts: Date.now() - index
+    }))
+    const status = {
+      enabled: true,
+      mode: 'link',
+      scan: { active: false, pending: false, queued: 0, phase: 'idle', scope_id: null },
+      last_scan: { ts: Date.now(), bytes_total: 1024 * 501 },
+      tracked_bytes: 0,
+      effective_bytes: 0,
+      shared_bytes: 0,
+      pending_bytes: 0,
+      activity_error: null,
+      cloud_sync_warning: null,
+      sources: [{
+        id: 'app:appB', kind: 'app', label: 'appB', root: '/pinokio/api/appB',
+        display_path: '/pinokio/api/appB', parent_id: null, available: true, shareable: true
+      }],
+      blobs: [],
+      duplicates: [],
+      excluded: [],
+      events,
+      undo_batches: [{
+        batch_id: 'batch-large',
+        files: events.length,
+        bytes: events.reduce((sum, event) => sum + event.bytes_saved, 0),
+        ts: events[0].ts
+      }, {
+        batch_id: 'batch-compacted',
+        files: 2,
+        bytes: 4096,
+        ts: events[events.length - 1].ts - 1
+      }]
+    }
+    dom.window.fetch = async () => ({ ok: true, json: async () => status })
+    await runVaultScript(dom)
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    const activityView = dom.window.document.querySelector('[data-view="activity"]')
+    assert.strictEqual(activityView.querySelector('.vault-nav-count').textContent, '502')
+    activityView.click()
+
+    const rows = () => [...dom.window.document.querySelectorAll('.vault-table.activity .vault-file-row')]
+    assert.strictEqual(rows().length, 500)
+    assert.strictEqual(dom.window.document.querySelectorAll('[data-undo="batch-large"]').length, 1)
+    assert.strictEqual(dom.window.document.querySelectorAll('[data-undo="batch-compacted"]').length, 1)
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '1–500 of 502')
+
+    dom.window.document.querySelector('[data-page="next"]').click()
+    assert.strictEqual(rows().length, 2)
+    assert.strictEqual(dom.window.document.querySelectorAll('[data-undo="batch-large"]').length, 0)
+    assert.strictEqual(dom.window.document.querySelectorAll('[data-undo="batch-compacted"]').length, 0)
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '501–502 of 502')
+    dom.window.close()
+  })
+
+  test('large file lists render bounded pages without narrowing Deduplicate all', async () => {
+    const views = path.resolve(__dirname, '..', 'server', 'views')
+    const html = await ejs.renderFile(path.resolve(views, 'vault_app.ejs'), {
+      theme: 'light', platform: 'darwin', agent: 'electron', scope_id: 'app:appB'
+    })
+    const dom = new JSDOM(html, {
+      url: 'http://localhost/vault/app/appB',
+      runScripts: 'dangerously'
+    })
+    const actions = []
+    const duplicates = Array.from({ length: 501 }, (_, index) => {
+      const name = `file-${String(index).padStart(4, '0')}.bin`
+      return {
+        path: `/pinokio/api/appB/${name}`,
+        relative_path: name,
+        source_id: 'app:appB',
+        source_label: 'appB',
+        size: 1024 + index,
+        shareable: true,
+        match: { path: `/pinokio/api/appA/${name}` }
+      }
+    })
+    const status = {
+      enabled: true,
+      mode: 'link',
+      scan: { active: false, pending: false, queued: 0, phase: 'idle', scope_id: null },
+      last_scan: { ts: Date.now(), bytes_total: 1024 * 501 },
+      tracked_bytes: 1024 * 501,
+      effective_bytes: 1024 * 501,
+      shared_bytes: 0,
+      pending_bytes: duplicates.reduce((sum, item) => sum + item.size, 0),
+      activity_error: null,
+      cloud_sync_warning: null,
+      sources: [{
+        id: 'app:appB', kind: 'app', label: 'appB', root: '/pinokio/api/appB',
+        display_path: '/pinokio/api/appB', parent_id: null, available: true, shareable: true
+      }],
+      blobs: [],
+      duplicates,
+      excluded: [],
+      events: [],
+      undo_batches: []
+    }
+    dom.window.fetch = async (url, options = {}) => {
+      if (options.method === 'POST') {
+        actions.push(JSON.parse(options.body))
+        return { ok: true, json: async () => ({ converted: 501, bytes_saved: status.pending_bytes }) }
+      }
+      return { ok: true, json: async () => status }
+    }
+    await runVaultScript(dom)
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    dom.window.document.querySelector('[data-view="duplicates"]').click()
+    const rows = () => [...dom.window.document.querySelectorAll('.vault-table.matches .vault-file-row')]
+    let bulk = dom.window.document.querySelector('[data-deduplicate-all="duplicates"]')
+    assert.strictEqual(rows().length, 500)
+    assert.strictEqual(bulk.textContent, 'Deduplicate 501 files')
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '1–500 of 501')
+    assert.strictEqual(dom.window.document.querySelector('[data-page="previous"]').disabled, true)
+    assert.strictEqual(dom.window.document.querySelector('[data-page="next"]').disabled, false)
+
+    dom.window.document.querySelector('[data-page="next"]').click()
+    assert.strictEqual(rows().length, 1)
+    assert.strictEqual(rows()[0].querySelector('.vault-file-name').textContent, 'file-0500.bin')
+    assert.strictEqual(dom.window.document.querySelector('.vault-page-range').textContent, '501–501 of 501')
+    assert.strictEqual(dom.window.document.querySelector('[data-page="previous"]').disabled, false)
+    assert.strictEqual(dom.window.document.querySelector('[data-page="next"]').disabled, true)
+
+    bulk = dom.window.document.querySelector('[data-deduplicate-all="duplicates"]')
+    assert.strictEqual(bulk.textContent, 'Deduplicate 501 files')
+    bulk.click()
+    await new Promise((resolve) => setTimeout(resolve, 25))
+    assert.deepStrictEqual(actions[0], {
+      action: 'deduplicate',
+      selection: 'duplicates',
+      scope_id: 'app:appB'
+    })
+
+    const search = dom.window.document.getElementById('vault-search')
+    search.value = 'file-0001.bin'
+    search.dispatchEvent(new dom.window.Event('input', { bubbles: true }))
+    assert.strictEqual(rows().length, 1)
+    assert.strictEqual(rows()[0].querySelector('.vault-file-name').textContent, 'file-0001.bin')
+    assert.strictEqual(dom.window.document.querySelector('.vault-pagination'), null)
+    dom.window.close()
+  })
+
   test('app inventory uses explicit sharing actions without ambiguous switches', async () => {
     const views = path.resolve(__dirname, '..', 'server', 'views')
     const html = await ejs.renderFile(path.resolve(views, 'vault_app.ejs'), {
@@ -2060,6 +2472,64 @@ describe('vault dashboard backend (phase 4)', () => {
     dom.window.close()
   })
 
+  test('external file rows and expanded matches show the full target path', async () => {
+    const views = path.resolve(__dirname, '..', 'server', 'views')
+    const html = await ejs.renderFile(path.resolve(views, 'vault_app.ejs'), {
+      theme: 'light', platform: 'darwin', agent: 'electron', scope_id: 'external:api'
+    })
+    const dom = new JSDOM(html, { url: 'http://localhost/vault/app/external%3Aapi', runScripts: 'dangerously' })
+    const targetRoot = '/Volumes/Models/api'
+    const relativePath = 'ideogram/app/comfy_models/model.safetensors'
+    const externalPath = `${targetRoot}/${relativePath}`
+    const status = {
+      enabled: true,
+      mode: 'link',
+      scan: { active: false, pending: false, queued: 0, phase: 'idle', scope_id: null },
+      last_scan: { ts: Date.now(), bytes_total: 4096 },
+      tracked_bytes: 4096,
+      effective_bytes: 2048,
+      shared_bytes: 4096,
+      pending_bytes: 0,
+      activity_error: null,
+      cloud_sync_warning: null,
+      sources: [{
+        id: 'external:api', kind: 'external', label: 'api', root: targetRoot,
+        display_path: '/pinokio/vault/sources/api', target_path: targetRoot,
+        parent_id: null, available: true, shareable: true
+      }],
+      blobs: [{
+        hash: 'a'.repeat(64), size: 4096, orphan: false, nlink: 3,
+        names: [
+          {
+            path: externalPath, relative_path: relativePath,
+            source_id: 'external:api', source_label: 'api', mode: 'link'
+          },
+          {
+            path: `/pinokio/api/appA/${relativePath}`, relative_path: relativePath,
+            source_id: 'app:appA', source_label: 'appA', mode: 'link'
+          }
+        ]
+      }],
+      duplicates: [], excluded: [], events: [], undo_batches: []
+    }
+    dom.window.fetch = async () => ({ ok: true, json: async () => status })
+    await runVaultScript(dom)
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    dom.window.document.querySelector('[data-view="shared"]').click()
+    assert.strictEqual(
+      dom.window.document.querySelector('.vault-flat-location').textContent,
+      externalPath
+    )
+    dom.window.document.querySelector('[data-expand-file]').click()
+    assert.deepStrictEqual(
+      [...dom.window.document.querySelectorAll('.vault-location-detail span')]
+        .map((node) => node.textContent),
+      [externalPath, `appA / ${relativePath}`]
+    )
+    dom.window.close()
+  })
+
   test('vault route provisions the dev requirements needed by its folder picker', async () => {
     const serverSource = await fs.promises.readFile(path.resolve(__dirname, '..', 'server', 'index.js'), 'utf8')
     const routeStart = serverSource.indexOf('this.app.get("/vault"')