salidium 0.4.0 → 0.4.1

package/bundle/native/SalidiumMenuBar.swift

@@ -138,7 +138,7 @@ private final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate
         snapshot.pid = integer(daemonHealth["pid"])
         if let collection = health["collection"] as? [String: Any],
            let state = collection["state"] as? String {
-            snapshot.collection = state == "active" ? "Active" : "Paused"
+            snapshot.collection = state == "active" ? "On" : "Paused"
         }
         if let queue = health["queue"] as? [String: Any] {
             snapshot.queueFiles = integer(queue["files"])
@@ -170,9 +170,9 @@ private final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate
     }
 
     private static func retentionLabel(_ value: Any) -> String {
-        if let text = value as? String { return text == "forever" ? "Forever" : text }
-        if let days = integer(value) { return "\(days) days" }
-        return "Unavailable"
+        if let text = value as? String { return text == "forever" ? "kept forever" : text }
+        if let days = integer(value) { return "kept \(days) days" }
+        return "retention unavailable"
     }
 
     private static func titleCase(_ value: String) -> String {
@@ -191,21 +191,24 @@ private final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate
         menu.removeAllItems()
         configureStatusIcon()
 
+        // No em dash in anything the product says. `printedVoice.test.ts` reads this file for them.
         let heading: String
         switch snapshot.health {
-        case .healthy: heading = "Salidium — Healthy"
-        case .attention: heading = "Salidium — Needs Attention"
-        case .critical: heading = "Salidium — Critical"
-        case .offline: heading = "Salidium — Stopped"
+        case .healthy: heading = "Salidium · Healthy"
+        case .attention: heading = "Salidium · Needs Attention"
+        case .critical: heading = "Salidium · Critical"
+        case .offline: heading = "Salidium · Not Running"
         }
         addLabel(heading, emphasized: true)
         menu.addItem(.separator())
 
-        addLabel(snapshot.pid.map { "Running · PID \($0)" } ?? "Daemon · Not running")
-        addLabel("Collection · \(snapshot.collection)")
-        addLabel("Queue · \(queueLabel())")
-        addLabel("Storage · \(storageLabel())")
-        addLabel(snapshot.activeAlerts == 0 ? "Alerts · None active" : "Alerts · \(snapshot.activeAlerts) active")
+        addLabel(snapshot.pid.map { "Running · PID \($0)" } ?? "Not running")
+        addLabel("Recording · \(snapshot.collection)")
+        addLabel("Waiting to be stored · \(queueLabel())")
+        addLabel("On this Mac · \(storageLabel())")
+        addLabel(snapshot.activeAlerts == 0
+                 ? "Nothing needs attention"
+                 : "\(snapshot.activeAlerts) need\(snapshot.activeAlerts == 1 ? "s" : "") attention")
         if let maintenance = snapshot.maintenance { addLabel("Maintenance · \(maintenance)") }
 
         menu.addItem(.separator())
@@ -217,7 +220,7 @@ private final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate
             addAction(paused ? "Resume Collection" : "Pause Collection",
                       paused ? #selector(resumeCollection) : #selector(pauseCollection),
                       enabled: true)
-            addAction("Drain Queue Toward Empty", #selector(drainQueue), enabled: true)
+            addAction("Store One Batch Now", #selector(drainQueue), enabled: true)
             addAction("Stop Salidium", #selector(stopSalidium), enabled: true)
         }
         addAction("Refresh Now", #selector(refreshNow), key: "r", enabled: true)
@@ -259,16 +262,23 @@ private final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate
 
     private func storageLabel() -> String {
         guard let bytes = snapshot.storeBytes else { return "Unavailable" }
-        return "\(Self.byteLabel(bytes)) · \(snapshot.retention) retention"
+        return "\(Self.byteLabel(bytes)) · \(snapshot.retention)"
     }
 
+    /*
+     * The same rendering as `formatBytes` in `@salidium/core`, which the app and the CLI use.
+     *
+     * Decimal, matching Finder, but not `ByteCountFormatter`: its adaptive mode renders one byte as
+     * "0 KB" and 999999 as "1 MB", and the same function formats rates where that loses the value.
+     * `byteLabelVectors` in that module pins the cases, and `macosService.test.ts` checks them
+     * against this function, because Swift cannot import it.
+     */
     private static func byteLabel(_ bytes: Int) -> String {
-        let formatter = ByteCountFormatter()
-        formatter.countStyle = .file
-        formatter.allowedUnits = [.useKB, .useMB, .useGB]
-        formatter.includesUnit = true
-        formatter.isAdaptive = true
-        return formatter.string(fromByteCount: Int64(bytes))
+        let value = Double(bytes)
+        if bytes < 1000 { return "\(bytes) B" }
+        if bytes < 1000 * 1000 { return String(format: "%.1f KB", value / 1000) }
+        if bytes < 1000 * 1000 * 1000 { return String(format: "%.1f MB", value / (1000 * 1000)) }
+        return String(format: "%.2f GB", value / (1000 * 1000 * 1000))
     }
 
     private func addLabel(_ title: String, emphasized: Bool = false) {

package/bundle/salidium.mjs

@@ -277,6 +277,17 @@ function headlineOf(text, max = 160) {
   return "";
 }
 
+// ../core/dist/format/bytes.js
+function formatBytes(bytes) {
+  if (bytes < 1e3)
+    return `${bytes} B`;
+  if (bytes < 1e3 * 1e3)
+    return `${(bytes / 1e3).toFixed(1)} KB`;
+  if (bytes < 1e3 * 1e3 * 1e3)
+    return `${(bytes / (1e3 * 1e3)).toFixed(1)} MB`;
+  return `${(bytes / (1e3 * 1e3 * 1e3)).toFixed(2)} GB`;
+}
+
 // ../core/dist/verification/classifyCommand.js
 var RULES = [
   { runner: "vitest", method: "test", pattern: /^vitest(\s|$)/ },
@@ -19089,6 +19100,17 @@ var LocalAlertSchema = external_exports.object({
   state: external_exports.enum(["active", "acknowledged", "recovered"]),
   title: external_exports.string().min(1).max(160),
   detail: external_exports.string().min(1).max(500),
+  /*
+   * What to say once the condition is over.
+   *
+   * Without these a recovered alert can only be shown in the words that announced it, and every
+   * surface that renders one inherits the present tense: the macOS notification read "Recovered:
+   * The durable queue is growing", which is the all-clear and the alarm in one line. Optional
+   * because a ledger written before this field existed still has to parse; readers fall back to
+   * `title` and `detail`.
+   */
+  recoveryTitle: external_exports.string().min(1).max(160).optional(),
+  recoveryDetail: external_exports.string().min(1).max(500).optional(),
   firstSeenAt: CanonicalTimestampSchema,
   lastSeenAt: CanonicalTimestampSchema,
   lastTransitionAt: CanonicalTimestampSchema,
@@ -24640,7 +24662,9 @@ function conditions(snapshot, config2, priorHookTrust, priorGapFingerprint, now)
       kind: "queue-age",
       severity: "warning",
       title: "Queued work is aging",
-      detail: `The oldest durable queue item is at least ${values2.alerts.queueAgeMinutes.value} minutes old.`
+      detail: `The oldest item waiting to be stored is at least ${values2.alerts.queueAgeMinutes.value} minutes old.`,
+      recoveryTitle: "Queued work is moving again",
+      recoveryDetail: `Nothing has been waiting longer than ${values2.alerts.queueAgeMinutes.value} minutes. No action is needed.`
     });
   const velocity = snapshot.estimates.queueVelocity;
   if (velocity && velocity.value > 0 && velocity.value * (velocity.sampleWindowSeconds / 60) >= values2.alerts.queueGrowthFiles.value)
@@ -24648,8 +24672,10 @@ function conditions(snapshot, config2, priorHookTrust, priorGapFingerprint, now)
       key: "queue-growth",
       kind: "queue-growth",
       severity: "warning",
-      title: "The durable queue is growing",
-      detail: `Net growth crossed ${values2.alerts.queueGrowthFiles.value} files in the sampled window.`
+      title: "Salidium is falling behind",
+      detail: `Your agents are producing work faster than Salidium is storing it: ${values2.alerts.queueGrowthFiles.value} more files are waiting than when this window started. Nothing is lost while it waits.`,
+      recoveryTitle: "Salidium caught up",
+      recoveryDetail: "The backlog stopped growing. No action is needed."
     });
   if (snapshot.store.totalBytes !== null && snapshot.store.totalBytes >= values2.alerts.databaseSizeBytes.value)
     out.push({
@@ -24657,31 +24683,45 @@ function conditions(snapshot, config2, priorHookTrust, priorGapFingerprint, now)
       kind: "database-size",
       severity: "notice",
       title: "Local storage crossed its warning size",
-      detail: `The SQLite store and recovery log use ${snapshot.store.totalBytes} bytes.`
+      detail: `Salidium is using ${formatBytes(snapshot.store.totalBytes)} on this Mac, past the ${formatBytes(values2.alerts.databaseSizeBytes.value)} mark. Retention is set to ${snapshot.store.retention === "forever" ? "keep everything forever" : `${snapshot.store.retention} days`}.`,
+      recoveryTitle: "Local storage is back under its warning size",
+      /*
+       * No measurement in here. Recovery wording is composed while the condition is still true and
+       * refreshed only for as long as it stays true, so quoting `store.totalBytes` would put the
+       * size that raised the alert into the sentence saying the alert is over: "Salidium is using
+       * 5.01 GB, below the 5.00 GB mark". The threshold is config and does not have that problem.
+       */
+      recoveryDetail: `Salidium is back below ${formatBytes(values2.alerts.databaseSizeBytes.value)}. Open Salidium to see the current size.`
     });
   if (snapshot.gaps.latestFingerprint && (snapshot.gaps.active > 0 || snapshot.gaps.latestFingerprint !== priorGapFingerprint))
     out.push({
       key: `collection-gap:${snapshot.gaps.latestFingerprint}`,
       kind: "collection-gap",
       severity: snapshot.gaps.active > 0 ? "critical" : "warning",
-      title: snapshot.gaps.active > 0 ? "Collection loss is active" : "A new collection gap was recorded",
-      detail: "The gap ledger changed. Exact dropped-event counts remain unavailable."
+      title: snapshot.gaps.active > 0 ? "Salidium is missing some activity" : "Salidium missed some activity",
+      detail: snapshot.gaps.active > 0 ? "Agent activity is happening that Salidium is not recording. Reports covering this period will be incomplete. How much was missed cannot be counted." : "A period of agent activity went unrecorded. Reports covering it will be incomplete. How much was missed cannot be counted.",
+      recoveryTitle: "Salidium is recording everything again",
+      recoveryDetail: "Collection is complete from here on. Reports covering the earlier gap stay incomplete."
     });
   if (snapshot.daemon.state !== "running")
     out.push({
       key: "daemon-health",
       kind: "daemon-health",
       severity: snapshot.daemon.state === "unresponsive" ? "critical" : "warning",
-      title: snapshot.daemon.state === "unresponsive" ? "The daemon is not answering" : "The daemon is stopped",
-      detail: `Daemon state changed to ${snapshot.daemon.state}.`
+      title: snapshot.daemon.state === "unresponsive" ? "Salidium is not responding" : "Salidium has stopped",
+      detail: snapshot.daemon.state === "unresponsive" ? "Salidium is running but not answering. Agent activity is not being recorded while this lasts." : "Salidium is not running. Agent activity is not being recorded until it starts again.",
+      recoveryTitle: "Salidium is running again",
+      recoveryDetail: "Recording has resumed. No action is needed."
     });
   if (snapshot.maintenance?.phase === "failure" || snapshot.maintenance?.phase === "recovery")
     out.push({
       key: `maintenance-failure:${snapshot.maintenance.operationId}`,
       kind: "maintenance-failure",
       severity: "critical",
-      title: "Maintenance needs recovery",
-      detail: (snapshot.maintenance.failure ?? snapshot.maintenance.message).slice(0, 500)
+      title: "Maintenance did not finish",
+      detail: (snapshot.maintenance.failure ?? snapshot.maintenance.message).slice(0, 500),
+      recoveryTitle: "Maintenance finished",
+      recoveryDetail: "The operation that needed attention completed. No action is needed."
     });
   for (const hook of snapshot.hooks) {
     const prior = priorHookTrust[hook.id];
@@ -24692,8 +24732,10 @@ function conditions(snapshot, config2, priorHookTrust, priorGapFingerprint, now)
         key: `hook-trust-change:${hook.id}`,
         kind: "hook-trust-change",
         severity: hook.trust === "modified" || hook.trust === "untrusted" ? "critical" : "notice",
-        title: `${hook.name} hook trust changed`,
-        detail: `Trust changed from ${prior} to ${hook.trust}.`
+        title: unsafe ? `The ${hook.name} hook is no longer approved` : `The ${hook.name} hook was approved`,
+        detail: unsafe ? `The hook file changed since you approved it (${prior} to ${hook.trust}). Salidium will not trust it until you approve the new version.` : `Approval state went from ${prior} to ${hook.trust}.`,
+        recoveryTitle: `The ${hook.name} hook is approved again`,
+        recoveryDetail: "The hook file matches an approved version. No action is needed."
       });
   }
   return out;
@@ -24724,6 +24766,8 @@ async function evaluateLocalAlerts(home, snapshot, config2, options = {}) {
       existing.severity = condition.severity;
       existing.title = condition.title;
       existing.detail = condition.detail;
+      existing.recoveryTitle = condition.recoveryTitle;
+      existing.recoveryDetail = condition.recoveryDetail;
       existing.notificationEligible = false;
       continue;
     }
@@ -24737,6 +24781,8 @@ async function evaluateLocalAlerts(home, snapshot, config2, options = {}) {
       state: "active",
       title: condition.title,
       detail: condition.detail,
+      recoveryTitle: condition.recoveryTitle,
+      recoveryDetail: condition.recoveryDetail,
       firstSeenAt: at,
       lastSeenAt: at,
       lastTransitionAt: at,
@@ -24814,7 +24860,13 @@ var DEFAULT_OPERATIONAL_CONFIG = {
   alerts: {
     queueAgeMinutes: 10,
     queueGrowthFiles: 100,
-    databaseSizeBytes: 5 * 1024 * 1024 * 1024,
+    /*
+     * Decimal, to pair with how the size is shown. Left at 5 GiB it read "warns at 5.37 GB", which
+     * is not a number anyone chose, and the rail's own picker offered GiB steps that no longer
+     * matched any label. This lowers the warning by about seven percent; it is a notice about a
+     * local file, and `alerts.databaseSizeBytes` still overrides it.
+     */
+    databaseSizeBytes: 5 * 1e3 * 1e3 * 1e3,
     cooldownMinutes: 30,
     nativeNotifications: false
   },
@@ -27715,9 +27767,14 @@ function runStorageOptimizationMaintenance(home, options = {}) {
 import { spawn as spawn3 } from "node:child_process";
 import { delimiter as delimiter3 } from "node:path";
 function notificationText(alert) {
+  if (alert.state === "recovered")
+    return {
+      title: alert.recoveryTitle ?? `Recovered: ${alert.title}`,
+      detail: alert.recoveryDetail ?? alert.detail
+    };
   const detail = alert.kind === "maintenance-failure" ? "Maintenance needs local review. Open Salidium or run salidium maintenance status for details." : alert.detail;
   return {
-    title: alert.state === "recovered" ? `Recovered: ${alert.title}` : alert.title,
+    title: alert.title,
     detail: `${detail} Open Salidium or run salidium status for details.`
   };
 }
@@ -32442,9 +32499,9 @@ Change with: salidium explanations off|when-done|each-reply
 `);
         process.stdout.write(`Store: ${formatBytes(storeBytes)}
 `);
-        if (storeBytes >= 1024 * 1024 * 1024)
+        if (storeBytes >= 1e3 * 1e3 * 1e3)
           process.stdout.write(
-            inspectStoreLayout(db).optimized ? "Storage warning: history is over 1 GiB. Preview exactly what retention would delete before opting in.\n" : "Lossless storage optimization is available before deleting history. Run `salidium storage`, then `salidium storage optimize`; it coordinates queue drain and daemon stop.\n"
+            inspectStoreLayout(db).optimized ? "Storage warning: history is over 1 GB. Preview exactly what retention would delete before opting in.\n" : "Lossless storage optimization is available before deleting history. Run `salidium storage`, then `salidium storage optimize`; it coordinates queue drain and daemon stop.\n"
           );
         process.stdout.write(`Pinned: ${store.pinnedSessionIds().length}
 `);
@@ -32767,10 +32824,11 @@ async function readOperationsOverview(daemon, presence, providers) {
     alerts: await evaluateLocalAlerts(salidiumHome, health, config2)
   };
 }
-function estimateLabel(estimate2) {
-  if (!estimate2) return "Unavailable (needs at least two exact samples)";
+function estimateLabel(estimate2, absent = "Unavailable (needs two measurements)") {
+  if (!estimate2) return absent;
   const value2 = estimate2.unit === "bytes/minute" ? `${formatBytes(Math.abs(estimate2.value))}/minute` : Math.abs(estimate2.value).toFixed(1);
-  const sign = estimate2.value < 0 ? "\u2212" : estimate2.value > 0 ? "+" : "";
+  const zero = /^[0.]+(?: B\/minute)?$/.test(value2);
+  const sign = zero ? "" : estimate2.value < 0 ? "\u2212" : "+";
   const unit = estimate2.unit === "bytes/minute" ? "" : ` ${estimate2.unit}`;
   return `${sign}${value2}${unit} \xB7 derived from ${estimate2.samples} samples over ${Math.round(estimate2.sampleWindowSeconds)}s`;
 }
@@ -32934,10 +32992,9 @@ async function statusCommand(options) {
         );
       } else {
         const health = operations.health;
-        if (health.daemon.state === "stopped") process.stdout.write("not running\n");
         process.stdout.write(
           health.daemon.state === "running" ? `Daemon: Running \xB7 pid ${health.daemon.pid} \xB7 since ${health.daemon.startedAt}
-` : health.daemon.state === "unresponsive" ? `Daemon running: pid ${health.daemon.pid} \xB7 not answering
+` : health.daemon.state === "unresponsive" ? `Daemon: Not answering \xB7 pid ${health.daemon.pid}
 ` : "Daemon: Stopped\n"
         );
         process.stdout.write(
@@ -32963,12 +33020,24 @@ async function statusCommand(options) {
           `Store (exact): ${health.store.totalBytes === null ? "Unavailable" : formatBytes(health.store.totalBytes)}, retention ${retentionLabel(health.store.retention)}, last ingest ${health.store.lastIngestAt ?? "Unavailable"}
 `
         );
+        const projection = storageProjection(
+          health.store.totalBytes,
+          health.estimates.storageGrowth,
+          operations.config.values.alerts.databaseSizeBytes.value
+        );
+        if (projection) process.stdout.write(`Store outlook: ${projection}
+`);
         process.stdout.write(
           `Queue velocity (estimate): ${estimateLabel(health.estimates.queueVelocity)}
 `
         );
+        const sampled = health.estimates.queueVelocity !== null;
+        const notShrinking = "Unavailable (the queue is not shrinking)";
         process.stdout.write(
-          `Drain rate (estimate): ${estimateLabel(health.estimates.drainRate)}
+          `Drain rate (estimate): ${estimateLabel(
+            health.estimates.drainRate,
+            sampled ? notShrinking : void 0
+          )}
 `
         );
         process.stdout.write(
@@ -32976,7 +33045,7 @@ async function statusCommand(options) {
 `
         );
         process.stdout.write(
-          `Time to empty (estimate): ${health.estimates.timeToEmpty ? `${Math.round(health.estimates.timeToEmpty.value)} seconds \xB7 derived` : "Unavailable"}
+          `Time to empty (estimate): ${health.estimates.timeToEmpty ? `${Math.round(health.estimates.timeToEmpty.value)} seconds \xB7 derived` : health.queue.files === 0 ? "Already empty" : sampled ? notShrinking : "Unavailable (needs two measurements)"}
 `
         );
         process.stdout.write(
@@ -32986,7 +33055,7 @@ async function statusCommand(options) {
         process.stdout.write(`Explanations: ${explanationStateLabel(explanations)}
 `);
         process.stdout.write(
-          `Maintenance: ${health.maintenance ? `${health.maintenance.phase} \xB7 ${health.maintenance.message}` : "Idle"}
+          `Maintenance: ${health.maintenance ? `${maintenancePhaseLabel(health.maintenance.phase)} \xB7 ${health.maintenance.message}` : "Idle"}
 `
         );
         process.stdout.write(
@@ -33220,11 +33289,25 @@ async function maintenanceCommand(action, args, options) {
   process.stderr.write("maintenance accepts status, queue, drain, optimize, or acknowledge\n");
   return 2;
 }
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GiB`;
+function maintenancePhaseLabel(phase) {
+  if (phase === "failure") return "Did not finish";
+  if (phase === "recovery") return "Recovering";
+  if (phase === "completed") return "Finished";
+  if (phase === "running") return "Running";
+  return phase;
+}
+function storageProjection(total, growth, warnAt) {
+  const parts = [];
+  if (growth && growth.value > 0)
+    parts.push(`about ${formatBytes(growth.value * 60 * 24)} a day at this rate`);
+  if (total !== null) {
+    const mark2 = formatBytes(warnAt);
+    const room = formatBytes(warnAt - total);
+    parts.push(
+      total >= warnAt ? `past its ${mark2} warning mark` : room === mark2 ? `warns at ${mark2}` : `${room} below its ${mark2} warning mark`
+    );
+  }
+  return parts.join(" \xB7 ");
 }
 function queueLabel(status) {
   return `${status.queue.files.toLocaleString()} file${status.queue.files === 1 ? "" : "s"}, ${formatBytes(status.queue.bytes)}`;