pinokiod 8.0.56 → 8.0.58

package/kernel/vault/automatic_scans.js

@@ -152,8 +152,9 @@ class AutomaticScans {
     return setting && setting.mode === "manual" ? "manual" : "automatic"
   }
 
-  broadcast() {
+  broadcast(completion = null) {
     const snapshot = this.snapshot()
+    if (completion) snapshot.completion = completion
     for (const listener of this.listeners) {
       try {
         listener(snapshot)
@@ -617,6 +618,7 @@ class AutomaticScans {
 
   async precheckFinished(active, result, error) {
     const app = active.app
+    let completion = null
     try {
       await this.withAppTransition(app, async () => {
         let reason = active.reason
@@ -661,13 +663,20 @@ class AutomaticScans {
           ? Object.assign({}, this.settings.get(app))
           : null
         try {
-          await this.publishResultNow(app, result)
+          const outcome = await this.publishResultNow(app, result)
+          if (outcome === "empty") {
+            completion = {
+              app,
+              outcome: "no_possible_duplicates"
+            }
+          }
         } catch (publicationError) {
           this.restorePrevious(app)
           throw publicationError
         }
         reason = active.reason
         if (reason) {
+          completion = null
           await this.restorePublishedState(app, entry, previousSetting)
           this.entries.set(app, entry)
           this.log("publication-reverted", { app, reason })
@@ -682,7 +691,7 @@ class AutomaticScans {
       })
     } finally {
       if (this.active === active) this.active = null
-      this.broadcast()
+      this.broadcast(completion)
       this.schedule()
     }
   }
@@ -764,7 +773,7 @@ class AutomaticScans {
         possible_files: possibleFiles,
         acknowledged: acknowledged === result.signature
       })
-      return
+      return "result"
     }
     const acknowledged = (this.settings.get(app) || {})
       .acknowledged_signature
@@ -777,6 +786,7 @@ class AutomaticScans {
     }
     this.entries.delete(app)
     this.log("no-possible-matches", { app })
+    return "empty"
   }
 
   async clearAutomaticState(apps, reason, options = {}) {

package/package.json

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

package/server/index.js

@@ -1993,6 +1993,19 @@ class Server {
     const vault = this.kernel.vault
     if (vault && vault.ready) await vault.ready
     result.vault_enabled = !!(vault && vault.enabled)
+    result.vault_automatic_mode = "automatic"
+    if (result.vault_enabled) {
+      try {
+        const snapshot = await vault.automaticScanStatus()
+        const setting = Array.isArray(snapshot && snapshot.settings)
+          ? snapshot.settings.find((item) =>
+            item && item.app === name)
+          : null
+        result.vault_automatic_mode = setting && setting.mode === "manual"
+          ? "manual"
+          : "automatic"
+      } catch (_) {}
+    }
     if (!registryEnabled) {
       result.pendingSnapshotId = null
     }

package/server/public/app-vault-mode.js

@@ -0,0 +1,37 @@
+(() => {
+  const status = document.querySelector("[data-app-vault-mode]")
+  if (!status) return
+
+  const app = status.dataset.app || ""
+  const tab = status.closest("#save-space-tab")
+  const label = status.querySelector("[data-app-vault-mode-label]")
+  const setMode = (value) => {
+    const mode = value === "manual" ? "manual" : "automatic"
+    status.dataset.mode = mode
+    status.hidden = false
+    if (label) label.textContent = mode === "automatic" ? "Auto" : "Manual"
+    if (tab) {
+      tab.setAttribute("aria-label",
+        `Disk Saver — ${mode === "automatic" ? "Automatic" : "Manual"} checking`)
+    }
+  }
+  const applySnapshot = (snapshot) => {
+    const settings = snapshot && Array.isArray(snapshot.settings)
+      ? snapshot.settings
+      : []
+    const setting = settings.find((item) => item && item.app === app)
+    setMode(setting && setting.mode)
+  }
+
+  setMode(status.dataset.mode)
+  if (!app || typeof window.EventSource !== "function") return
+
+  const source = new window.EventSource(
+    "/info/vault/automatic-scans/events")
+  source.onmessage = (event) => {
+    try {
+      applySnapshot(JSON.parse(event.data))
+    } catch (_) {}
+  }
+  window.addEventListener("beforeunload", () => source.close(), { once: true })
+})()

package/server/public/layout.js

@@ -866,8 +866,16 @@
         <circle cx="10" cy="10" r="7.5"></circle>
         <path d="M8 7.25v5.5M12 7.25v5.5"></path>
       </svg>`;
+    const COMPLETE_ICON = `
+      <svg viewBox="0 0 20 20" aria-hidden="true">
+        <circle cx="10" cy="10" r="7.5"></circle>
+        <path d="m6.75 10.1 2.1 2.1 4.6-4.65"></path>
+      </svg>`;
+    const COMPLETION_VISIBLE_MS = 4000;
 
     let eventSource = null;
+    let visibleCheckingApps = new Set();
+    const completions = new Map();
 
     function statusText(row) {
       if (row.state === 'paused') {
@@ -912,6 +920,97 @@
       tray.hidden = tray.childElementCount === 0;
     }
 
+    function removeCompletion(app) {
+      const completion = completions.get(app);
+      if (!completion) return;
+      if (completion.timer) window.clearTimeout(completion.timer);
+      completions.delete(app);
+      removeRow(completion.item);
+    }
+
+    function clearCompletions() {
+      [...completions.keys()].forEach(removeCompletion);
+    }
+
+    function scheduleCompletion(completion) {
+      if (completion.paused.size || completion.timer) return;
+      completion.startedAt = Date.now();
+      completion.timer = window.setTimeout(() => {
+        completion.timer = null;
+        removeCompletion(completion.app);
+      }, completion.remaining);
+    }
+
+    function setCompletionPaused(completion, reason, paused) {
+      if (paused) {
+        if (completion.paused.has(reason)) return;
+        if (!completion.paused.size && completion.timer) {
+          completion.remaining = Math.max(0,
+            completion.remaining - (Date.now() - completion.startedAt));
+          window.clearTimeout(completion.timer);
+          completion.timer = null;
+        }
+        completion.paused.add(reason);
+        return;
+      }
+      completion.paused.delete(reason);
+      if (!completion.paused.size) scheduleCompletion(completion);
+    }
+
+    function startCompletion(app) {
+      if (completions.has(app)) return;
+      const item = document.createElement('div');
+      item.className = 'vault-auto-scan-row';
+      item.dataset.state = 'complete';
+
+      const close = document.createElement('button');
+      close.type = 'button';
+      close.className = 'vault-auto-scan-close';
+      close.setAttribute('aria-label',
+        `Dismiss Disk Saver completion for ${app}`);
+      close.title = 'Dismiss';
+      close.textContent = '×';
+
+      const icon = document.createElement('span');
+      icon.className = 'vault-auto-scan-icon';
+      icon.innerHTML = COMPLETE_ICON;
+
+      const copy = document.createElement('span');
+      copy.className = 'vault-auto-scan-copy';
+      const appName = document.createElement('span');
+      appName.className = 'vault-auto-scan-app';
+      appName.textContent = app;
+      appName.title = app;
+      const status = document.createElement('span');
+      status.className = 'vault-auto-scan-status';
+      status.textContent = 'No possible duplicate files found';
+      copy.append(appName, status);
+      item.append(close, icon, copy);
+
+      const completion = {
+        app,
+        item,
+        timer: null,
+        remaining: COMPLETION_VISIBLE_MS,
+        startedAt: 0,
+        paused: new Set()
+      };
+      close.addEventListener('click', () => removeCompletion(app));
+      item.addEventListener('mouseenter', () =>
+        setCompletionPaused(completion, 'pointer', true));
+      item.addEventListener('mouseleave', () =>
+        setCompletionPaused(completion, 'pointer', false));
+      item.addEventListener('focusin', () =>
+        setCompletionPaused(completion, 'focus', true));
+      item.addEventListener('focusout', (event) => {
+        if (!item.contains(event.relatedTarget)) {
+          setCompletionPaused(completion, 'focus', false);
+        }
+      });
+      completions.set(app, completion);
+      scheduleCompletion(completion);
+    }
+
     function automaticSettingsKey(app) {
       return `pinokio:vault:auto-settings:${encodeURIComponent(app)}`;
     }
@@ -968,15 +1067,34 @@
       return opened;
     }
 
-    function render(snapshot) {
+    function render(snapshot, options = {}) {
       const rows = snapshot && Array.isArray(snapshot.rows)
         ? snapshot.rows
         : [];
+      const validRows = rows.filter((row) =>
+        row && typeof row.app === 'string' && row.app);
+      const liveApps = new Set(validRows.map((row) => row.app));
+      [...completions.keys()].forEach((app) => {
+        if (liveApps.has(app)) removeCompletion(app);
+      });
+      const manualApps = new Set(snapshot && Array.isArray(snapshot.settings)
+        ? snapshot.settings.filter((setting) =>
+          setting && setting.mode === 'manual').map((setting) => setting.app)
+        : []);
+      manualApps.forEach(removeCompletion);
+
+      const completion = snapshot && snapshot.completion;
+      if (options.acceptCompletion && completion &&
+          completion.outcome === 'no_possible_duplicates' &&
+          typeof completion.app === 'string' && completion.app &&
+          visibleCheckingApps.has(completion.app) &&
+          !liveApps.has(completion.app) &&
+          !manualApps.has(completion.app)) {
+        startCompletion(completion.app);
+      }
+
       const fragment = document.createDocumentFragment();
-      rows.forEach((row) => {
-        if (!row || typeof row.app !== 'string' || !row.app) {
-          return;
-        }
+      validRows.forEach((row) => {
         const item = document.createElement('div');
         item.className = 'vault-auto-scan-row';
         item.dataset.state = row.state || 'checking';
@@ -988,6 +1106,7 @@
         close.title = 'Dismiss';
         close.textContent = '×';
         close.addEventListener('click', async () => {
+          if (row.state === 'checking') visibleCheckingApps.delete(row.app);
           close.disabled = true;
           try {
             const result = await requestAction(
@@ -1000,6 +1119,9 @@
             removeRow(item);
           } catch (error) {
             console.warn('[Disk Saver] Automatic check dismissal failed', error);
+            if (row.state === 'checking' && item.isConnected) {
+              visibleCheckingApps.add(row.app);
+            }
             close.disabled = false;
           }
         });
@@ -1088,8 +1210,16 @@
         item.append(close, icon, copy, controls);
         fragment.appendChild(item);
       });
+      completions.forEach((completionRow) => {
+        if (!liveApps.has(completionRow.app)) {
+          fragment.appendChild(completionRow.item);
+        }
+      });
       tray.replaceChildren(fragment);
       tray.hidden = tray.childElementCount === 0;
+      visibleCheckingApps = new Set(validRows
+        .filter((row) => row.state === 'checking')
+        .map((row) => row.app));
     }
 
     async function loadState() {
@@ -1119,12 +1249,13 @@
         '/info/vault/automatic-scans/events');
       eventSource.onmessage = (event) => {
         try {
-          render(JSON.parse(event.data));
+          render(JSON.parse(event.data), { acceptCompletion: true });
         } catch (error) {
           console.debug('[Disk Saver] Invalid automatic check state', error);
         }
       };
       eventSource.onerror = () => {
+        clearCompletions();
         loadState();
       };
     }

package/server/public/vault.js

@@ -2274,8 +2274,8 @@ const renderOverview = () => {
     : activeScan
       ? `<i class="fa-solid fa-circle-notch fa-spin"></i>${esc(COPY.scanning)}`
     : `<i class="fa-solid fa-rotate"></i>${esc(idleScanLabel)}`
-  const firstGlobalScan = !IS_APP_MODE && !last && !activeScan
-  scanButton.classList.toggle("primary", firstGlobalScan)
+  const firstScan = !last && !activeScan
+  scanButton.classList.toggle("primary", firstScan)
   scanButton.disabled = busyElsewhere || state.scanCancelRequested
   if (state.automaticReviewRequested && !activeScan &&
       !scanButton.disabled) {
@@ -2296,7 +2296,7 @@ const renderOverview = () => {
   if (scanSizeMenu) {
     const scanSizeTrigger = scanSizeMenu.querySelector("summary")
     if (scanSizeTrigger) {
-      scanSizeTrigger.classList.toggle("primary", firstGlobalScan)
+      scanSizeTrigger.classList.toggle("primary", firstScan)
     }
     scanSizeMenu.hidden = activeScan
     if (activeScan) scanSizeMenu.open = false

package/server/views/app.ejs

@@ -4102,6 +4102,48 @@ body.dark .disk-usage {
   flex: 0 0 auto;
   min-width: 0;
 }
+.appcanvas.vertical > aside .menu-actions #save-space-tab {
+  width: 100%;
+  max-width: none;
+  box-sizing: border-box;
+}
+.app-vault-mode {
+  flex: 0 0 auto;
+  margin-left: auto;
+  color: rgba(71, 85, 105, 0.82);
+  font-size: 12px;
+  font-weight: 500;
+  letter-spacing: 0;
+  line-height: 1.2;
+  text-align: right;
+  white-space: nowrap;
+}
+.app-vault-mode[data-mode="automatic"] {
+  color: #b45309;
+}
+body.dark .app-vault-mode {
+  color: rgba(203, 213, 225, 0.74);
+}
+body.dark .app-vault-mode[data-mode="automatic"] {
+  color: #e0a54b;
+}
+.app-vault-mode-chevron,
+.app-autolaunch-chevron {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 10px;
+  flex: 0 0 10px;
+  margin-right: 0;
+  padding: 0;
+  color: var(--pinokio-sidebar-action-muted);
+  font-size: 10px;
+  line-height: 1;
+  box-sizing: border-box;
+}
+.appcanvas > aside .menu-actions .header-item .tab .app-vault-mode-chevron {
+  margin-right: 0;
+}
 .app-autolaunch-row {
   appearance: none;
   display: flex;
@@ -4171,19 +4213,14 @@ body.dark .disk-usage {
 .app-autolaunch-status {
   flex: 0 0 auto;
   color: var(--pinokio-sidebar-action-muted);
-  font-size: 11px;
-  font-weight: 700;
-  letter-spacing: 0.02em;
+  font-size: 12px;
+  font-weight: 500;
+  letter-spacing: 0;
   white-space: nowrap;
 }
 .app-autolaunch-row[data-enabled="true"] .app-autolaunch-status {
   color: rgba(22, 101, 52, 0.95);
 }
-.app-autolaunch-chevron {
-  flex: 0 0 auto;
-  color: var(--pinokio-sidebar-action-muted);
-  font-size: 10px;
-}
 body.dark .app-autolaunch-row {
   background: transparent;
   color: var(--pinokio-sidebar-tab-muted);
@@ -4193,6 +4230,7 @@ body.dark .app-autolaunch.open .app-autolaunch-row {
   background: var(--pinokio-sidebar-tab-hover);
   color: var(--pinokio-sidebar-tab-active-color);
 }
+body.dark .app-vault-mode-chevron,
 body.dark .app-autolaunch-status,
 body.dark .app-autolaunch-chevron {
   color: var(--pinokio-sidebar-action-muted);
@@ -8163,6 +8201,7 @@ body.dark .pinokio-custom-terminal-header {
 <script src="/tippy-bundle.umd.min.js"></script>
 <script src="/tab-link-popover.js"></script>
 <script src="/browser-popout-surface.js"></script>
+<script src="/app-vault-mode.js" defer></script>
 <script>
 (function() {
   try {
@@ -8461,11 +8500,16 @@ body.dark .pinokio-custom-terminal-header {
           </div>
         </button>
         <% if (typeof vault_enabled !== 'undefined' && vault_enabled) { %>
-        <a id='save-space-tab' data-mode="refresh" target="app-vault" href="/vault/app/<%=encodeURIComponent(name)%>" class="btn header-item frame-link" data-index="vault" data-static="retain" data-tab-link-popover="false">
+        <% const vaultAutomaticMode = typeof vault_automatic_mode === 'string' && vault_automatic_mode === 'manual' ? 'manual' : 'automatic' %>
+        <a id='save-space-tab' data-mode="refresh" target="app-vault" href="/vault/app/<%=encodeURIComponent(name)%>" class="btn header-item frame-link" data-index="vault" data-static="retain" data-tab-link-popover="false" aria-label="Disk Saver — <%=vaultAutomaticMode === 'automatic' ? 'Automatic' : 'Manual'%> checking">
           <div class='tab'>
             <i class="fa-solid fa-hard-drive menu-action-leading-icon"></i>
             <div class='display'>Disk Saver</div>
             <div class='flexible'></div>
+            <span class="app-vault-mode" data-app-vault-mode data-app="<%=name%>" data-mode="<%=vaultAutomaticMode%>" aria-hidden="true">
+              <span data-app-vault-mode-label><%=vaultAutomaticMode === 'automatic' ? 'Auto' : 'Manual'%></span>
+            </span>
+            <i class="fa-solid fa-angle-down app-vault-mode-chevron" aria-hidden="true"></i>
           </div>
         </a>
         <% } %>
@@ -8474,7 +8518,7 @@ body.dark .pinokio-custom-terminal-header {
             <button type="button" class="app-autolaunch-row" data-app-autolaunch-button data-enabled="<%= autolaunch_app.autolaunch_enabled ? 'true' : 'false' %>" aria-haspopup="dialog" aria-expanded="false">
               <span class="app-autolaunch-label"><i class="fa-solid fa-power-off"></i><span>Autolaunch</span></span>
               <span class="app-autolaunch-spacer" aria-hidden="true"></span>
-              <span class="app-autolaunch-status" data-app-autolaunch-status><%= autolaunch_app.autolaunch_enabled ? 'ON' : 'OFF' %></span>
+              <span class="app-autolaunch-status" data-app-autolaunch-status><%= autolaunch_app.autolaunch_enabled ? 'On' : 'Off' %></span>
               <i class="fa-solid fa-angle-down app-autolaunch-chevron" aria-hidden="true"></i>
             </button>
             <div class="app-autolaunch-modal hidden" data-app-autolaunch-modal role="dialog" aria-modal="true" aria-label="Autolaunch">

package/server/views/layout.ejs

@@ -333,7 +333,8 @@
       opacity: 0.55;
     }
 
-    .vault-auto-scan-row[data-state="result"] {
+    .vault-auto-scan-row[data-state="result"],
+    .vault-auto-scan-row[data-state="complete"] {
       grid-template-rows: 16px 30px;
       min-height: 66px;
       padding-top: 10px;
@@ -342,14 +343,25 @@
 
     .vault-auto-scan-row[data-state="result"] .vault-auto-scan-icon,
     .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy,
-    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-controls {
+    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-controls,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-icon,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
       grid-row: 1 / 3;
     }
 
-    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy {
+    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
       grid-template-rows: 16px 30px;
     }
 
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
+      grid-column: 2 / 4;
+    }
+
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-icon {
+      color: var(--vault-notice-accent);
+    }
+
     @keyframes vault-notice-enter {
       from { opacity: 0; transform: translateY(6px); }
       to { opacity: 1; transform: translateY(0); }

package/server/views/partials/app_autolaunch_modal_helpers.ejs

@@ -169,7 +169,7 @@
   }
   const renderStatus = () => {
     const enabled = !!(state && state.autolaunch_enabled)
-    status.textContent = enabled ? "ON" : "OFF"
+    status.textContent = enabled ? "On" : "Off"
     button.dataset.enabled = enabled ? "true" : "false"
     button.setAttribute("aria-label", `Autolaunch. Start with Pinokio ${enabled ? "On" : "Off"}`)
     switchButton.setAttribute("aria-checked", enabled ? "true" : "false")

package/test/launch-requirements-browser.test.js

@@ -122,7 +122,7 @@ function appAutolaunchMarkup(initialApp) {
     <div class="app-autolaunch" data-app-autolaunch data-app-id="target">
       <button type="button" class="app-autolaunch-row" data-app-autolaunch-button data-enabled="${initialApp.autolaunch_enabled ? "true" : "false"}" aria-haspopup="dialog" aria-expanded="false">
         <span class="app-autolaunch-label">Autolaunch</span>
-        <span class="app-autolaunch-status" data-app-autolaunch-status>${initialApp.autolaunch_enabled ? "ON" : "OFF"}</span>
+        <span class="app-autolaunch-status" data-app-autolaunch-status>${initialApp.autolaunch_enabled ? "On" : "Off"}</span>
       </button>
       <div class="app-autolaunch-modal hidden" data-app-autolaunch-modal role="dialog" aria-modal="true" aria-label="Autolaunch">
         <button type="button" class="app-autolaunch-switch" role="switch" aria-checked="${initialApp.autolaunch_enabled ? "true" : "false"}" data-app-autolaunch-switch aria-label="Start with Pinokio">
@@ -478,7 +478,7 @@ browserTest("browser: selecting a launch script from empty state persists and st
       enabled: false
     })
     assert.equal(await page.isChecked('input[name="app-autolaunch-script"][value="start.js"]'), true)
-    assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "OFF")
+    assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "Off")
   })
 })
 
@@ -532,7 +532,7 @@ browserTest("browser: startup toggle from empty selection saves the single eligi
     })
     assert.equal(state.launchRequirementsGets, 0)
     assert.equal(await page.isChecked('input[name="app-autolaunch-script"][value="start.js"]'), true)
-    assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "ON")
+    assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "On")
   })
 })
 
@@ -570,7 +570,7 @@ browserTest("browser: startup toggle from empty selection warns when no eligible
       })
 
       assert.equal(state.autolaunchPosts.length, 0, scenario.name)
-      assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "OFF")
+      assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "Off")
     })
   }
 })

package/test/vault-automatic-scan-ui.test.js

@@ -227,6 +227,234 @@ test("checking notices expose settings, Pause, and dismissal", async () => {
   dom.window.close()
 })
 
+test("an empty automatic check briefly confirms completion", async () => {
+  const template = await fs.promises.readFile(
+    path.join(root, "server", "views", "layout.ejs"), "utf8")
+  const script = await fs.promises.readFile(
+    path.join(root, "server", "public", "layout.js"), "utf8")
+  const html = ejs.render(template, {
+    theme: "light",
+    agent: "web",
+    initialPath: "/v/ComfyUI",
+    defaultPath: "/home",
+    sessionId: null,
+    vaultEnabled: true
+  })
+  const dom = new JSDOM(html, {
+    runScripts: "outside-only",
+    pretendToBeVisual: true,
+    url: "http://localhost/"
+  })
+  const eventSources = []
+  const requests = []
+  const completionTimers = []
+  const nativeSetTimeout = dom.window.setTimeout.bind(dom.window)
+  const nativeClearTimeout = dom.window.clearTimeout.bind(dom.window)
+  dom.window.setTimeout = (callback, delay, ...args) => {
+    if (delay <= 4000 && delay > 3500) {
+      const timer = {
+        callback,
+        delay,
+        cleared: false,
+        id: 10000 + completionTimers.length
+      }
+      completionTimers.push(timer)
+      return timer.id
+    }
+    return nativeSetTimeout(callback, delay, ...args)
+  }
+  dom.window.clearTimeout = (id) => {
+    const timer = completionTimers.find((candidate) => candidate.id === id)
+    if (timer) {
+      timer.cleared = true
+      return
+    }
+    nativeClearTimeout(id)
+  }
+  dom.window.EventSource = class EventSource {
+    constructor(url) {
+      this.url = url
+      eventSources.push(this)
+    }
+    close() {}
+  }
+  dom.window.fetch = async (url, options = {}) => {
+    requests.push({ url, options })
+    if (url === "/info/vault/automatic-scans") {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          enabled: true,
+          rows: [],
+          settings: [{ app: "ComfyUI", mode: "automatic" }]
+        })
+      }
+    }
+    if (url === "/vault/action") {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ dismissed: true, app: "ComfyUI" })
+      }
+    }
+    throw new Error(`Unexpected request: ${url}`)
+  }
+
+  dom.window.eval(script)
+  await waitFor(() => eventSources.length === 1)
+  const send = (payload) => eventSources[0].onmessage({
+    data: JSON.stringify(payload)
+  })
+
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  const tray = dom.window.document.getElementById("vault-auto-scan-tray")
+  assert.equal(tray.hidden, true,
+    "a completion event cannot appear without a visible checking row")
+
+  send({
+    enabled: true,
+    rows: [
+      {
+        app: "ComfyUI",
+        state: "checking",
+        notice_id: "checking:1:"
+      },
+      {
+        app: "OtherApp",
+        state: "paused",
+        notice_id: "paused:1:"
+      }
+    ],
+    settings: [
+      { app: "ComfyUI", mode: "automatic" },
+      { app: "OtherApp", mode: "manual" }
+    ]
+  })
+  send({
+    enabled: true,
+    rows: [{
+      app: "OtherApp",
+      state: "paused",
+      notice_id: "paused:1:"
+    }],
+    settings: [
+      { app: "ComfyUI", mode: "automatic" },
+      { app: "OtherApp", mode: "manual" }
+    ],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+
+  const completed = tray.querySelector(
+    '.vault-auto-scan-row[data-state="complete"]')
+  assert.ok(completed)
+  assert.equal(completed.querySelector(
+    ".vault-auto-scan-app").textContent, "ComfyUI")
+  assert.equal(completed.querySelector(
+    ".vault-auto-scan-status").textContent,
+  "No possible duplicate files found")
+  assert.ok(completed.querySelector(".vault-auto-scan-icon svg"))
+  assert.equal(completed.querySelector(".vault-auto-scan-settings"), null)
+  assert.equal(completed.querySelector(".vault-auto-scan-action"), null)
+  assert.equal(completionTimers[0].delay, 4000)
+
+  tray.querySelector(
+    '.vault-auto-scan-row[data-state="paused"] .vault-auto-scan-action').click()
+  await waitFor(() => requests.some((request) =>
+    request.url === "/info/vault/automatic-scans"))
+  await new Promise((resolve) => nativeSetTimeout(resolve, 0))
+  assert.equal(completed.isConnected, true,
+    "refreshing durable tray state preserves an active completion")
+  assert.equal(completionTimers.length, 1,
+    "a durable state refresh does not restart the completion timer")
+
+  completed.dispatchEvent(new dom.window.MouseEvent("mouseenter"))
+  assert.equal(completionTimers[0].cleared, true)
+  completed.dispatchEvent(new dom.window.MouseEvent("mouseleave"))
+  assert.equal(completionTimers.length, 2)
+  assert.ok(completionTimers[1].delay <= 4000)
+
+  const closeButton = completed.querySelector(".vault-auto-scan-close")
+  closeButton.dispatchEvent(new dom.window.FocusEvent("focusin", {
+    bubbles: true
+  }))
+  assert.equal(completionTimers[1].cleared, true)
+  closeButton.dispatchEvent(new dom.window.FocusEvent("focusout", {
+    bubbles: true,
+    relatedTarget: null
+  }))
+  assert.equal(completionTimers.length, 3)
+  completionTimers[2].callback()
+  assert.equal(tray.hidden, true)
+
+  send({
+    enabled: true,
+    rows: [{
+      app: "ComfyUI",
+      state: "checking",
+      notice_id: "checking:2:"
+    }],
+    settings: [{ app: "ComfyUI", mode: "automatic" }]
+  })
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  assert.equal(tray.hidden, false)
+  eventSources[0].onerror()
+  await new Promise((resolve) => nativeSetTimeout(resolve, 0))
+  assert.equal(tray.hidden, true,
+    "a reconnect drops presentation-only completion state")
+
+  send({
+    enabled: true,
+    rows: [{
+      app: "ComfyUI",
+      state: "checking",
+      notice_id: "checking:3:"
+    }],
+    settings: [{ app: "ComfyUI", mode: "automatic" }]
+  })
+  tray.querySelector(".vault-auto-scan-close").click()
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  await waitFor(() => tray.hidden)
+  assert.equal(tray.querySelector(
+    '.vault-auto-scan-row[data-state="complete"]'), null,
+  "a closed checking row cannot be replaced by completion")
+  assert.ok(requests.some((request) => {
+    if (request.url !== "/vault/action" || !request.options.body) return false
+    const payload = JSON.parse(request.options.body)
+    return payload.action === "automatic_dismiss" &&
+      payload.notice_id === "checking:3:"
+  }))
+
+  dom.window.close()
+})
+
 test("the shared layout does not initialize automatic notices when Vault is disabled", async () => {
   const template = await fs.promises.readFile(
     path.join(root, "server", "views", "layout.ejs"), "utf8")
@@ -290,3 +518,80 @@ test("the app workspace focuses Scan this app without starting it after Review",
   assert.doesNotMatch(source,
     /automaticReviewRequested[\s\S]{0,200}(post\(|btn-scan\.click)/)
 })
+
+test("the app sidebar mirrors Automatic and Manual Disk Saver modes", async () => {
+  const template = await fs.promises.readFile(
+    path.join(root, "server", "views", "app.ejs"), "utf8")
+  const server = await fs.promises.readFile(
+    path.join(root, "server", "index.js"), "utf8")
+  const script = await fs.promises.readFile(
+    path.join(root, "server", "public", "app-vault-mode.js"), "utf8")
+  const dom = new JSDOM(`<a id="save-space-tab">
+    <span data-app-vault-mode data-app="ComfyUI" data-mode="automatic">
+      <span data-app-vault-mode-label>Auto</span>
+    </span>
+  </a>`, {
+    runScripts: "outside-only",
+    url: "http://localhost/v/ComfyUI"
+  })
+  const eventSources = []
+  dom.window.EventSource = class EventSource {
+    constructor(url) {
+      this.url = url
+      eventSources.push(this)
+    }
+    close() {}
+  }
+
+  dom.window.eval(script)
+  const status = dom.window.document.querySelector("[data-app-vault-mode]")
+  const label = status.querySelector("[data-app-vault-mode-label]")
+  assert.equal(eventSources.length, 1)
+  assert.equal(eventSources[0].url,
+    "/info/vault/automatic-scans/events")
+  assert.equal(status.dataset.mode, "automatic")
+  assert.equal(status.hidden, false)
+  assert.equal(label.textContent, "Auto")
+  assert.equal(dom.window.document.getElementById("save-space-tab")
+    .getAttribute("aria-label"), "Disk Saver — Automatic checking")
+
+  eventSources[0].onmessage({
+    data: JSON.stringify({
+      settings: [{ app: "ComfyUI", mode: "manual" }]
+    })
+  })
+  assert.equal(status.dataset.mode, "manual")
+  assert.equal(status.hidden, false)
+  assert.equal(label.textContent, "Manual")
+  assert.equal(dom.window.document.getElementById("save-space-tab")
+    .getAttribute("aria-label"), "Disk Saver — Manual checking")
+
+  eventSources[0].onmessage({ data: JSON.stringify({ settings: [] }) })
+  assert.equal(status.dataset.mode, "automatic")
+  assert.equal(status.hidden, false)
+  assert.equal(label.textContent, "Auto")
+  assert.match(template, /data-app-vault-mode/)
+  assert.match(template, /app-vault-mode\.js/)
+  assert.match(template,
+    /#save-space-tab\s*\{[^}]*width:\s*100%;[^}]*max-width:\s*none;/s)
+  assert.match(template,
+    /\.app-vault-mode\s*\{[^}]*margin-left:\s*auto;[^}]*font-size:\s*12px;[^}]*font-weight:\s*500;/s)
+  assert.match(template,
+    /\.app-vault-mode-chevron,\s*\.app-autolaunch-chevron\s*\{[^}]*width:\s*10px;[^}]*flex:\s*0 0 10px;/s)
+  assert.doesNotMatch(template,
+    /\.app-vault-mode\s*\{[^}]*(background|border-radius|padding):/s)
+  assert.match(template,
+    /vaultAutomaticMode === 'automatic' \? 'Auto' : 'Manual'/)
+  assert.match(template,
+    /fa-solid fa-angle-down app-vault-mode-chevron/)
+  assert.match(template,
+    /autolaunch_app\.autolaunch_enabled \? 'On' : 'Off'/)
+  assert.match(template,
+    /\.app-autolaunch-status\s*\{[^}]*font-size:\s*12px;[^}]*font-weight:\s*500;[^}]*letter-spacing:\s*0;/s)
+  assert.doesNotMatch(template, /data-app-vault-mode[^>]*hidden/)
+  assert.doesNotMatch(template, /app-vault-mode-dot/)
+  assert.match(server,
+    /result\.vault_automatic_mode = setting && setting\.mode === "manual"/)
+
+  dom.window.close()
+})

package/test/vault-automatic-scans.test.js

@@ -409,12 +409,29 @@ describe("automatic app checks", () => {
       await handle.close()
     }
     const vault = await makeVault(home)
+    const broadcasts = []
+    const unsubscribe = vault.automaticScans.subscribe((snapshot) => {
+      broadcasts.push(snapshot)
+    })
 
     vault.automaticScans.queueApp("threshold-app")
     await waitFor(() => !vault.automaticScans.active &&
       !vault.automaticScans.entries.has("threshold-app"))
 
     assert.deepEqual(vault.automaticScans.snapshot().rows, [])
+    assert.deepEqual(broadcasts.find((snapshot) => snapshot.completion)
+      ?.completion, {
+      app: "threshold-app",
+      outcome: "no_possible_duplicates"
+    })
+    assert.equal("completion" in vault.automaticScans.snapshot(), false)
+    let restoredSnapshot = null
+    const unsubscribeRestored = vault.automaticScans.subscribe((snapshot) => {
+      restoredSnapshot = snapshot
+    })
+    assert.equal("completion" in restoredSnapshot, false)
+    unsubscribeRestored()
+    unsubscribe()
     assert.equal(await vault.registry.scanFor("app:threshold-app"), null)
     await close(vault)
   })

package/test/vault-ui.test.js

@@ -2184,6 +2184,26 @@ describe("Save Space interface", () => {
     dom.window.close()
   })
 
+  test("a fresh app workspace makes Scan this app primary", async () => {
+    const status = fixture([], {
+      last_scan: null,
+      bytes_without_sharing: 0,
+      bytes_on_disk: 0,
+      saved_by_sharing: 0,
+      effective_bytes: 0
+    })
+    const { dom } = await makePage(status, {
+      appMode: true,
+      scopeId: "app:app"
+    })
+    const scanButton = dom.window.document.getElementById("btn-scan")
+
+    assert.match(scanButton.textContent, /Scan this app/)
+    assert.equal(scanButton.classList.contains("primary"), true)
+
+    dom.window.close()
+  })
+
   test("app mode uses full-width results without redundant locations", async () => {
     const status = fixture([item()])
     const { dom, requests } = await makePage(status, {