pinokiod 8.0.54 → 8.0.55

package/kernel/vault/automatic_scans.js

@@ -1,9 +1,20 @@
 const fs = require("fs")
+const os = require("os")
 const path = require("path")
-const { SIZE_THRESHOLD } = require("./constants")
+const {
+  DIR_CONCURRENCY,
+  ENTRY_BATCH_SIZE,
+  HASH_INACTIVITY_MS,
+  HASH_PROGRESS_INTERVAL_MS,
+  HASH_READ_SIZE,
+  SIZE_THRESHOLD,
+  STAT_CONCURRENCY
+} = require("./constants")
 
 const COMPLETE_PHASES = new Set(["complete", "completed_with_exclusions"])
 const STOP_SETTLE_MS = 3000
+const SCAN_PROGRESS_INTERVAL_MS = 5000
+const SCAN_STALL_THRESHOLD_MS = 30000
 const isMissing = (error) => !!(error &&
   (error.code === "ENOENT" || error.code === "ENOTDIR"))
 
@@ -34,6 +45,10 @@ class AutomaticScans {
     this.waitingFor = null
     this.listeners = new Set()
     this.appTransitions = new Map()
+    this.scanDiagnostics = null
+    this.scanProgressIntervalMs = SCAN_PROGRESS_INTERVAL_MS
+    this.scanStallThresholdMs = SCAN_STALL_THRESHOLD_MS
+    this.clock = () => Date.now()
   }
 
   log(event, details = {}) {
@@ -49,6 +64,345 @@ class AutomaticScans {
     console.log(`[Vault Automatic Scan] ${JSON.stringify(record)}`)
   }
 
+  diagnosticMarker(scan) {
+    return JSON.stringify([
+      scan.phase,
+      scan.stage,
+      scan.current_directory,
+      scan.anchor_files,
+      scan.anchor_bytes,
+      scan.walk_batches,
+      scan.dirs,
+      scan.files,
+      scan.bytes_total,
+      scan.comparison_batches,
+      scan.comparison_files_verified,
+      scan.candidates,
+      scan.hash_work_files,
+      scan.hash_work_bytes,
+      scan.hash_files_completed,
+      scan.hash_bytes_completed,
+      scan.hash_total,
+      scan.hashed,
+      scan.hash_bytes,
+      scan.current_file,
+      scan.current_file_role,
+      scan.current_file_bytes,
+      scan.current_file_size,
+      scan.inode_reuses,
+      scan.unstable_hashes,
+      scan.hash_failures,
+      Array.isArray(scan.exclusions) ? scan.exclusions.length : 0
+    ])
+  }
+
+  diagnosticCounters(scan) {
+    const currentFileBytes = Math.max(
+      0, Number(scan.current_file_bytes) || 0)
+    return {
+      files: Math.max(0, Number(scan.files) || 0),
+      discoveryBytes: Math.max(0, Number(scan.bytes_total) || 0),
+      hashBytes: Math.max(0,
+        Number(scan.hash_bytes_completed) || 0) + currentFileBytes
+    }
+  }
+
+  diagnosticDetails(monitor, scan, now) {
+    const started = Number(scan.started) || monitor.startedAt
+    const stageStarted = Number(scan.stage_started) || started
+    const lastProgress = Number(scan.last_progress_at) || stageStarted
+    const preview = scan.preview || {}
+    const currentFileSize = Math.max(
+      0, Number(scan.current_file_size) || 0)
+    const currentFileBytes = Math.min(currentFileSize || Infinity, Math.max(
+      0, Number(scan.current_file_bytes) || 0))
+    const hashWorkBytes = Math.max(
+      0, Number(scan.hash_work_bytes) || 0)
+    const hashProgressBytes = Math.min(hashWorkBytes || Infinity, Math.max(
+      0, Number(scan.hash_bytes_completed) || 0) + currentFileBytes)
+    const details = {
+      app: monitor.app,
+      scope_id: monitor.scopeId,
+      phase: scan.phase || "unknown",
+      stage: scan.stage || scan.phase || "unknown",
+      previous_stage: scan.previous_stage,
+      previous_stage_duration_ms: scan.previous_stage_duration_ms,
+      active: !!scan.active,
+      pending: !!scan.pending,
+      elapsed_ms: Math.max(0, now - started),
+      stage_elapsed_ms: Math.max(0, now - stageStarted),
+      progress_age_ms: Math.max(0, now - lastProgress),
+      progress_unchanged_ms: Math.max(0, now - monitor.lastChangedAt),
+      current_directory: scan.current_directory,
+      anchor_files: Math.max(0, Number(scan.anchor_files) || 0),
+      anchor_bytes: Math.max(0, Number(scan.anchor_bytes) || 0),
+      walk_batches: Math.max(0, Number(scan.walk_batches) || 0),
+      dirs: Math.max(0, Number(scan.dirs) || 0),
+      files: Math.max(0, Number(scan.files) || 0),
+      bytes_total: Math.max(0, Number(scan.bytes_total) || 0),
+      source_files: scan.source_files || {},
+      source_bytes: scan.source_bytes || {},
+      comparison_batches:
+        Math.max(0, Number(scan.comparison_batches) || 0),
+      comparison_files_verified:
+        Math.max(0, Number(scan.comparison_files_verified) || 0),
+      candidates: Math.max(0, Number(scan.candidates) || 0),
+      hash_work_files:
+        Math.max(0, Number(scan.hash_work_files) || 0),
+      hash_work_bytes: hashWorkBytes,
+      hash_files_completed:
+        Math.max(0, Number(scan.hash_files_completed) || 0),
+      hash_bytes_completed:
+        Math.max(0, Number(scan.hash_bytes_completed) || 0),
+      hash_progress_bytes: hashProgressBytes,
+      hash_progress_percent: hashWorkBytes
+        ? Math.floor((hashProgressBytes / hashWorkBytes) * 100)
+        : 0,
+      hash_total: Math.max(0, Number(scan.hash_total) || 0),
+      hashed: Math.max(0, Number(scan.hashed) || 0),
+      hash_bytes: Math.max(0, Number(scan.hash_bytes) || 0),
+      current_file: scan.current_file,
+      current_file_role: scan.current_file_role,
+      current_file_source_id: scan.current_file_source_id,
+      current_file_bytes: Number.isFinite(currentFileBytes)
+        ? currentFileBytes
+        : 0,
+      current_file_size: currentFileSize,
+      inode_reuses: Math.max(0, Number(scan.inode_reuses) || 0),
+      unstable_hashes: Math.max(0, Number(scan.unstable_hashes) || 0),
+      hash_failures: Math.max(0, Number(scan.hash_failures) || 0),
+      source_hash_failures: scan.source_hash_failures || {},
+      exclusions_count: Array.isArray(scan.exclusions)
+        ? scan.exclusions.length
+        : 0,
+      preview_duplicate_files:
+        Math.max(0, Number(preview.duplicate_files) || 0),
+      preview_savings_bytes: Math.max(0, Number(preview.bytes) || 0),
+      source_refresh_duration_ms: scan.source_refresh_duration_ms,
+      anchor_walk_duration_ms: scan.anchor_walk_duration_ms,
+      walk_duration_ms: scan.walk_duration_ms,
+      comparison_duration_ms: scan.comparison_duration_ms,
+      hash_wait_duration_ms: scan.hash_wait_duration_ms,
+      hash_duration_ms: scan.hash_duration_ms,
+      anchor_verify_duration_ms: scan.anchor_verify_duration_ms,
+      publish_duration_ms: scan.publish_duration_ms,
+      error: scan.error
+    }
+    const counters = this.diagnosticCounters(scan)
+    if (monitor.lastCounters && monitor.lastSampleAt < now) {
+      const sampleMs = now - monitor.lastSampleAt
+      details.sample_ms = sampleMs
+      details.files_per_second = Number((Math.max(
+        0, counters.files - monitor.lastCounters.files
+      ) * 1000 / sampleMs).toFixed(2))
+      details.discovery_bytes_per_second = Math.round(Math.max(
+        0, counters.discoveryBytes - monitor.lastCounters.discoveryBytes
+      ) * 1000 / sampleMs)
+      details.hash_bytes_per_second = Math.round(Math.max(
+        0, counters.hashBytes - monitor.lastCounters.hashBytes
+      ) * 1000 / sampleMs)
+    }
+    monitor.lastCounters = counters
+    monitor.lastSampleAt = now
+    try {
+      const cpu = process.cpuUsage()
+      if (monitor.cpuUsage && Number(details.sample_ms) > 0) {
+        const user = Math.max(0, cpu.user - monitor.cpuUsage.user)
+        const system = Math.max(0, cpu.system - monitor.cpuUsage.system)
+        details.process_cpu_user_delta_ms =
+          Number((user / 1000).toFixed(2))
+        details.process_cpu_system_delta_ms =
+          Number((system / 1000).toFixed(2))
+        const sampleMs = Math.max(1, Number(details.sample_ms) ||
+          now - monitor.startedAt)
+        details.process_cpu_percent =
+          Number((((user + system) / 1000) * 100 / sampleMs).toFixed(2))
+      }
+      monitor.cpuUsage = cpu
+      const memory = process.memoryUsage()
+      details.process_rss_bytes = memory.rss
+      details.process_heap_used_bytes = memory.heapUsed
+    } catch (_) {}
+    return details
+  }
+
+  sampleScanDiagnostics(options = {}) {
+    const monitor = this.scanDiagnostics
+    if (!monitor) return null
+    let scan
+    try {
+      scan = typeof this.vault.scanStatus === "function"
+        ? this.vault.scanStatus()
+        : null
+    } catch (error) {
+      this.log("scan-progress-error", {
+        app: monitor.app,
+        scope_id: monitor.scopeId,
+        message: error && error.message ? error.message : String(error)
+      })
+      return null
+    }
+    if (!scan) return null
+    const now = this.clock()
+    const marker = this.diagnosticMarker(scan)
+    const changed = marker !== monitor.lastMarker
+    const previousUnchanged = now - monitor.lastChangedAt
+    if (changed) {
+      if (monitor.stalled) {
+        this.log("scan-progress-resumed", {
+          app: monitor.app,
+          scope_id: monitor.scopeId,
+          phase: scan.phase,
+          stage: scan.stage,
+          stalled_ms: Math.max(0, previousUnchanged)
+        })
+      }
+      monitor.lastMarker = marker
+      monitor.lastChangedAt = now
+      monitor.stalled = false
+    }
+    const stage = scan.stage || scan.phase || "unknown"
+    if (monitor.lastStage && stage !== monitor.lastStage) {
+      this.log("scan-stage-changed", {
+        app: monitor.app,
+        scope_id: monitor.scopeId,
+        from: monitor.lastStage,
+        to: stage,
+        previous_stage_observed_ms: Math.max(
+          0, now - monitor.lastStageObservedAt)
+      })
+      monitor.lastStageObservedAt = now
+    }
+    monitor.lastStage = stage
+    const details = this.diagnosticDetails(monitor, scan, now)
+    if (!options.final) this.log("scan-progress", details)
+    if (!monitor.stalled && details.progress_unchanged_ms >=
+        this.scanStallThresholdMs && (scan.active || scan.pending)) {
+      monitor.stalled = true
+      this.log("scan-progress-stalled", details)
+    }
+    return details
+  }
+
+  startScanDiagnostics(app, scopeId) {
+    this.stopScanDiagnostics()
+    const now = this.clock()
+    let cpuUsage = null
+    try { cpuUsage = process.cpuUsage() } catch (_) {}
+    this.scanDiagnostics = {
+      app,
+      scopeId,
+      startedAt: now,
+      lastChangedAt: now,
+      lastMarker: null,
+      lastStage: null,
+      lastStageObservedAt: now,
+      lastCounters: null,
+      lastSampleAt: now,
+      cpuUsage,
+      stalled: false,
+      timer: null
+    }
+    const version = this.vault.kernel && this.vault.kernel.version
+    let cpuCount = null
+    let cpuModel = null
+    let totalMemory = null
+    let osRelease = null
+    try {
+      const cpus = os.cpus()
+      cpuCount = cpus.length
+      cpuModel = cpus[0] && cpus[0].model
+      totalMemory = os.totalmem()
+      osRelease = os.release()
+    } catch (_) {}
+    this.log("scan-diagnostics-started", {
+      app,
+      scope_id: scopeId,
+      progress_interval_ms: this.scanProgressIntervalMs,
+      stall_threshold_ms: this.scanStallThresholdMs,
+      platform: this.vault.kernel && this.vault.kernel.platform ||
+        process.platform,
+      arch: process.arch,
+      os_release: osRelease,
+      cpu_count: cpuCount,
+      cpu_model: cpuModel,
+      total_memory_bytes: totalMemory,
+      node_version: process.versions && process.versions.node,
+      electron_version: process.versions && process.versions.electron,
+      pinokiod_version: version && version.pinokiod,
+      process_pid: process.pid,
+      threshold_bytes: this.sizeThreshold,
+      entry_batch_size: ENTRY_BATCH_SIZE,
+      directory_concurrency: this.vault.scanner
+        ? this.vault.scanner.dirConcurrency
+        : DIR_CONCURRENCY,
+      stat_concurrency: this.vault.scanner
+        ? this.vault.scanner.statConcurrency
+        : STAT_CONCURRENCY,
+      hash_read_size: HASH_READ_SIZE,
+      hash_progress_interval_ms: HASH_PROGRESS_INTERVAL_MS,
+      hash_inactivity_timeout_ms:
+        Number(this.vault.hashInactivityMs) || HASH_INACTIVITY_MS
+    })
+    this.logFilesystemDiagnostics(app, scopeId)
+    this.sampleScanDiagnostics()
+    const timer = setInterval(() => {
+      this.sampleScanDiagnostics()
+    }, this.scanProgressIntervalMs)
+    if (typeof timer.unref === "function") timer.unref()
+    this.scanDiagnostics.timer = timer
+  }
+
+  finishScanDiagnostics(app) {
+    const monitor = this.scanDiagnostics
+    if (!monitor || monitor.app !== app) return {}
+    if (monitor.timer) clearInterval(monitor.timer)
+    const details = this.sampleScanDiagnostics({ final: true }) || {}
+    this.scanDiagnostics = null
+    return details
+  }
+
+  stopScanDiagnostics() {
+    const monitor = this.scanDiagnostics
+    if (monitor && monitor.timer) clearInterval(monitor.timer)
+    this.scanDiagnostics = null
+  }
+
+  logFilesystemDiagnostics(app, scopeId) {
+    if (typeof fs.promises.statfs !== "function") return
+    let source
+    try {
+      source = this.sourceForApp(app)
+    } catch (_) {
+      return
+    }
+    if (!source || !source.root) return
+    fs.promises.statfs(source.root).then((stat) => {
+      const blockSize = Math.max(0, Number(stat.bsize) || 0)
+      const bytes = (blocks) => Math.max(
+        0, Number(blocks) || 0) * blockSize
+      this.log("scan-filesystem", {
+        app,
+        scope_id: scopeId,
+        source_device: source.dev,
+        filesystem_type: stat.type,
+        block_size: blockSize,
+        total_bytes: bytes(stat.blocks),
+        free_bytes: bytes(stat.bfree),
+        available_bytes: bytes(stat.bavail),
+        total_file_nodes: stat.files,
+        free_file_nodes: stat.ffree
+      })
+    }).catch((error) => {
+      this.log("scan-filesystem-error", {
+        app,
+        scope_id: scopeId,
+        code: error && error.code,
+        error_name: error && error.name
+      })
+    })
+  }
+
   appForLaunchPath(launchPath) {
     if (typeof launchPath !== "string" || !launchPath) return null
     const apiRoot = path.resolve(this.vault.kernel.homedir, "api")
@@ -515,6 +869,7 @@ class AutomaticScans {
       this.waitForBusyWork()
     } else {
       this.log("scan-started", { app: entry.app, scope_id: scopeId })
+      this.startScanDiagnostics(entry.app, scopeId)
     }
   }
 
@@ -743,13 +1098,14 @@ class AutomaticScans {
           if (this.active && this.active.app === app) this.active = null
           const reason = this.cancelReasons.get(app)
           this.cancelReasons.delete(app)
-          this.log("scan-finished", {
+          const diagnostics = this.finishScanDiagnostics(app)
+          this.log("scan-finished", Object.assign({}, diagnostics, {
             app,
             scope_id: scopeId,
             outcome: result && result.outcome,
             cancel_reason: reason,
             error: error && error.message ? error.message : error
-          })
+          }))
           try {
             const entry = this.entries.get(app)
             if (reason === "paused" || reason === "manual-mode" ||

package/kernel/vault/constants.js

@@ -1,5 +1,7 @@
 const CANDIDATE_SIZE_BASE = process.platform === "win32" ? 1024 : 1000
 const SIZE_THRESHOLD = 100 * CANDIDATE_SIZE_BASE ** 2
+const HASH_READ_SIZE = 1024 * 1024
+const HASH_PROGRESS_INTERVAL_MS = 1000
 const CANDIDATE_SIZE_OPTIONS = [0]
   .concat([1, 10, 50, 100, 500].map((value) => value * CANDIDATE_SIZE_BASE ** 2))
   .concat(CANDIDATE_SIZE_BASE ** 3)
@@ -14,5 +16,7 @@ module.exports = {
   ENTRY_BATCH_SIZE: 256,
   DIR_CONCURRENCY: 8,
   STAT_CONCURRENCY: 32,
-  HASH_INACTIVITY_MS: 120 * 1000
+  HASH_INACTIVITY_MS: 120 * 1000,
+  HASH_READ_SIZE,
+  HASH_PROGRESS_INTERVAL_MS
 }

package/kernel/vault/hash_worker.js

@@ -1,13 +1,14 @@
 const { parentPort } = require('worker_threads')
 const crypto = require('crypto')
 const fs = require('fs')
+const {
+  HASH_READ_SIZE,
+  HASH_PROGRESS_INTERVAL_MS
+} = require('./constants')
 
 // Large model files otherwise generate a very high number of 64 KiB stream
 // events. This changes only the read granularity; every byte still feeds the
 // same sha256 digest, one file at a time.
-const HASH_READ_SIZE = 1024 * 1024
-const HASH_PROGRESS_INTERVAL_MS = 1000
-
 parentPort.on('message', ({ id, filePath }) => {
   const hash = crypto.createHash('sha256')
   let size = 0

package/kernel/vault/index.js

@@ -3372,6 +3372,7 @@ class Vault {
     const state = pending
       ? Object.assign(this.sweeper.idleState(), {
         phase: "queued",
+        stage: "queued",
         scope_id: this.scanScopeId
       })
       : this.sweeper.state
@@ -3385,6 +3386,12 @@ class Vault {
       current_file_size: this.sweeper.currentHash
         ? this.sweeper.currentHash.size
         : null,
+      current_file_source_id: this.sweeper.currentHash
+        ? this.sweeper.currentHash.source_id
+        : null,
+      current_file_role: this.sweeper.currentHash
+        ? this.sweeper.currentHash.role
+        : null,
       pending,
       error: this.scanError
     })

package/kernel/vault/sweeper.js

@@ -22,9 +22,20 @@ class Sweeper {
     return {
       active: false,
       phase: "idle",
+      stage: "idle",
+      stage_started: null,
+      previous_stage: null,
+      previous_stage_duration_ms: null,
+      last_progress_at: null,
+      current_directory: null,
+      anchor_files: 0,
+      anchor_bytes: 0,
       dirs: 0,
       files: 0,
       bytes_total: 0,
+      walk_batches: 0,
+      comparison_batches: 0,
+      comparison_files_verified: 0,
       source_bytes: {},
       source_files: {},
       source_hash_failures: {},
@@ -50,12 +61,34 @@ class Sweeper {
       },
       started: null,
       duration_ms: null,
+      source_refresh_duration_ms: null,
+      anchor_walk_duration_ms: null,
       walk_duration_ms: null,
+      comparison_duration_ms: null,
       hash_wait_duration_ms: null,
-      hash_duration_ms: 0
+      hash_duration_ms: 0,
+      anchor_verify_duration_ms: null,
+      publish_duration_ms: null
     }
   }
 
+  setStage(stage) {
+    const now = Date.now()
+    if (this.state.stage && this.state.stage !== stage &&
+        Number.isFinite(this.state.stage_started)) {
+      this.state.previous_stage = this.state.stage
+      this.state.previous_stage_duration_ms = Math.max(
+        0, now - this.state.stage_started)
+    }
+    this.state.stage = stage
+    this.state.stage_started = now
+    this.state.last_progress_at = now
+  }
+
+  markProgress() {
+    this.state.last_progress_at = Date.now()
+  }
+
   cancel() {
     if (!this.state.active) return false
     this.cancelRequested = true
@@ -89,6 +122,7 @@ class Sweeper {
       started: Date.now(),
       scope_id: scopeId
     })
+    this.setStage("starting")
 
     const registry = this.vault.registry
     const runId = await registry.beginScan(scopeId)
@@ -96,7 +130,12 @@ class Sweeper {
     let fatalError = null
     let affectedApps = []
     try {
+      this.setStage("refreshing_sources")
+      const sourceRefreshStarted = Date.now()
       await this.vault.refreshSources()
+      this.state.source_refresh_duration_ms =
+        Date.now() - sourceRefreshStarted
+      this.markProgress()
       if (!scopeId) {
         const unavailable = this.vault.sources().find((source) =>
           source.kind === "external" &&
@@ -113,9 +152,13 @@ class Sweeper {
       }
 
       const anchorStores = this.anchorStoresForScope(scopeId)
+      this.setStage("scanning_anchors")
+      const anchorWalkStarted = Date.now()
       await this.stageAnchors(runId, anchorStores)
+      this.state.anchor_walk_duration_ms = Date.now() - anchorWalkStarted
       this.checkpoint()
 
+      this.setStage("discovering_files")
       const walkStarted = Date.now()
       for (const source of scanRoots) {
         if (!Object.prototype.hasOwnProperty.call(
@@ -127,20 +170,34 @@ class Sweeper {
         await this.walk(source.root, runId, source.source_id)
         this.checkpoint()
       }
+      this.state.current_directory = null
       this.state.walk_duration_ms = Date.now() - walkStarted
+      this.setStage("staging_discovery_results")
       await registry.stageExclusions(runId, this.exclusionList())
       if (scopeId) {
+        const comparisonStarted = Date.now()
+        this.setStage("staging_comparisons")
         const comparisons = await registry.stageComparisonFiles(
           runId, this.publicationSourceIds(scopeId))
         this.applyHashWork(comparisons && comparisons.work)
+        this.setStage("verifying_comparisons")
         await this.verifyComparisonFiles(runId)
+        this.state.comparison_duration_ms =
+          Date.now() - comparisonStarted
       }
 
       this.state.phase = "hashing"
+      this.setStage("hashing_candidates")
       const hashStarted = Date.now()
       await this.hashCandidates(runId)
+      this.setStage("staging_hash_results")
       await registry.stageExclusions(runId, this.exclusionList())
+      this.setStage("verifying_anchors")
+      const anchorVerifyStarted = Date.now()
       await this.verifyCandidateAnchors(runId)
+      this.state.anchor_verify_duration_ms =
+        Date.now() - anchorVerifyStarted
+      this.setStage("staging_verification_results")
       await registry.stageExclusions(runId, this.exclusionList())
       this.state.hash_wait_duration_ms = Date.now() - hashStarted
       this.checkpoint()
@@ -149,6 +206,7 @@ class Sweeper {
         ? "completed_with_exclusions"
         : "complete"
       this.state.phase = "publishing"
+      this.setStage("publishing")
       this.state.duration_ms = Date.now() - this.state.started
       const metadata = this.scanMetadata(scopeId, outcome)
       const stores = anchorStores
@@ -160,12 +218,15 @@ class Sweeper {
           can_link: store.mode !== "copy",
           root: store.root
         }))
+      const publishStarted = Date.now()
       const publication = await registry.publishScan(
         runId,
         this.publicationSourceIds(scopeId),
         metadata,
         stores
       )
+      this.state.publish_duration_ms = Date.now() - publishStarted
+      this.markProgress()
       affectedApps = publication && Array.isArray(publication.affected_apps)
         ? publication.affected_apps
         : []
@@ -178,9 +239,11 @@ class Sweeper {
       }
     } finally {
       this.currentHash = null
+      this.state.current_directory = null
       this.state.active = false
       this.state.phase = outcome
       this.state.duration_ms = Date.now() - this.state.started
+      this.setStage(outcome)
       this.clearPreview()
     }
 
@@ -223,9 +286,15 @@ class Sweeper {
       hash_failures: this.state.hash_failures,
       candidate_min_bytes: this.vault.sizeThreshold,
       duration_ms: Date.now() - this.state.started,
+      source_refresh_duration_ms:
+        this.state.source_refresh_duration_ms || 0,
+      anchor_walk_duration_ms: this.state.anchor_walk_duration_ms || 0,
       walk_duration_ms: this.state.walk_duration_ms || 0,
+      comparison_duration_ms: this.state.comparison_duration_ms || 0,
       hash_wait_duration_ms: this.state.hash_wait_duration_ms || 0,
-      hash_duration_ms: this.state.hash_duration_ms || 0
+      hash_duration_ms: this.state.hash_duration_ms || 0,
+      anchor_verify_duration_ms:
+        this.state.anchor_verify_duration_ms || 0
     }
   }
 
@@ -334,9 +403,14 @@ class Sweeper {
       onError: (error, filePath, reason = null) =>
         this.recordExclusion(error, filePath, null, reason),
       onEntries: async (anchors) => {
+        this.state.anchor_files += anchors.length
+        this.state.anchor_bytes += anchors.reduce((total, anchor) =>
+          total + (Math.max(0, Number(anchor.size) || 0)), 0)
+        this.markProgress()
         const staged = await this.vault.registry.stageAnchors(
           runId, anchors)
         this.applyHashWork(staged && staged.work)
+        this.markProgress()
       }
     })
   }
@@ -352,6 +426,9 @@ class Sweeper {
       }
       const observations = await this.vault.scanner.validateSnapshots(entries)
       await this.vault.registry.resolveComparisonFiles(runId, observations)
+      this.state.comparison_batches += 1
+      this.state.comparison_files_verified += entries.length
+      this.markProgress()
     }
   }
 
@@ -361,7 +438,12 @@ class Sweeper {
       skipDirectory: (full) => this.vault.isStorageRoot(full),
       onError: (error, filePath) =>
         this.recordExclusion(error, filePath, preferredSourceId),
-      onBatch: async ({ files, directories }) => {
+      onBatch: async ({ files, directories, currentDirectory }) => {
+        this.state.current_directory = currentDirectory
+          ? path.relative(root, currentDirectory) || "."
+          : this.state.current_directory
+        this.markProgress()
+        this.state.walk_batches += 1
         this.state.dirs += directories
         const entries = files.map((file) =>
           this.considerStat(file.path, file.stat, preferredSourceId))
@@ -371,6 +453,7 @@ class Sweeper {
         this.state.candidates += Number(staged && staged.changes) || 0
         this.applyPreview(staged && staged.preview)
         this.applyHashWork(staged && staged.work)
+        this.markProgress()
       }
     })
   }
@@ -421,6 +504,7 @@ class Sweeper {
             runId, candidate.dev, candidate.ino, candidate.reusable_hash)
           this.state.inode_reuses += updated.changes
           this.applyPreview(updated.preview)
+          this.markProgress()
           continue
         }
         await this.hashCandidateRoutes(runId, candidate)
@@ -439,14 +523,18 @@ class Sweeper {
       this.currentHash = {
         path: candidate.path,
         size: candidate.size,
-        bytes: 0
+        bytes: 0,
+        source_id: candidate.source_id || null,
+        role: candidate.comparison_only ? "comparison" : "candidate"
       }
+      this.markProgress()
       try {
         const verified = await this.vault.scanner.hashStable(candidate, {
           onProgress: (bytes) => {
             if (this.currentHash &&
                 this.currentHash.path === candidate.path) {
               this.currentHash.bytes = bytes
+              this.markProgress()
             }
           }
         })
@@ -476,6 +564,7 @@ class Sweeper {
         this.state.hash_bytes += verified.result.size
         this.state.inode_reuses += Math.max(0, updated.changes - 1)
         this.applyPreview(updated.preview)
+        this.markProgress()
         candidate = null
         deferCompletion = false
       } catch (error) {
@@ -513,14 +602,18 @@ class Sweeper {
         this.currentHash = {
           path: anchor.path,
           size: anchor.size,
-          bytes: 0
+          bytes: 0,
+          source_id: null,
+          role: "anchor"
         }
+        this.markProgress()
         try {
           const verified = await this.vault.scanner.hashStable(anchor, {
             onProgress: (bytes) => {
               if (this.currentHash &&
                   this.currentHash.path === anchor.path) {
                 this.currentHash.bytes = bytes
+                this.markProgress()
               }
             }
           })
@@ -528,6 +621,7 @@ class Sweeper {
             await this.vault.registry.markAnchorChecked(
               runId, anchor, verified.result.hash)
             completeWork = true
+            this.markProgress()
           } else {
             const retry =
               await this.vault.registry.markAnchorVerificationFailed(

package/package.json

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

package/server/views/app.ejs

@@ -12131,11 +12131,6 @@ const rerenderMenuSection = (container, html) => {
       let shell = target.closest("[data-shell]")
       if (shell) {
         let shell_id = shell.getAttribute("data-shell")
-        n.Noty({
-          text: `stopping shell`,
-          silent: true,
-          timeout: 2000
-        })
         let socket = new Socket()
         socket.run({
           method: "kernel.bin.shell_kill",
@@ -12146,11 +12141,6 @@ const rerenderMenuSection = (container, html) => {
           console.log("packet", packet)
           if (packet.type === "result") {
             socket.close()
-            n.Noty({
-              timeout: 2000,
-              text: `stopped`,
-              silent: true
-            })
             console.log("Refresh 4")
             refresh(true)
           }
@@ -12163,11 +12153,6 @@ const rerenderMenuSection = (container, html) => {
             target.querySelector("i").className = "fa-solid fa-check"
           } catch (e) {
           }
-          n.Noty({
-            text: `stopping script`,
-            silent: true,
-            timeout: 2000
-          })
 
           let socket = new Socket()
           socket.run({
@@ -12179,11 +12164,6 @@ const rerenderMenuSection = (container, html) => {
             if (packet.type === "result") {
               console.log("is result")
               socket.close()
-              n.Noty({
-                timeout: 2000,
-                text: `stopped`,
-                silent: true
-              })
               console.log("Refresh 4")
               refresh(true)
             }
@@ -12196,11 +12176,6 @@ const rerenderMenuSection = (container, html) => {
               target.querySelector("i").className = "fa-solid fa-check"
             } catch (e) {
             }
-            n.Noty({
-              text: `stopping ${src}`,
-              silent: true,
-              timeout: 2000
-            })
             console.log("src", src)
 
             let socket = new Socket()
@@ -12212,11 +12187,6 @@ const rerenderMenuSection = (container, html) => {
             }, (packet) => {
               if (packet.type === "result") {
                 socket.close()
-                n.Noty({
-                  timeout: 2000,
-                  text: `stopped`,
-                  silent: true
-                })
                 console.log("Refresh 4")
                 refresh(true)
               }

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

@@ -1698,6 +1698,106 @@ describe("automatic app scans", () => {
     await close(vault)
   })
 
+  test("diagnostics report progress, stalls, resumed work, and final state", () => {
+    let now = 1000
+    let scan = {
+      active: true,
+      pending: false,
+      phase: "discovering",
+      stage: "discovering_files",
+      stage_started: now,
+      last_progress_at: now,
+      started: now,
+      scope_id: "app:demo",
+      dirs: 1,
+      files: 2,
+      bytes_total: 2048,
+      source_files: { "app:demo": 2 },
+      source_bytes: { "app:demo": 2048 },
+      exclusions: [],
+      preview: { duplicate_files: 0, bytes: 0 }
+    }
+    const automatic = new AutomaticScans({
+      kernel: { homedir: "/pinokio", platform: "win32" },
+      scanner: { dirConcurrency: 8, statConcurrency: 32 },
+      hashInactivityMs: 120000,
+      scanStatus: () => scan
+    })
+    automatic.clock = () => now
+    automatic.scanProgressIntervalMs = 60000
+    automatic.scanStallThresholdMs = 100
+    const events = []
+    automatic.log = (event, details) => events.push({ event, details })
+
+    automatic.startScanDiagnostics("demo", "app:demo")
+    now += 50
+    scan = Object.assign({}, scan, {
+      dirs: 4,
+      files: 10,
+      bytes_total: 10240,
+      last_progress_at: now
+    })
+    automatic.sampleScanDiagnostics()
+    now += 100
+    automatic.sampleScanDiagnostics()
+
+    const stalled = events.find((entry) =>
+      entry.event === "scan-progress-stalled")
+    assert.ok(stalled)
+    assert.equal(stalled.details.stage, "discovering_files")
+    assert.equal(stalled.details.files, 10)
+    assert.equal(stalled.details.progress_unchanged_ms, 100)
+
+    now += 10
+    scan = Object.assign({}, scan, {
+      phase: "hashing",
+      stage: "hashing_candidates",
+      stage_started: now,
+      last_progress_at: now,
+      hash_work_files: 2,
+      hash_work_bytes: 8192,
+      current_file: "model.bin",
+      current_file_role: "candidate",
+      current_file_source_id: "app:demo",
+      current_file_bytes: 1024,
+      current_file_size: 4096
+    })
+    automatic.sampleScanDiagnostics()
+
+    assert.ok(events.some((entry) =>
+      entry.event === "scan-progress-resumed"))
+    assert.ok(events.some((entry) =>
+      entry.event === "scan-stage-changed" &&
+      entry.details.from === "discovering_files" &&
+      entry.details.to === "hashing_candidates"))
+    const hashing = events.filter((entry) =>
+      entry.event === "scan-progress").at(-1).details
+    assert.equal(hashing.hash_progress_bytes, 1024)
+    assert.equal(hashing.hash_progress_percent, 12)
+    assert.equal(hashing.current_file, "model.bin")
+    assert.ok(hashing.hash_bytes_per_second > 0)
+
+    now += 20
+    scan = Object.assign({}, scan, {
+      active: false,
+      phase: "cancelled",
+      stage: "cancelled",
+      previous_stage: "hashing_candidates",
+      previous_stage_duration_ms: 20,
+      current_file: null,
+      current_file_role: null,
+      current_file_source_id: null,
+      current_file_bytes: null,
+      current_file_size: null
+    })
+    const final = automatic.finishScanDiagnostics("demo")
+
+    assert.equal(final.phase, "cancelled")
+    assert.equal(final.previous_stage, "hashing_candidates")
+    assert.equal(final.previous_stage_duration_ms, 20)
+    assert.equal(automatic.scanDiagnostics, null)
+  })
+
   test("existing lifecycle results are unchanged while Vault observes them", () => {
     const calls = []
     const fakeKernel = {

package/test/vault-sweep.test.js

@@ -513,12 +513,15 @@ describe("Save Space scans", () => {
 
     try {
       assert.equal(progress.phase, "hashing")
+      assert.equal(progress.stage, "hashing_candidates")
       assert.equal(progress.hash_work_files, 2)
       assert.equal(progress.hash_work_bytes, contents.length * 2)
       assert.equal(progress.hash_files_completed, 0)
       assert.equal(progress.hash_bytes_completed, 0)
       assert.equal(progress.current_file_bytes, 1024)
       assert.equal(progress.current_file_size, contents.length)
+      assert.equal(progress.current_file_role, "candidate")
+      assert.match(progress.current_file_source_id, /^app:/)
     } finally {
       release()
     }
@@ -528,6 +531,8 @@ describe("Save Space scans", () => {
       vault.scanStatus().hash_bytes_completed,
       contents.length * 2
     )
+    assert.equal(vault.scanStatus().previous_stage, "publishing")
+    assert.ok(vault.scanStatus().publish_duration_ms >= 0)
   })
 
   test("an anchor sharing a scanned inode is not counted as a second read", async () => {