salidium 0.4.0 → 0.5.0

package/bundle/salidium.mjs

@@ -13,6 +13,7 @@ import {
   existsSync as existsSync21,
   mkdirSync as mkdirSync12,
   openSync as openSync7,
+  readFileSync as readFileSync13,
   statfsSync as statfsSync3,
   statSync as statSync15
 } from "node:fs";
@@ -21,6 +22,7 @@ import { arch, homedir as homedir5, platform as platform2, release } from "node:
 import { join as join23, resolve as resolve6, sep as sep3 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { setTimeout as sleep } from "node:timers/promises";
+import { parentPort } from "node:worker_threads";
 
 // ../core/dist/claims/markdown.js
 var FENCE = /(^|\n)\s*(```|~~~)/;
@@ -277,6 +279,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|$)/ },
@@ -18978,6 +18991,30 @@ var OperationsStoreMeasurementSchema = external_exports.object({
   retention: RetentionDaysSchema.nullable(),
   lastIngestAt: CanonicalTimestampSchema.nullable()
 }).strict();
+var StorageCompositionPartSchema = external_exports.object({
+  key: external_exports.enum(["sessions", "checkpoints", "provenance", "structure", "reusable"]),
+  bytes: external_exports.number().int().nonnegative()
+}).strict();
+var StorageCompositionProjectSchema = external_exports.object({
+  /** Repository root, else working directory, else empty when the session recorded neither. */
+  path: external_exports.string(),
+  sessions: external_exports.number().int().nonnegative(),
+  bytes: external_exports.number().int().nonnegative()
+}).strict();
+var StorageCompositionSchema = external_exports.object({
+  contractVersion: external_exports.literal(OPERATIONS_CONTRACT_VERSION),
+  state: external_exports.enum(["absent", "running", "ready", "failed"]),
+  computedAt: CanonicalTimestampSchema.nullable(),
+  elapsedMs: external_exports.number().int().nonnegative().nullable(),
+  /** The database file at the moment of measurement, from page count and page size. */
+  fileBytes: external_exports.number().int().nonnegative().nullable(),
+  sessions: external_exports.number().int().nonnegative().nullable(),
+  parts: external_exports.array(StorageCompositionPartSchema),
+  projects: external_exports.array(StorageCompositionProjectSchema),
+  /** Projects measured but not listed, so a truncated list can say so rather than imply totality. */
+  projectsOmitted: external_exports.number().int().nonnegative(),
+  failure: external_exports.string().max(500).nullable()
+}).strict();
 var MaintenancePhaseSchema = external_exports.enum([
   "idle",
   "pause",
@@ -19089,6 +19126,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 +24688,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 +24698,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 +24709,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 +24758,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 +24792,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 +24807,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 +24886,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
   },
@@ -26860,6 +26938,87 @@ var SqliteStore = class {
     });
     return true;
   }
+  /*
+   * What the store is made of, measured rather than estimated.
+   *
+   * Every part here is one pass over a table. The events pass is the expensive one: `length(json)`
+   * does not read a blob's payload, but it does read the header of every row, so on a store with
+   * 1.3 million events that is a ten second scan and the reason this never runs on the health path
+   * or on a timer. The daemon runs it on a worker with its own read-only connection for the same
+   * reason it runs usage backfill there: a ten second synchronous scan on the main loop is ten
+   * seconds of unanswered hooks.
+   *
+   * `structure` is deliberately a subtraction. Naming what each index costs needs `dbstat`, which
+   * is a further nine to fifteen seconds because it walks every page in the file, and the answer
+   * it adds is "your indexes are large" rather than anything a reader can act on. The difference
+   * is honest, arrives free, and is labelled as a remainder wherever it is shown.
+   */
+  storageComposition(projectLimit = 12) {
+    const started = Date.now();
+    const scalar = (sql) => {
+      const row = this.db.prepare(sql).get();
+      const value2 = row ? Object.values(row)[0] : 0;
+      return typeof value2 === "number" ? value2 : Number(value2 ?? 0);
+    };
+    const pageSize = scalar("PRAGMA page_size");
+    const fileBytes = scalar("PRAGMA page_count") * pageSize;
+    const reusable = scalar("PRAGMA freelist_count") * pageSize;
+    const sessions = this.db.prepare(`SELECT id, COALESCE(NULLIF(repo_root, ''), NULLIF(cwd, ''), '') AS project FROM sessions`).all();
+    const projectOf = new Map(sessions.map((row) => [row.id, row.project]));
+    const perProject = /* @__PURE__ */ new Map();
+    for (const row of sessions) {
+      const entry2 = perProject.get(row.project) ?? { sessions: 0, bytes: 0 };
+      entry2.sessions += 1;
+      perProject.set(row.project, entry2);
+    }
+    let sessionBytes = 0;
+    let checkpointBytes = 0;
+    const accumulate = (sql, into) => {
+      for (const row of this.db.prepare(sql).all()) {
+        const bytes = Number(row.b ?? 0);
+        into(bytes);
+        const project = projectOf.get(row.id);
+        if (project === void 0)
+          continue;
+        const entry2 = perProject.get(project);
+        if (entry2)
+          entry2.bytes += bytes;
+      }
+    };
+    accumulate("SELECT session_id AS id, SUM(length(json)) AS b FROM events GROUP BY session_id", (b) => {
+      sessionBytes += b;
+    });
+    accumulate("SELECT session_id AS id, SUM(length(json)) AS b FROM changes GROUP BY session_id", (b) => {
+      sessionBytes += b;
+    });
+    accumulate("SELECT session_id AS id, SUM(length(state_json)) AS b FROM checkpoints GROUP BY session_id", (b) => {
+      checkpointBytes += b;
+    });
+    const provenanceBytes = scalar(`SELECT COALESCE(SUM(length(session_id) + length(event_id) + length(path)
+         + length(record_hash) + length(captured_at) + length(COALESCE(origin, ''))), 0) AS b
+       FROM raw_record_fingerprints`);
+    const named = sessionBytes + checkpointBytes + provenanceBytes + reusable;
+    const ranked = [...perProject.entries()].map(([path, value2]) => ({ path, sessions: value2.sessions, bytes: value2.bytes })).sort((a, b) => b.bytes - a.bytes || b.sessions - a.sessions);
+    return {
+      contractVersion: OPERATIONS_CONTRACT_VERSION,
+      state: "ready",
+      computedAt: new Date(started).toISOString(),
+      elapsedMs: Date.now() - started,
+      fileBytes,
+      sessions: sessions.length,
+      parts: [
+        { key: "sessions", bytes: sessionBytes },
+        { key: "checkpoints", bytes: checkpointBytes },
+        { key: "provenance", bytes: provenanceBytes },
+        // A store measured while it is being written to can name more than the file holds.
+        { key: "structure", bytes: Math.max(fileBytes - named, 0) },
+        { key: "reusable", bytes: reusable }
+      ],
+      projects: ranked.slice(0, projectLimit),
+      projectsOmitted: Math.max(ranked.length - projectLimit, 0),
+      failure: null
+    };
+  }
   /** Offline space reclamation after bounded cleanup batches. */
   compact() {
     if (!this.usageBackfillProgress().complete)
@@ -27715,9 +27874,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.`
   };
 }
@@ -28699,6 +28863,13 @@ function createHttpServer(deps) {
     }
     if (req.method === "POST" && url2.pathname === "/api/operations/maintenance/drain" && deps.operations)
       return json2(res, 200, deps.operations.drainQueue());
+    if (url2.pathname === "/api/operations/storage" && deps.operations) {
+      if (req.method === "GET")
+        return json2(res, 200, deps.operations.storageComposition());
+      if (req.method === "POST")
+        return json2(res, 200, deps.operations.analyzeStorage());
+      return json2(res, 405, { error: "method not allowed" });
+    }
     const acknowledge = /^\/api\/operations\/alerts\/([^/]+)\/acknowledge$/.exec(url2.pathname);
     if (req.method === "POST" && acknowledge?.[1] && deps.operations) {
       try {
@@ -29438,6 +29609,67 @@ async function startDaemon(overrides = {}) {
     refreshHealthSampling?.();
     return effective2;
   };
+  let composition = {
+    contractVersion: OPERATIONS_CONTRACT_VERSION,
+    state: "absent",
+    computedAt: null,
+    elapsedMs: null,
+    fileBytes: null,
+    sessions: null,
+    parts: [],
+    projects: [],
+    projectsOmitted: 0,
+    failure: null
+  };
+  let compositionWorker;
+  const analyzeStorage = () => {
+    if (compositionWorker)
+      return composition;
+    const sibling = new URL("./storage/compositionWorker.js", import.meta.url);
+    const worker = existsSync16(fileURLToPath(sibling)) ? new Worker(sibling, { workerData: paths.db }) : (() => {
+      const runtime = process.argv[1];
+      if (!runtime)
+        return void 0;
+      return new Worker(resolve4(runtime), {
+        argv: ["__storage-composition", paths.db]
+      });
+    })();
+    if (!worker) {
+      composition = {
+        ...composition,
+        state: "failed",
+        failure: "Salidium could not locate a runtime to measure the store with."
+      };
+      return composition;
+    }
+    compositionWorker = worker;
+    worker.unref();
+    composition = { ...composition, state: "running", failure: null };
+    worker.once("message", (message) => {
+      composition = message;
+    });
+    worker.once("error", (error51) => {
+      log.warn("storage composition worker failed", { err: String(error51) });
+      composition = { ...composition, state: "failed", failure: String(error51).slice(0, 500) };
+    });
+    worker.once("exit", (code) => {
+      if (compositionWorker === worker)
+        compositionWorker = void 0;
+      if (code !== 0 && composition.state === "running")
+        composition = {
+          ...composition,
+          state: "failed",
+          failure: `The measurement stopped with status ${code}.`
+        };
+      else if (composition.state === "running")
+        composition = {
+          ...composition,
+          state: "failed",
+          failure: "The measurement produced no result."
+        };
+    });
+    return composition;
+  };
   let port = config2.port;
   const server = createHttpServer({
     registry: registry2,
@@ -29473,7 +29705,9 @@ async function startDaemon(overrides = {}) {
         return inspectQueue(config2.home, { entryLimit: limit });
       },
       drainQueue: () => runQueueDrainMaintenance(config2.home, () => hooks.drainSpool()),
-      acknowledgeAlert: (id) => acknowledgeLocalAlert(config2.home, id)
+      acknowledgeAlert: (id) => acknowledgeLocalAlert(config2.home, id),
+      storageComposition: () => composition,
+      analyzeStorage
     },
     settings: {
       explainer: explainerSettings,
@@ -29564,6 +29798,8 @@ async function startDaemon(overrides = {}) {
       clearTimeout(usageBackfillRetryTimer);
     if (usageBackfillWorker)
       void usageBackfillWorker.terminate();
+    if (compositionWorker)
+      void compositionWorker.terminate();
     if (healthTimer)
       clearTimeout(healthTimer);
     if (hookTrustTimer)
@@ -31510,6 +31746,15 @@ async function runFirstRunOnboarding(context, io, options = {}) {
   };
 }
 
+// src/pauseOnRun.ts
+function clearsPauseOnRun(command, argument, argv) {
+  if (argv.includes("--no-resume")) return false;
+  if (["pause", "resume", "stop", "service"].includes(command)) return false;
+  if (command.startsWith("__")) return false;
+  if (command === "storage" && argument === "optimize") return false;
+  return true;
+}
+
 // src/render.ts
 var H = "\u2500";
 var CONTROL = /[\u0000-\u001F\u007F-\u009F]/g;
@@ -31740,6 +31985,7 @@ Usage:
   salidium retention apply      Apply one cleanup batch now (daemon must be stopped)
   salidium retention compact    Return reusable SQLite pages to the OS (daemon must be stopped)
   salidium storage              Show the lossless storage layout and page size
+  salidium storage composition  Measure what is using the space, by part and by project
   salidium storage optimize     Coordinate, copy, verify, and install the compact layout
   salidium pin [session]        Exempt a session from automatic retention
   salidium unpin [session]      Remove the retention exemption
@@ -31761,7 +32007,9 @@ Environment:
 
 Native Windows imports transcript history but does not install the POSIX live-hook relay.
 Ordinary commands resume an expired or manual pause. pause, stop, service commands, and coordinated
-storage optimize do not; resume changes collection state explicitly.
+storage optimize do not; resume changes collection state explicitly. Add --no-resume to any command
+to leave a pause in place, for a caller that has already seen the daemon answer and so cannot be
+recovering a marker its dead owner left behind.
 `;
 var require3 = createRequire2(import.meta.url);
 var VERSION2 = (() => {
@@ -31781,11 +32029,10 @@ async function main(argv) {
   const jsonOutput = argv.includes("--json");
   const quiet = argv.includes("--quiet");
   const positional = argv.filter(
-    (value2) => !["--yes", "-y", "--no-open", "--json", "--quiet"].includes(value2)
+    (value2) => !["--yes", "-y", "--no-open", "--json", "--quiet", "--no-resume"].includes(value2)
   );
   const [cmd = "up", arg, ...args] = positional;
-  if (!["pause", "resume", "stop", "service", "__usage-backfill"].includes(cmd) && !(cmd === "storage" && arg === "optimize"))
-    await implicitlyResumeCollection();
+  if (clearsPauseOnRun(cmd, arg, argv)) await implicitlyResumeCollection();
   switch (cmd) {
     case "help":
     case "--help":
@@ -31828,6 +32075,24 @@ async function main(argv) {
         store.close();
       }
     }
+    /*
+     * The other private worker entrypoint. Measuring what the store is made of reads the header of
+     * every stored event, which is ten seconds on a three gigabyte store, and `node:sqlite` is
+     * synchronous: run on the daemon's loop that is ten seconds of hooks going unanswered and
+     * spooling to disk. It runs here instead, on its own event loop and its own connection, and
+     * posts one message back.
+     */
+    case "__storage-composition": {
+      if (!arg || !resolve6(arg).startsWith(`${resolve6(salidiumHome)}${sep3}`))
+        throw new Error("storage composition store must be inside the Salidium state directory");
+      const store = new SqliteStore(resolve6(arg), { concurrentWriter: true });
+      try {
+        parentPort?.postMessage(store.storageComposition());
+        return 0;
+      } finally {
+        store.close();
+      }
+    }
     case "start": {
       const running = await ensureDaemon();
       const explanations = await currentExplanationState(running, "reachable");
@@ -32442,9 +32707,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}
 `);
@@ -32464,10 +32729,54 @@ Change with: salidium explanations off|when-done|each-reply
 `);
         return 1;
       }
-      if (arg !== void 0 && arg !== "optimize") {
-        process.stderr.write("storage accepts only `optimize`\n");
+      if (arg !== void 0 && arg !== "optimize" && arg !== "composition") {
+        process.stderr.write("storage accepts only `composition` or `optimize`\n");
         return 2;
       }
+      if (arg === "composition") {
+        const store = new SqliteStore(db, { concurrentWriter: true });
+        try {
+          const measured = store.storageComposition();
+          if (jsonOutput) {
+            process.stdout.write(`${JSON.stringify(measured)}
+`);
+            return 0;
+          }
+          const label = {
+            sessions: "Recorded sessions",
+            checkpoints: "Replay checkpoints",
+            provenance: "Provenance records",
+            structure: "Indexes and internal structure",
+            reusable: "Reusable space"
+          };
+          process.stdout.write(`On this Mac: ${formatBytes(measured.fileBytes ?? 0)}
+`);
+          for (const part of measured.parts)
+            process.stdout.write(
+              `  ${(label[part.key] ?? part.key).padEnd(30)} ${formatBytes(part.bytes)}
+`
+            );
+          process.stdout.write(
+            `
+${measured.sessions ?? 0} sessions across ${measured.projects.length + measured.projectsOmitted} projects.
+`
+          );
+          for (const project of measured.projects)
+            process.stdout.write(
+              `  ${formatBytes(project.bytes).padStart(9)}  ${String(project.sessions).padStart(4)} ${project.sessions === 1 ? "session " : "sessions"}  ${project.path || "No project recorded"}
+`
+            );
+          if (measured.projectsOmitted > 0)
+            process.stdout.write(`  ${measured.projectsOmitted} more not listed.
+`);
+          process.stdout.write(
+            "\nIndexes and internal structure is the remainder after the named parts, not a separate measurement.\n"
+          );
+          return 0;
+        } finally {
+          store.close();
+        }
+      }
       if (arg === void 0) {
         const layout = inspectStoreLayout(db);
         if (quiet) return layout.optimized ? 0 : 3;
@@ -32767,10 +33076,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 +33244,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 +33272,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 +33297,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 +33307,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 +33541,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)}`;
@@ -33496,11 +33831,22 @@ async function ensureDaemon() {
   for (let i = 0; i < 100; i++) {
     await sleep(100);
     if (childFailure)
-      throw new Error(`daemon ${childFailure} before it became ready; see ${paths.startupLogFile}`);
+      throw new Error(
+        `daemon ${childFailure} before it became ready: ${startupFailureReason(paths.startupLogFile)}`
+      );
     const d = readDaemonJson(salidiumHome);
     if (d && d.pid === child.pid && await alive(d)) return d;
   }
-  throw new Error(`daemon did not start; see ${paths.startupLogFile}`);
+  throw new Error(`daemon did not start: ${startupFailureReason(paths.startupLogFile)}`);
+}
+function startupFailureReason(logFile) {
+  try {
+    const lines = readFileSync13(logFile, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
+    const last = lines.at(-1);
+    if (last) return `${last.slice(0, 200)} (see ${logFile})`;
+  } catch {
+  }
+  return `see ${logFile}`;
 }
 function compareSemver(left, right) {
   const parse3 = (value2) => {