pinokiod 8.0.48 → 8.0.50

package/kernel/vault/index.js

@@ -1712,6 +1712,7 @@ class Vault {
     )
     let bytesOnDisk = 0
     let wouldBe = 0
+    let trackedLogicalBytes = 0
     for (let index = 0; index < blobEntries.length; index++) {
       const [hash, blob] = blobEntries[index]
       const names = namesByHash.get(hash) || []
@@ -1723,6 +1724,7 @@ class Vault {
       const linkedCopy = storeStat || names.some((name) => name.mode === "link") ? 1 : 0
       const physicalCopies = linkedCopy + names.filter((name) => name.mode === "copy").length
       const pendingBytes = pendingBytesByHash.get(hash) || 0
+      trackedLogicalBytes += (size * names.length) + pendingBytes
       bytesOnDisk += (size * physicalCopies) + pendingBytes
       wouldBe += (size * Math.max(physicalCopies, names.length)) + pendingBytes
       const orphan = !!(storeStat && storeStat.nlink === 1)
@@ -1733,6 +1735,22 @@ class Vault {
       blobs.push(publicBlob)
       blobByHash.set(hash, publicBlob)
     }
+    if (!scopeId) {
+      // The scan total covers every regular file, including files below the
+      // candidate threshold and files the user kept separate. The registry
+      // figures above cover only content tracked by Save space. Add the
+      // remainder to both sides so the global comparison represents the
+      // complete scanned locations instead of silently omitting small files.
+      const lastScan = registry.scanFor()
+      const scannedBytes = lastScan && Number.isFinite(lastScan.bytes_total)
+        ? lastScan.bytes_total
+        : null
+      const untrackedScannedBytes = scannedBytes === null
+        ? 0
+        : Math.max(0, scannedBytes - trackedLogicalBytes)
+      bytesOnDisk += untrackedScannedBytes
+      wouldBe += untrackedScannedBytes
+    }
     const duplicates = []
     for (const [p, entry] of registry.duplicates) {
       if (scopeId && entry.source_id !== scopeId) continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.48",
+  "version": "8.0.50",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/public/vault.css

@@ -300,7 +300,8 @@ body[data-vault-mode="app"] .vault-overview {
 .vault-action-state,
 .vault-result,
 .vault-feedback,
-.vault-cloud-warning {
+.vault-cloud-warning,
+.vault-cleanup-notice {
   display: none;
   align-items: center;
   min-height: 38px;
@@ -319,7 +320,8 @@ body[data-vault-mode="app"] .vault-overview {
 .vault-action-state.show,
 .vault-result.show,
 .vault-feedback.show,
-.vault-cloud-warning.show { display: flex; }
+.vault-cloud-warning.show,
+.vault-cleanup-notice.show { display: flex; }
 .vault-scan-state i,
 .vault-action-state i,
 .vault-result > i { color: var(--task-accent); }
@@ -469,6 +471,28 @@ body[data-vault-mode="app"] .vault-overview {
 .vault-cloud-warning { min-height: 34px; background: var(--vault-warning-soft); }
 .vault-cloud-warning > i { color: var(--vault-warning); }
 .vault-cloud-warning .vault-text-button { margin-left: auto; }
+.vault-cleanup-notice {
+  flex: 0 0 auto;
+  border-bottom-color: color-mix(in srgb, var(--vault-warning) 45%, var(--task-border));
+  background: color-mix(in srgb, var(--vault-warning) 16%, var(--task-panel));
+}
+.vault-cleanup-notice > i { color: var(--vault-warning); }
+.vault-cleanup-notice strong { flex: 0 0 auto; font-weight: 650; }
+.vault-cleanup-notice-detail {
+  min-width: 0;
+  flex: 1 1 auto;
+  color: color-mix(in srgb, var(--task-text) 78%, var(--vault-warning));
+}
+.vault-cleanup-notice .vault-button {
+  flex: 0 0 auto;
+  margin-left: auto;
+  border-color: color-mix(in srgb, var(--vault-warning) 70%, var(--task-border-strong));
+  background: var(--task-panel);
+  font-weight: 650;
+}
+.vault-cleanup-notice .vault-button:hover {
+  background: color-mix(in srgb, var(--vault-warning) 12%, var(--task-panel));
+}
 .vault-explorer {
   display: grid;
   min-height: 0;
@@ -952,6 +976,15 @@ body.dark .vault-row-action .vault-text-button:hover:not(:disabled) {
   .vault-result-actions { grid-column: 2; }
   .vault-pane-footer { align-items: flex-start; flex-direction: column; }
   .vault-result.incomplete .vault-button { margin: 0; }
+  .vault-cleanup-notice.show {
+    display: grid;
+    grid-template-columns: 16px minmax(0, 1fr) auto;
+    align-items: center;
+  }
+  .vault-cleanup-notice > i { grid-area: 1 / 1; }
+  .vault-cleanup-notice strong { grid-area: 1 / 2; }
+  .vault-cleanup-notice-detail { grid-area: 2 / 2 / 3 / 4; }
+  .vault-cleanup-notice .vault-button { grid-area: 1 / 3; margin-left: 0; }
 }
 @media (pointer: coarse) {
   .vault-page {

package/server/public/vault.js

@@ -10,8 +10,9 @@ const COPY = {
   all_description: "Every scanned file and its current deduplication status.",
   duplicates_description: "Identical files waiting to be deduplicated or kept separate.",
   shared_description: "Files that share disk storage across multiple locations.",
+  tracked_description: "Files with no duplicate action required.",
   independent_description: "Duplicate files that remain as separate copies.",
-  reclaimable_description: "Stored copies no longer used by any configured location.",
+  reclaimable_description: "Private links no longer used by any linked file.",
   activity_description: "A history of scans and changes made by Save space.",
   add_external_folder: "Add external folder",
   files_region: "Files",
@@ -21,11 +22,12 @@ const COPY = {
   external_other_disk: "Added to Locations. It can be scanned, but files on this disk cannot be deduplicated with files in your Pinokio folder.",
   pinokio_folder: "Pinokio folder",
   save_space: "Save space",
-  disk_space_saved: "of disk space saved",
-  saved_for_app: "{size} saved for this app",
-  before: "Before",
-  before_help: "Estimated space if every app stored its own copy.",
-  after: "After",
+  disk_space_freed: "of disk space freed",
+  sharing_saves_for_app: "Sharing saves {size} for this app",
+  without_sharing: "Without sharing",
+  without_sharing_help: "Estimated size of every scanned location if each app stored its own copy. File Explorer may count deduplicated files differently.",
+  on_disk: "On disk",
+  app_share: "This app’s share",
   effective_help: "For deduplicated files, disk usage is divided evenly among every location using them.",
   nothing_more_to_save: "Nothing else to save",
   more_can_be_saved: "{size} more can be saved",
@@ -35,7 +37,8 @@ const COPY = {
   find_savings: "Scan to find duplicate files and save disk space",
   find_app_savings: "Scan this app to find duplicate files and save disk space",
   storage_details: "Storage details",
-  saved_by_actions: "Saved by your actions",
+  kept_deduplicated: "Kept deduplicated",
+  already_shared: "Already shared before Save space",
   last_scanned: "Last scanned",
   never: "Never",
   scan: "Scan now",
@@ -86,6 +89,7 @@ const COPY = {
   search_all: "Search files",
   search_duplicates: "Search duplicates",
   search_shared: "Search deduplicated files",
+  search_tracked: "Search files with no action needed",
   search_skipped: "Search files kept separate",
   search_activity: "Search activity",
   search_in: "Search in {location}",
@@ -152,8 +156,13 @@ const COPY = {
   keep_separate: "Keep separate",
   kept_separate: "Kept separate",
   make_separate: "Make separate",
-  reclaim: "Delete",
-  reclaim_all: "Delete all",
+  reclaim: "Clean up",
+  reclaim_all: "Clean up all",
+  cleanup_ready: "{size} ready to clean up",
+  cleanup_ready_detail: "{count} left after their linked files were deleted.",
+  review_cleanup: "Review cleanup",
+  private_link: "private link",
+  private_links: "private links",
   undo: "Undo",
   identical_contents_at: "Identical contents at",
   no_files: "No files found",
@@ -164,26 +173,29 @@ const COPY = {
   no_duplicates_hint: "There are no files waiting for your review.",
   no_shared: "Nothing deduplicated yet",
   no_shared_hint: "Deduplicated files will appear here after you review duplicates.",
+  no_tracked: "No files with no action needed",
+  no_tracked_hint: "Files without a duplicate action will appear here after a scan.",
   no_skipped: "Nothing kept separate",
   no_skipped_hint: "Files you keep separate will appear here.",
-  no_reclaimable: "No unused files",
-  no_reclaimable_hint: "Copies no longer used by any configured location will appear here.",
+  no_reclaimable: "No cleanup needed",
+  no_reclaimable_hint: "Private links with no remaining linked files will appear here.",
   no_activity: "No activity yet",
   no_activity_hint: "Scans and actions will be recorded here.",
   view_all: "View all files",
   show_all_locations: "Show all locations",
   tracked_note: "Only files {size} and larger appear here. Files keep their current locations.",
   duplicate_note: "Only files waiting for review are shown.",
-  reclaimable_note: "These copies are no longer used by any configured location. Deleting them frees disk space.",
+  reclaimable_note: "These private links have no remaining linked files. Cleaning them up frees disk space.",
+  activity_note: "Recent scans and Save space actions.",
   converted: "Deduplicated",
   files_left_separate: "{count} remained separate",
   skipped_action: "Kept separate",
   separated: "Separated",
-  reclaimed: "Deleted",
+  reclaimed: "Cleaned up",
   event_convert: "Deduplicated",
   event_found: "Duplicate found",
   event_adopt: "Added",
-  event_reclaim: "Deleted unused file",
+  event_reclaim: "Cleaned up unused link",
   event_undo: "Undid deduplication",
   event_diverged: "Changed by an app — no longer deduplicated",
   event_detach: "Separated",
@@ -280,6 +292,16 @@ const sourcePath = (source) => {
   if (source.kind === "app") return IS_APP_MODE ? (source.display_path || source.root || "") : ""
   return source.display_path || source.root || ""
 }
+const externalLocation = (item) => {
+  const source = sourceById(item.source_id)
+  if (!source || source.kind !== "external") return ""
+  const base = sourcePath(source).replace(/[\\/]+$/, "")
+  const relative = String(item.relative_path || "").replace(/^[\\/]+/, "")
+  if (!base) return relative
+  if (!relative) return base
+  const separator = base.includes("\\") && !base.includes("/") ? "\\" : "/"
+  return `${base}${separator}${separator === "\\" ? relative.replace(/\//g, "\\") : relative}`
+}
 const isDescendantSource = (candidateId, parentId) => {
   if (!parentId) return true
   if (candidateId === parentId) return true
@@ -337,9 +359,10 @@ const getCounts = (items) => ({
   all: items.length,
   duplicates: items.filter((item) => item.status === "duplicate").length,
   shared: items.filter((item) => item.status === "shared").length,
+  tracked: items.filter((item) => item.status === "tracked").length,
   independent: items.filter((item) => item.status === "independent").length,
   reclaimable: state.data.blobs.filter((blob) => blob.orphan).length,
-  activity: state.data.events.length
+  activity: activityItems("").length
 })
 
 const sourceCounts = (items) => {
@@ -362,6 +385,7 @@ const activeItems = (items) => {
   let result = items
   if (state.view === "duplicates") result = result.filter((item) => item.status === "duplicate")
   if (state.view === "shared") result = result.filter((item) => item.status === "shared")
+  if (state.view === "tracked") result = result.filter((item) => item.status === "tracked")
   if (state.view === "independent") result = result.filter((item) => item.status === "independent")
   if (state.sourceId) result = result.filter((item) => isDescendantSource(item.source_id, state.sourceId))
   if (state.view === "all" && state.statusFilter !== "all") result = result.filter((item) => item.status === state.statusFilter)
@@ -374,6 +398,7 @@ const viewIcon = {
   all: "fa-regular fa-file-lines",
   duplicates: "fa-regular fa-copy",
   shared: "fa-solid fa-link",
+  tracked: "fa-regular fa-circle-check",
   independent: "fa-solid fa-circle-minus",
   reclaimable: "fa-regular fa-trash-can",
   activity: "fa-solid fa-wave-square"
@@ -382,6 +407,7 @@ const viewLabel = {
   all: COPY.all,
   duplicates: COPY.duplicates,
   shared: COPY.shared,
+  tracked: COPY.tracked,
   independent: COPY.skipped,
   reclaimable: COPY.reclaimable,
   activity: COPY.activity
@@ -397,18 +423,30 @@ const eventLabels = {
   skip: COPY.event_skip,
   reshare: COPY.event_reshare
 }
-const activityItems = () => {
-  const query = state.query.toLowerCase()
-  return state.data.events.filter((event) => !query ||
+const activityItems = (queryText = state.query) => {
+  const query = queryText.trim().toLowerCase()
+  const events = state.data.events.filter((event) => !query ||
     `${eventLabels[event.kind] || event.kind} ${event.path || ""}`.toLowerCase().includes(query))
+  const seenBatches = new Set()
+  const eventItems = events.map((event) => {
+    const showUndo = event.kind === "convert" && event.batch_id &&
+      event.undoable !== false && !seenBatches.has(event.batch_id)
+    if (showUndo) seenBatches.add(event.batch_id)
+    return Object.assign({}, event, { activity_type: "event", show_undo: showUndo })
+  })
+  const batchItems = (Array.isArray(state.data.undo_batches) ? state.data.undo_batches : [])
+    .filter((batch) => !seenBatches.has(batch.batch_id) && (!query ||
+      `${COPY.event_convert} ${batch.files || 0} ${COPY.files}`.toLowerCase().includes(query)))
+    .map((batch) => Object.assign({}, batch, { activity_type: "batch" }))
+  return batchItems.concat(eventItems)
 }
 
 const renderViews = (items) => {
   const counts = getCounts(items)
   el("views-label").textContent = COPY.views
   const views = IS_APP_MODE
-    ? ["all", "duplicates", "shared", "independent", "activity"]
-    : ["all", "duplicates", "shared", "independent", "reclaimable", "activity"]
+    ? ["all", "duplicates", "shared", "tracked", "independent", "activity"]
+    : ["all", "duplicates", "shared", "tracked", "independent", "reclaimable", "activity"]
   el("vault-views").innerHTML = views.map((view) => `
     <button class="vault-nav-row ${state.view === view ? "selected" : ""}" type="button" data-view="${view}" ${state.view === view ? 'aria-current="page"' : ""}>
       <i class="${viewIcon[view]}"></i>
@@ -516,12 +554,14 @@ const updateToolbarSummary = (visibleItems) => {
 const searchPlaceholder = () => {
   if (state.view === "duplicates") return COPY.search_duplicates
   if (state.view === "shared") return COPY.search_shared
+  if (state.view === "tracked") return COPY.search_tracked
   if (state.view === "independent") return COPY.search_skipped
   if (state.view === "activity") return COPY.search_activity
   const source = selectedSource()
   return source && source.kind === "app" ? COPY.search_in.replace("{location}", source.label) : COPY.search_all
 }
-const supportsDisplayMode = () => state.view === "all" || state.view === "shared" || state.view === "independent"
+const supportsDisplayMode = () => state.view === "all" || state.view === "shared" ||
+  state.view === "tracked" || state.view === "independent"
 const displayModeControl = () => supportsDisplayMode() ? `<div class="vault-display-mode" role="group" aria-label="${attr(COPY.display_mode)}">
   <button type="button" data-display-mode="folders" aria-pressed="${state.displayMode === "folders"}" class="${state.displayMode === "folders" ? "selected" : ""}">${esc(COPY.folders)}</button>
   <button type="button" data-display-mode="files" aria-pressed="${state.displayMode === "files"}" class="${state.displayMode === "files" ? "selected" : ""}">${esc(COPY.files_mode)}</button>
@@ -589,7 +629,7 @@ const sharingControl = (item) => {
 const fileDetail = (item) => {
   if (!state.expandedFiles.has(item.path) || !item.locations || item.locations.length < 2) return ""
   return `<div class="vault-detail"><div class="vault-detail-label">${esc(COPY.identical_contents_at)} ${countLabel(item.locations.length, COPY.location, COPY.locations_lower)}</div>${item.locations.map((location) => `
-    <div class="vault-location-detail"><i class="fa-regular fa-file"></i><span>${esc(location.source_label || "")}${location.relative_path ? ` / ${esc(location.relative_path)}` : ""}</span></div>`).join("")}</div>`
+    <div class="vault-location-detail"><i class="fa-regular fa-file"></i><span>${esc(externalLocation(location) || [location.source_label, location.relative_path].filter(Boolean).join(" / "))}</span></div>`).join("")}</div>`
 }
 
 const renderFileRow = (item, depth = 0, showMatch = false) => {
@@ -686,7 +726,8 @@ const sourceSort = (a, b) => {
   const rank = (source) => source && source.kind === "external" ? 1 : source ? 0 : 2
   return rank(first) - rank(second) || groupTitle(first).localeCompare(groupTitle(second))
 }
-const flatLocation = (item) => [groupTitle(sourceById(item.source_id)), item.relative_path].filter(Boolean).join(" / ")
+const flatLocation = (item) => externalLocation(item) ||
+  [groupTitle(sourceById(item.source_id)), item.relative_path].filter(Boolean).join(" / ")
 const renderFlatFiles = (items) => [...items]
   .sort((a, b) => compareRows(a, b, flatLocation))
   .map((item) => {
@@ -750,6 +791,7 @@ const emptyState = (view) => {
       : [COPY.no_files, COPY.no_files_hint, "fa-regular fa-folder-open"],
     duplicates: [COPY.no_duplicates, COPY.no_duplicates_hint, "fa-regular fa-circle-check"],
     shared: [COPY.no_shared, COPY.no_shared_hint, "fa-solid fa-link"],
+    tracked: [COPY.no_tracked, COPY.no_tracked_hint, "fa-regular fa-circle-check"],
     independent: [COPY.no_skipped, COPY.no_skipped_hint, "fa-solid fa-circle-minus"],
     reclaimable: [COPY.no_reclaimable, COPY.no_reclaimable_hint, "fa-regular fa-circle-check"],
     activity: [COPY.no_activity, COPY.no_activity_hint, "fa-solid fa-wave-square"]
@@ -763,30 +805,21 @@ const renderReclaimable = (blobs) => {
   return blobs.map((blob) => `<div class="vault-file-row"><div class="vault-name-cell"><span class="vault-disclosure"></span><i class="fa-regular fa-file vault-name-icon"></i><span class="vault-name-copy"><span class="vault-file-name">${esc(blob.names[0] ? basename(blob.names[0].path) : `${blob.hash.slice(0, 12)}…`)}</span></span></div><span class="vault-size">${fmt(blob.size)}</span><span class="vault-space">${fmt(blob.size)}</span><span class="vault-row-action"><button class="vault-text-button" type="button" data-reclaim="${attr(blob.hash)}">${esc(COPY.reclaim)}</button></span></div>`).join("")
 }
 
-const renderActivity = () => {
-  const events = activityItems()
-  const query = state.query.trim().toLowerCase()
-  const undoBatches = Array.isArray(state.data.undo_batches)
-    ? state.data.undo_batches.filter((batch) => !query ||
-      `${COPY.event_convert} ${batch.files || 0} ${COPY.files}`.toLowerCase().includes(query))
-    : []
-  if (!events.length && !undoBatches.length) return emptyState("activity")
-  const seenBatches = new Set()
-  const eventRows = events.map((event) => {
-    let undo = ""
-    if (event.kind === "convert" && event.batch_id && event.undoable !== false && !seenBatches.has(event.batch_id)) {
-      seenBatches.add(event.batch_id)
-      undo = `<button class="vault-text-button" type="button" data-undo="${attr(event.batch_id)}">${esc(COPY.undo)}</button>`
+const renderActivity = (items) => {
+  if (!items.length) return emptyState("activity")
+  return items.map((item) => {
+    if (item.activity_type === "batch") {
+      return `<div class="vault-file-row"><div class="vault-name-cell"><span class="vault-disclosure"></span><i class="fa-solid fa-wave-square vault-name-icon"></i><span class="vault-name-copy"><span class="vault-file-name vault-event-kind">${esc(COPY.event_convert)}</span><span class="vault-file-path">${esc(countLabel(item.files || 0))}</span></span></div><span class="vault-size">${fmt(item.bytes || 0)}</span><span class="vault-event-time">${item.ts ? esc(new Date(item.ts).toLocaleString()) : "—"}</span><span class="vault-row-action"><button class="vault-text-button" type="button" data-undo="${attr(item.batch_id)}">${esc(COPY.undo)}</button></span></div>`
     }
+    const event = item
+    const undo = event.show_undo
+      ? `<button class="vault-text-button" type="button" data-undo="${attr(event.batch_id)}">${esc(COPY.undo)}</button>`
+      : ""
     const eventPath = event.path
       ? `${event.source_label ? `${event.source_label} / ` : ""}${event.relative_path || event.path}`
       : (event.hash || "").slice(0, 12)
     return `<div class="vault-file-row"><div class="vault-name-cell"><span class="vault-disclosure"></span><i class="fa-solid fa-wave-square vault-name-icon"></i><span class="vault-name-copy"><span class="vault-file-name vault-event-kind">${esc(eventLabels[event.kind] || event.kind)}</span><span class="vault-file-path">${esc(eventPath)}</span></span></div><span class="vault-size">${event.bytes_saved ? fmt(event.bytes_saved) : event.size ? fmt(event.size) : "—"}</span><span class="vault-event-time">${esc(new Date(event.ts).toLocaleString())}</span><span class="vault-row-action">${undo}</span></div>`
   }).join("")
-  const batchRows = undoBatches.filter((batch) => !seenBatches.has(batch.batch_id)).map((batch) =>
-    `<div class="vault-file-row"><div class="vault-name-cell"><span class="vault-disclosure"></span><i class="fa-solid fa-wave-square vault-name-icon"></i><span class="vault-name-copy"><span class="vault-file-name vault-event-kind">${esc(COPY.event_convert)}</span><span class="vault-file-path">${esc(countLabel(batch.files || 0))}</span></span></div><span class="vault-size">${fmt(batch.bytes || 0)}</span><span class="vault-event-time">${batch.ts ? esc(new Date(batch.ts).toLocaleString()) : "—"}</span><span class="vault-row-action"><button class="vault-text-button" type="button" data-undo="${attr(batch.batch_id)}">${esc(COPY.undo)}</button></span></div>`
-  ).join("")
-  return batchRows + eventRows
 }
 
 const renderTable = (items) => {
@@ -804,7 +837,7 @@ const renderTable = (items) => {
   } else if (state.view === "activity") {
     tableClass = "activity"
     headers = [COPY.name, COPY.size, COPY.last_scanned, ""]
-    body = renderActivity()
+    body = renderActivity(items)
   } else if (state.displayMode === "files" && supportsDisplayMode()) {
     tableClass = "flat"
     headers = [COPY.name, COPY.location_column, COPY.size, COPY.status]
@@ -837,9 +870,6 @@ const orderedItems = (items) => {
 }
 
 const pagedItems = (items) => {
-  if (state.view === "activity") {
-    return { items, start: 0, end: items.length, total: items.length, pages: 1 }
-  }
   const context = JSON.stringify([
     state.view, state.sourceId, state.query, state.statusFilter,
     state.displayMode, state.sizeSort
@@ -870,6 +900,7 @@ const paneFooterText = (items) => {
   }
   if (state.view === "duplicates") return COPY.duplicate_note
   if (state.view === "reclaimable") return COPY.reclaimable_note
+  if (state.view === "activity") return COPY.activity_note
   return COPY.tracked_note.replace("{size}", fmt(candidateSize()))
 }
 
@@ -910,23 +941,31 @@ const renderOverview = () => {
         (!!last || beforeBytes > 0 || afterBytes > 0 || Number(data.pending_bytes) > 0)
     const afterRatio = beforeBytes ? Math.min(100, (afterBytes / beforeBytes) * 100) : 0
     const pendingBytes = Math.max(0, Number(data.pending_bytes) || 0)
+    // The headline reports bytes actually freed by user actions, so it always
+    // survives a comparison against the OS file manager. Sharing that already
+    // existed when a scan adopted it (package-manager hardlinks, earlier runs)
+    // never changed free space and stays out of this number.
+    const freedBytes = Math.max(0, Number(data.lifetime_bytes_saved) || 0)
+    const sharedNow = Math.max(0, Number(data.saved_by_sharing) || 0)
     const headline = hasComparison
       ? (IS_APP_MODE
-          ? COPY.saved_for_app.replace("{size}", fmt(Math.max(0, beforeBytes - afterBytes)))
-          : `${fmt(data.saved_by_sharing)} ${COPY.disk_space_saved}`)
+          ? COPY.sharing_saves_for_app.replace("{size}", fmt(Math.max(0, beforeBytes - afterBytes)))
+          : `${fmt(freedBytes)} ${COPY.disk_space_freed}`)
       : (IS_APP_MODE ? COPY.find_app_savings : COPY.find_savings)
-    const help = IS_APP_MODE ? COPY.effective_help : COPY.before_help
+    const beforeLabel = COPY.without_sharing
+    const afterLabel = IS_APP_MODE ? COPY.app_share : COPY.on_disk
+    const help = IS_APP_MODE ? COPY.effective_help : COPY.without_sharing_help
     const helpId = IS_APP_MODE ? "vault-after-help" : "vault-before-help"
     const helpMarkup = `<span class="vault-compare-info" tabindex="0" aria-describedby="${helpId}"><i class="fa-regular fa-circle-question" aria-hidden="true"></i><span class="vault-compare-tooltip" id="${helpId}" role="tooltip">${esc(help)}</span></span>`
     const comparison = hasComparison ? `
-      <div class="vault-comparison" aria-label="${attr(`${COPY.before}: ${fmt(beforeBytes)}. ${COPY.after}: ${fmt(afterBytes)}.`)}">
+      <div class="vault-comparison" aria-label="${attr(`${beforeLabel}: ${fmt(beforeBytes)}. ${afterLabel}: ${fmt(afterBytes)}.`)}">
         <div class="vault-compare-row">
-          <span class="vault-compare-label">${esc(COPY.before)}${IS_APP_MODE ? "" : helpMarkup}</span>
+          <span class="vault-compare-label">${esc(beforeLabel)}${IS_APP_MODE ? "" : helpMarkup}</span>
           <span class="vault-compare-track"><span class="vault-compare-fill before"></span></span>
           <span class="vault-compare-value">${fmt(beforeBytes)}</span>
         </div>
         <div class="vault-compare-row">
-          <span class="vault-compare-label">${esc(COPY.after)}${IS_APP_MODE ? helpMarkup : ""}</span>
+          <span class="vault-compare-label">${esc(afterLabel)}${IS_APP_MODE ? helpMarkup : ""}</span>
           <span class="vault-compare-track"><span class="vault-compare-fill after" style="--vault-after-ratio:${afterRatio.toFixed(2)}%"></span></span>
           <span class="vault-compare-value">${fmt(afterBytes)}</span>
         </div>
@@ -947,10 +986,14 @@ const renderOverview = () => {
     const storageDetails = !IS_APP_MODE && el("vault-storage-details")
     if (storageDetails) {
       const homeBytes = last ? (last.home_bytes_total == null ? last.bytes_total : last.home_bytes_total) : null
+      // Clamped because deleting linked files later shrinks the live sharing
+      // total without touching the lifetime counter.
+      const alreadyShared = Math.max(0, sharedNow - freedBytes)
       storageDetails.innerHTML = `<div class="vault-advanced-title">${esc(COPY.storage_details)}</div>
         <dl class="vault-storage-list">
           <div><dt>${esc(COPY.pinokio_folder)}</dt><dd>${homeBytes == null ? "—" : fmt(homeBytes)}</dd></div>
-          <div><dt>${esc(COPY.saved_by_actions)}</dt><dd>${fmt(data.lifetime_bytes_saved)}</dd></div>
+          <div><dt>${esc(COPY.kept_deduplicated)}</dt><dd>${fmt(sharedNow)}</dd></div>
+          <div><dt>${esc(COPY.already_shared)}</dt><dd>${fmt(alreadyShared)}</dd></div>
         </dl>`
     }
   }
@@ -1188,12 +1231,34 @@ const renderCloudWarning = () => {
   warning.innerHTML = `<i class="fa-solid fa-triangle-exclamation"></i><span>${esc(message)}</span><button class="vault-text-button" id="btn-dismiss-cloud" type="button" data-warning-key="${attr(key)}">${esc(COPY.dismiss)}</button>`
 }
 
+const renderCleanupNotice = () => {
+  const notice = el("vault-cleanup-notice")
+  const blobs = state.data && Array.isArray(state.data.blobs) ? state.data.blobs : []
+  const unused = !IS_APP_MODE && state.data && state.data.enabled
+    ? blobs.filter((blob) => blob.orphan)
+    : []
+  if (!unused.length || state.view === "reclaimable") {
+    notice.className = "vault-cleanup-notice"
+    notice.innerHTML = ""
+    return
+  }
+  const bytes = unused.reduce((sum, blob) => sum + (Number(blob.size) || 0), 0)
+  const title = COPY.cleanup_ready.replace("{size}", fmt(bytes))
+  const detail = COPY.cleanup_ready_detail.replace(
+    "{count}",
+    countLabel(unused.length, COPY.private_link, COPY.private_links)
+  )
+  notice.className = "vault-cleanup-notice show"
+  notice.innerHTML = `<i class="fa-solid fa-broom" aria-hidden="true"></i><strong>${esc(title)}</strong><span class="vault-cleanup-notice-detail">${esc(detail)}</span><button class="vault-button" id="btn-review-cleanup" type="button">${esc(COPY.review_cleanup)}<i class="fa-solid fa-chevron-right" aria-hidden="true"></i></button>`
+}
+
 const render = () => {
   if (!state.data) return
   renderOverview()
   renderResult()
   renderFeedback()
   renderCloudWarning()
+  renderCleanupNotice()
   if (!state.data.enabled) {
     el("vault-explorer").style.display = "none"
     return
@@ -1263,13 +1328,16 @@ const applyFullData = (data) => {
   render()
   return scanning || !!fileAction
 }
+let refreshSequence = 0
 const refresh = async (forceFull = false) => {
+  const sequence = ++refreshSequence
   let delay = null
   try {
     const progressOnly = !forceFull &&
       !!(state.data && (scanActive(state.data.scan) || state.actionProgress))
     if (progressOnly) {
       const progress = await fetchJson(statusUrl(true))
+      if (sequence !== refreshSequence) return
       state.data.scan = progress.scan
       state.data.last_scan = progress.last_scan
       const fileAction = serverFileAction(progress.file_action)
@@ -1281,16 +1349,22 @@ const refresh = async (forceFull = false) => {
         renderActionProgress()
         renderFeedback()
       } else {
-        if (applyFullData(await fetchJson(statusUrl())) || state.scanRequested) delay = 1500
+        const data = await fetchJson(statusUrl())
+        if (sequence !== refreshSequence) return
+        if (applyFullData(data) || state.scanRequested) delay = 1500
       }
     } else {
-      if (applyFullData(await fetchJson(statusUrl())) || state.scanRequested) delay = 1500
+      const data = await fetchJson(statusUrl())
+      if (sequence !== refreshSequence) return
+      if (applyFullData(data) || state.scanRequested) delay = 1500
     }
   } catch (error) {
+    if (sequence !== refreshSequence) return
     state.feedback = { error: true, message: error && error.message ? error.message : String(error) }
     renderFeedback()
     delay = 5000
   } finally {
+    if (sequence !== refreshSequence) return
     clearTimeout(window.__vaultRefresh)
     window.__vaultRefresh = delay == null ? null : setTimeout(refresh, delay)
   }
@@ -1476,8 +1550,8 @@ document.addEventListener("click", async (event) => {
     state.displayMode = target.dataset.displayMode === "files" ? "files" : "folders"
     state.sizeSort = state.displayMode === "files" ? "desc" : null
     render()
-  } else if (target.dataset.view) {
-    state.view = target.dataset.view
+  } else if (target.dataset.view || target.id === "btn-review-cleanup") {
+    state.view = target.dataset.view || "reclaimable"
     state.sourceId = SCOPE_ID
     state.query = ""
     state.statusFilter = "all"

package/server/views/partials/vault_workspace.ejs

@@ -25,6 +25,7 @@
       <div class='vault-result' id='vault-result' role='status' aria-live='polite'></div>
       <div class='vault-feedback' id='vault-feedback' role='status' aria-live='polite'></div>
       <div class='vault-cloud-warning' id='vault-cloud-warning' role='status'></div>
+      <div class='vault-cleanup-notice' id='vault-cleanup-notice' role='status'></div>
       <section class='vault-explorer' id='vault-explorer'>
         <aside class='vault-rail'>
           <div class='vault-rail-section'>

package/test/vault-engine.test.js

@@ -97,6 +97,27 @@ describe('vault engine (phase 1)', () => {
     assert.strictEqual(fs.existsSync(path.resolve(h, 'vault', 'registry.json')), true)
   })
 
+  test('startup verification reports unused private links without deleting them', async () => {
+    const h = await home()
+    const vault = await makeVault(h)
+    const content = crypto.randomBytes(4096)
+    const hash = sha256(content)
+    const file = await writeFile(path.resolve(h, 'api', 'appA', 'unused.bin'), content)
+    await vault.adopt(file, hash, { app: 'appA' })
+    await vault.registry.flush()
+    await fs.promises.unlink(file)
+
+    const fresh = new Vault(fakeKernel(h))
+    await fresh.init({ existingOnly: true })
+    fresh.verificationPending = true
+    await fresh.ensureInitialized()
+
+    assert.strictEqual(fs.existsSync(fresh.storePathFor(hash)), true)
+    assert.strictEqual(fresh.registry.links.has(file), false)
+    assert.strictEqual(fresh.registry.blobs.get(hash).orphan, true)
+    assert.strictEqual((await fresh.status()).reclaimable, content.length)
+  })
+
   test('adopt: metadata-only, store name shares the inode', async () => {
     const h = await home()
     const vault = await makeVault(h)

package/test/vault-ui.test.js

@@ -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,27 +1235,36 @@ 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, /disk_space_freed:\s*"of disk space freed"/)
+    assert.match(vaultPage, /without_sharing_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\)/)
+    assert.match(vaultPage, /Number\(data\.saved_by_sharing\)/)
     assert.match(vaultPage, /Number\(data\.bytes_without_sharing\)/)
     assert.match(vaultPage, /Number\(data\.bytes_on_disk\)/)
     assert.match(vaultPage, /Number\(data\.pending_bytes\)/)
@@ -1118,7 +1276,8 @@ describe('vault dashboard backend (phase 4)', () => {
     assert.match(vaultPage, /candidate_size:\s*candidateSize\(\)/)
     assert.match(vaultPage, /localStorage\.setItem\(candidateSizeKey/)
     assert.match(vaultPage, /id='vault-storage-details'/)
-    assert.match(vaultPage, /fmt\(data\.lifetime_bytes_saved\)/)
+    assert.match(vaultPage, /Number\(data\.lifetime_bytes_saved\)/)
+    assert.match(vaultPage, /Math\.max\(0, sharedNow - freedBytes\)/)
     assert.match(vaultPage, /repair_index:\s*"Repair index"/)
     assert.match(vaultPage, /<details class='vault-advanced'/)
     assert.doesNotMatch(vaultPage, /id='btn-rebuild'/)
@@ -1186,7 +1345,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/)
@@ -1366,7 +1526,7 @@ describe('vault dashboard backend (phase 4)', () => {
     await runVaultScript(dom)
     await new Promise((resolve) => setTimeout(resolve, 25))
 
-    assert.strictEqual(dom.window.document.querySelector('.vault-summary-value').textContent, '4.51 GB saved for this app')
+    assert.strictEqual(dom.window.document.querySelector('.vault-summary-value').textContent, 'Sharing saves 4.51 GB for this app')
     assert.deepStrictEqual([...dom.window.document.querySelectorAll('.vault-compare-value')].map((node) => node.textContent), ['7.09 GB', '2.58 GB'])
     assert.match(dom.window.document.querySelector('.vault-compare-fill.after').getAttribute('style'), /--vault-after-ratio:36\.36%/)
     assert.strictEqual(dom.window.document.getElementById('vault-after-help').textContent,
@@ -1387,11 +1547,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')
@@ -1439,24 +1602,37 @@ describe('vault dashboard backend (phase 4)', () => {
     await runVaultScript(dom)
     await new Promise((resolve) => setTimeout(resolve, 25))
 
-    assert.strictEqual(dom.window.document.querySelector('.vault-summary-value').textContent, '256.95 GB of disk space saved')
-    assert.deepStrictEqual([...dom.window.document.querySelectorAll('.vault-compare-label')].map((node) => node.firstChild.textContent.trim()), ['Before', 'After'])
+    assert.strictEqual(dom.window.document.querySelector('.vault-summary-value').textContent, '258.77 GB of disk space freed')
+    assert.deepStrictEqual([...dom.window.document.querySelectorAll('.vault-compare-label')].map((node) => node.firstChild.textContent.trim()), ['Without sharing', 'On disk'])
     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')
     assert.strictEqual(dom.window.document.getElementById('btn-review-metric').classList.contains('primary'), true)
     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/)
+    assert.match(dom.window.document.getElementById('vault-storage-details').textContent, /Kept deduplicated\s*256\.95 GB/)
+    // lifetime (241) exceeds live sharing (239.3) here, so the clamp keeps
+    // the pre-existing figure at zero instead of going negative.
+    assert.match(dom.window.document.getElementById('vault-storage-details').textContent, /Already shared before Save space\s*0 B/)
+    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 +1648,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()
   })
 
@@ -1511,12 +1688,13 @@ describe('vault dashboard backend (phase 4)', () => {
     await new Promise((resolve) => setTimeout(resolve, 25))
 
     assert.strictEqual(dom.window.document.querySelector('.vault-summary-value').textContent,
-      '3 GB of disk space saved')
+      '3 GB of disk space freed')
     assert.deepStrictEqual(
       [...dom.window.document.querySelectorAll('.vault-compare-value')].map((node) => node.textContent),
       ['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 +1727,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 +2031,156 @@ 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'), {
@@ -2148,6 +2476,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"')