disk-space-saviour 0.20.0 → 0.22.0

package/src/liveness.js

@@ -17,6 +17,12 @@
 
 import path from 'node:path';
 
+import {
+  bundleRoots,
+  bundlesOwn,
+  ownerBundleId,
+  processBundles,
+} from './app-owners.js';
 import { isWithin } from './paths.js';
 import { formatDuration } from './units.js';
 
@@ -195,6 +201,12 @@ export function matchingName(proc, names) {
   return null;
 }
 
+/** `matched`, prefixed with the app it runs from: `Warp (stable)`. */
+function appLabel(proc, matched) {
+  const app = proc.bundles?.[0]?.name;
+  return app && app !== matched ? `${app} (${matched})` : matched;
+}
+
 export class LivenessProbe {
   /**
    * @param {object} env environment adapter
@@ -212,6 +224,9 @@ export class LivenessProbe {
     this.realPaths = new Map();
     this.pathOwners = new Map();
     this.pathStats = new Map();
+    this.inodes = new Map();
+    // Bundle identifiers never change, so they outlive refreshes.
+    this.bundleIds = new Map();
   }
 
   async refresh(force = false) {
@@ -223,6 +238,7 @@ export class LivenessProbe {
     this.listed = processes !== null;
     this.processes = processes ?? [];
     this.bunCacheUsers = await this.#bunCacheUsers();
+    await this.#resolveBundles();
     this.probeError =
       (processes === null || this.openPaths === null) &&
       (this.env.platform === 'linux' || this.env.platform === 'darwin');
@@ -230,6 +246,96 @@ export class LivenessProbe {
     this.realPaths.clear();
     this.pathStats.clear();
     this.pathOwners.clear();
+    this.inodes.clear();
+  }
+
+  /** Reads the identifiers of the app bundles running processes come from. */
+  async #resolveBundles() {
+    if (!this.env.bundleIdentifier) {
+      return;
+    }
+    for (const proc of this.processes) {
+      const roots = bundleRoots(proc.executable);
+      for (const root of roots) {
+        if (!this.bundleIds.has(root)) {
+          this.bundleIds.set(
+            root,
+            await this.env.bundleIdentifier(root).catch(() => null)
+          );
+        }
+      }
+      proc.bundles = processBundles(roots, this.bundleIds);
+    }
+  }
+
+  /** ` (pid N, name)` of the process holding `open`, when the probe knows it. */
+  #holder(open) {
+    const pid = this.env.openPathPids?.get(open);
+    if (!pid) {
+      return '';
+    }
+    const proc = this.processes.find((entry) => entry.pid === pid);
+    return proc
+      ? ` (pid ${pid}, ${appLabel(proc, proc.name)})`
+      : ` (pid ${pid})`;
+  }
+
+  /** A running app that owns a per-app Library folder of `paths`. */
+  appUsage(paths) {
+    const owners = [...new Set(paths.map(ownerBundleId).filter(Boolean))];
+    if (owners.length === 0) {
+      return null;
+    }
+    for (const proc of this.processes) {
+      const owner = owners.find((id) => bundlesOwn(proc.bundles ?? [], id));
+      if (owner) {
+        return `${appLabel(proc, proc.name)} is running (pid ${proc.pid}) and owns ${owner}`;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Inodes of `executables` and of the open files that share their names,
+   * because a process running a hard link of an executable reports
+   * whichever path it was started from.
+   * @param {string[]} [executables]
+   */
+  async resolveExecutables(executables = []) {
+    if (executables.length === 0) {
+      return;
+    }
+    const names = new Set(
+      executables.map((target) => this.env.path.basename(target))
+    );
+    const missing = [
+      ...executables,
+      ...[...(this.openPaths ?? [])].filter((open) =>
+        names.has(this.env.path.basename(open))
+      ),
+    ].filter((target) => !this.inodes.has(target));
+    const stats = await Promise.all(
+      missing.map((target) => this.env.stat(target))
+    );
+    missing.forEach((target, index) =>
+      this.inodes.set(target, stats[index]?.inode ?? null)
+    );
+  }
+
+  /** A process running one of `executables` under any of its links. */
+  executableUsage(executables = []) {
+    for (const target of executables) {
+      const inode = this.inodes.get(target);
+      if (!inode) {
+        continue;
+      }
+      for (const open of this.openPaths ?? []) {
+        if (open !== target && this.inodes.get(open) === inode) {
+          return `in use: ${open} is ${target}`;
+        }
+      }
+    }
+    return null;
   }
 
   /**
@@ -360,10 +466,11 @@ export class LivenessProbe {
       ) {
         continue;
       }
-      const name = matchingName(proc, names);
-      if (!name) {
+      const matched = matchingName(proc, names);
+      if (!matched) {
         continue;
       }
+      const name = appLabel(proc, matched);
       if (!cwd) {
         return `${name} is running (pid ${proc.pid})`;
       }
@@ -386,7 +493,7 @@ export class LivenessProbe {
     for (const open of this.openPaths) {
       for (const target of targets) {
         if (isWithin(open, target, pathApi)) {
-          return `in use: ${open}`;
+          return `in use: ${open}${this.#holder(open)}`;
         }
       }
     }
@@ -421,7 +528,7 @@ export class LivenessProbe {
           candidate &&
           paths.some((target) => isWithin(candidate, target, this.env.path))
         ) {
-          return `in use: ${candidate} (pid ${proc.pid})`;
+          return `in use: ${candidate} (pid ${proc.pid}, ${appLabel(proc, proc.name)})`;
         }
       }
     }
@@ -510,7 +617,9 @@ export class LivenessProbe {
       this.probeBlocker() ??
       (checks.mtime === false ? null : this.recentWrite(item.newestMtimeMs)) ??
       this.runningTool(checks.busy, checks.cwd, item) ??
+      this.appUsage(item.paths ?? []) ??
       this.processUsage(paths) ??
+      this.executableUsage(checks.executables) ??
       this.uncertainUsage(item.paths ?? [])
     );
   }

package/src/playwright-registry.js

@@ -0,0 +1,77 @@
+/**
+ * Browser revisions that installed Playwright packages still launch.
+ *
+ * Playwright records every package it installed browsers for as a file in
+ * `<registry>/.links/` holding that package's directory, and the package's
+ * `browsers.json` names the revisions it launches. Playwright's own cleanup
+ * keeps a revision while a linked package that still exists names it; dss
+ * keeps the same revisions, so deleting one never breaks an installed
+ * project until its next `playwright install`.
+ */
+
+/** Directory of a registry revision: `chromium-headless-shell` → `chromium_headless_shell-1248`. */
+export function browserDirName(name, revision) {
+  return `${name.replace(/-/g, '_')}-${revision}`;
+}
+
+/** Revision directories one `browsers.json` names, platform overrides included. */
+export function requiredDirs(text) {
+  const browsers = JSON.parse(text)?.browsers;
+  if (!Array.isArray(browsers)) {
+    throw new Error('no browsers list');
+  }
+  return browsers.flatMap((browser) =>
+    [browser.revision, ...Object.values(browser.revisionOverrides ?? {})]
+      .filter(Boolean)
+      .map((revision) => browserDirName(browser.name, revision))
+  );
+}
+
+/**
+ * Maps each revision directory name to the linked packages that need it;
+ * `unreadable` lists links whose package exists but cannot be read.
+ */
+export async function playwrightUsers(env, registry) {
+  const users = new Map();
+  const unreadable = [];
+  for (const link of await env.list(env.path.join(registry, '.links'))) {
+    const pkg = (await env.readText(link.path))?.trim();
+    if (!pkg) {
+      unreadable.push(link.path);
+      continue;
+    }
+    const manifest = env.path.join(pkg, 'browsers.json');
+    if (!(await env.exists(manifest))) {
+      // The project or its node_modules is gone; Playwright drops the link too.
+      continue;
+    }
+    try {
+      for (const dir of requiredDirs((await env.readText(manifest)) ?? '')) {
+        users.set(dir, [...(users.get(dir) ?? []), pkg]);
+      }
+    } catch {
+      unreadable.push(manifest);
+    }
+  }
+  return { users, unreadable };
+}
+
+/**
+ * Why `target`, a revision directory in a Playwright registry, must stay;
+ * null when no installed package needs it.
+ * @param {Map<string, Promise<object>>} [cache] registry → playwrightUsers
+ */
+export async function playwrightBlocker(env, target, cache = new Map()) {
+  const registry = env.path.dirname(target);
+  if (!cache.has(registry)) {
+    cache.set(registry, playwrightUsers(env, registry));
+  }
+  const { users, unreadable } = await cache.get(registry);
+  if (unreadable.length > 0) {
+    return `cannot read Playwright install record ${unreadable[0]}`;
+  }
+  const needed = users.get(env.path.basename(target));
+  return needed
+    ? `Playwright in ${needed[0]} still uses ${env.path.basename(target)}`
+    : null;
+}

package/src/report.js

@@ -82,7 +82,14 @@ function tierSection(report, tier, options) {
     '',
     `${tier.toUpperCase()}  ${plural(items.length, 'item')}, ${formatBytes(bytes)}`,
     ...limited(
-      items.map((item) => itemLine(item, showEnv)),
+      items.flatMap((item) => [
+        itemLine(item, showEnv),
+        ...(item.globalPackages?.length
+          ? [
+              `      also removes global packages: ${item.globalPackages.join(', ')}`,
+            ]
+          : []),
+      ]),
       options.limit
     ),
   ];
@@ -107,6 +114,72 @@ function blockedSection(report, options) {
   ];
 }
 
+/**
+ * Clones that share every block with an installed app: `du` and Finder
+ * count them at full size, deleting them frees nothing.
+ */
+export function sharedSection(shared) {
+  if (!shared?.length) {
+    return [];
+  }
+  const apparent = shared.reduce((sum, item) => sum + item.apparentBytes, 0);
+  return [
+    '',
+    `SHARED WITH INSTALLED APPS  ${plural(shared.length, 'item')}, ${formatBytes(apparent)} as du counts it, about 0 B to free (APFS clones; the app recreates them at launch)`,
+    ...shared.map(
+      (item) =>
+        `  ${pad(formatBytes(item.apparentBytes), 10)}  ${item.rule}  ${item.path}  (shares its blocks with ${item.sharedWith})`
+    ),
+  ];
+}
+
+function tierBreakdown(tiers) {
+  return TIERS.filter((tier) => tiers[tier])
+    .map((tier) => `${tier} ${formatBytes(tiers[tier])}`)
+    .join(', ');
+}
+
+/** One-line warning naming the largest conditions, or null. */
+export function conditionsWarning(blocked) {
+  const conditions = blocked?.conditions ?? [];
+  if (conditions.length === 0) {
+    return null;
+  }
+  const bytes = conditions.reduce((sum, group) => sum + group.bytes, 0);
+  const top = conditions
+    .slice(0, 3)
+    .map((group) => `${group.action} (${formatBytes(group.bytes)})`);
+  const more = conditions.length > 3 ? `, ${conditions.length - 3} more` : '';
+  return `${formatBytes(bytes)} more frees only once something stops using it: ${top.join('; ')}${more}. See FREEABLE ON CONDITIONS.`;
+}
+
+function conditionsWarningLines(blocked) {
+  const warning = conditionsWarning(blocked);
+  return warning ? [`WARNING: ${warning}`] : [];
+}
+
+/** Blocked space grouped by the condition that frees it. */
+export function conditionsSection(blocked, options = {}) {
+  const conditions = blocked?.conditions ?? [];
+  if (conditions.length === 0) {
+    return [];
+  }
+  const lines = conditions.map(
+    (group) =>
+      `  ${pad(formatBytes(group.bytes), 9)}  ${group.action} (${plural(group.items, 'item')}: ${tierBreakdown(group.tiers)})`
+  );
+  if (blocked.other?.items) {
+    lines.push(
+      `  ${pad(formatBytes(blocked.other.bytes), 9)}  kept for other reasons (Git state, still needed, protected or unverifiable): ${plural(blocked.other.items, 'item')}`
+    );
+  }
+  return [
+    '',
+    'FREEABLE ON CONDITIONS (blocked items free once these happen; rerun dss afterwards)',
+    ...limited(lines, options.limit ?? DEFAULT_LIMIT),
+  ];
+}
+
 function repoSummary(repo) {
   if (repo.error) {
     return `${repo.root}: ${repo.error}`;
@@ -351,6 +424,54 @@ function timingLines(report, { verbose }) {
     });
 }
 
+function holderLine(holder) {
+  const details = [`${formatBytes(holder.memoryBytes)} memory`];
+  if (holder.compressedBytes !== undefined) {
+    details.push(`${formatBytes(holder.compressedBytes)} compressed`);
+  }
+  if (holder.swappedBytes !== undefined) {
+    details.push(`${formatBytes(holder.swappedBytes)} swapped`);
+  }
+  const change = holder.growth?.memoryBytes;
+  if (change) {
+    details.push(
+      `${change > 0 ? '+' : '-'}${formatBytes(Math.abs(change))} since ${new Date(holder.growth.since).toISOString()}`
+    );
+  }
+  return `${holder.pid} ${holder.command}: ${details.join(', ')}`;
+}
+
+function swapLines(swap) {
+  if (!swap) {
+    return [];
+  }
+  return [
+    `Swap: ${formatBytes(swap.used)} used of ${formatBytes(swap.total)} (managed by macOS)`,
+    ...(swap.warnings ?? []).map((warning) => `WARNING: ${warning}`),
+    swap.attribution,
+    ...swap.holders.map((holder) => `  ${holderLine(holder)}`),
+    swap.advice,
+  ];
+}
+
+function environmentStatusLines(env) {
+  const lines = [];
+  if (env.layerSource) {
+    lines.push(`  ${env.label}: layer source ${env.layerSource}`);
+  }
+  if (env.scanStatus === 'goal-reached') {
+    lines.push(
+      `  ${env.label}: scan stopped after the free-space goal was met`
+    );
+  } else if (env.scanStatus && env.scanStatus !== 'complete') {
+    lines.push(`  ${env.label}: scan incomplete (${env.scanStatus})`);
+  }
+  if (env.hint) {
+    lines.push(`  ${env.label}: ${env.hint}`);
+  }
+  return lines;
+}
+
 /**
  * Renders a scan report.
  * @param {object} report
@@ -364,37 +485,15 @@ export function formatReport(report, options = {}) {
     `disk-space-saviour scan of ${host.label} in ${(report.durationMs / 1000).toFixed(1)}s (report only, nothing was deleted)`,
     formatDisk(host.disk),
   ];
-  if (host.swap) {
-    lines.push(
-      `Swap: ${formatBytes(host.swap.used)} used of ${formatBytes(host.swap.total)} (managed by macOS)`
-    );
-    lines.push(host.swap.attribution);
-    for (const holder of host.swap.holders) {
-      lines.push(
-        `  ${holder.pid} ${holder.command}: ${formatBytes(holder.memoryBytes)} memory, ${formatBytes(holder.compressedBytes)} compressed`
-      );
-    }
-    lines.push(host.swap.advice);
-  }
+  lines.push(...swapLines(host.swap));
+  lines.push(...conditionsWarningLines(report.totals?.blocked));
   for (const tier of TIERS) {
     lines.push(...tierSection(report, tier, { limit }));
   }
-  for (const env of report.environments) {
-    if (env.layerSource) {
-      lines.push(`  ${env.label}: layer source ${env.layerSource}`);
-    }
-    if (env.scanStatus === 'goal-reached') {
-      lines.push(
-        `  ${env.label}: scan stopped after the free-space goal was met`
-      );
-    } else if (env.scanStatus && env.scanStatus !== 'complete') {
-      lines.push(`  ${env.label}: scan incomplete (${env.scanStatus})`);
-    }
-    if (env.hint) {
-      lines.push(`  ${env.label}: ${env.hint}`);
-    }
-  }
+  lines.push(...report.environments.flatMap(environmentStatusLines));
   lines.push(...blockedSection(report, { limit }));
+  lines.push(...sharedSection(report.shared));
+  lines.push(...conditionsSection(report.totals?.blocked, { limit }));
   lines.push(...dockerSection(report));
   lines.push(...errorsSection(report.errors));
   lines.push(...totalsSection(report));
@@ -474,6 +573,14 @@ function emergencyLines(audit) {
  * @param {object} audit
  * @param {{verbose?: boolean}} [options]
  */
+/** Warns that a plan built on an incomplete scan misses what it never reached. */
+export function incompleteScanLines(incomplete) {
+  return (incomplete ?? []).map(
+    (env) =>
+      `WARNING: the scan of ${env.label} behind this plan stopped early (${env.status}), so items it did not reach were not considered; rerun with a larger --scan-budget (for example --scan-budget 5m).`
+  );
+}
+
 export function formatAudit(audit, options = {}) {
   const limit = options.verbose ? Infinity : DEFAULT_LIMIT * 2;
   const mode = audit.dryRun ? 'dry run, nothing was deleted' : 'deleting';
@@ -502,6 +609,14 @@ export function formatAudit(audit, options = {}) {
       ? `Would free ${formatBytes(audit.plannedBytes)} (run with --yes to delete)`
       : `Freed ${formatBytes(audit.freedBytes)}`
   );
+  lines.push(...incompleteScanLines(audit.incomplete));
+  const conditions = conditionsWarning(audit.blocked);
+  if (conditions) {
+    lines.push(
+      conditions,
+      ...conditionsSection(audit.blocked, options).slice(2)
+    );
+  }
   if (audit.file) {
     lines.push(`Audit log: ${audit.file}`);
   }

package/src/rules/apps.js

@@ -36,13 +36,14 @@ export const APP_RULES = [
   },
   {
     id: 'telegram-downloaded-media',
-    excludeNames: ['cache', 'cache-storage', 'short-cache'],
     ecosystem: 'apps',
     tier: 'moderate',
     description:
       'Telegram downloaded media: secret-chat media may not be recoverable',
+    // Only media Telegram downloads again from its cloud; `storage` holds
+    // the media database and `local-file-*` files the user sent.
     paths: [
-      `${telegramAccounts}/*`,
+      `${telegramAccounts}/telegram-cloud-*`,
       ...telegramDesktop.map((root) => `${root}/user_data/downloads`),
     ],
     busy: ['Telegram', 'telegram-desktop'],

package/src/rules/downloads.js

@@ -20,10 +20,12 @@ export const DOWNLOAD_RULES = [
     description:
       'Chromium app bundle clones left by exited browsers (an update makes them full copies)',
     // Chrome clones its bundle into the per-user `X` directory next to
-    // `$TMPDIR` at launch and removes the clone when it exits. A running
-    // browser maps the executables of its clone, so the open-file check
-    // keeps every clone in use: a browser name would block orphans forever.
+    // `$TMPDIR` at launch and removes the clone when it exits. A clone
+    // stays while any process runs its hard-linked main executable (see
+    // ../scanners/app-clones.js): a browser name would block orphans
+    // forever, and open files miss a browser started before the update.
     paths: ['{TMP}/../X/*.code_sign_clone/code_sign_clone.*'],
+    appClone: { installed: ['/Applications', '~/Applications'] },
     directoryOnly: true,
     minAge: 'stale',
     busy: [],

package/src/rules/other.js

@@ -12,7 +12,11 @@
  * otherwise each match is its own item. `minAge: 'stale'` only reports
  * matches untouched for the stale-age window, `minAge: 'inactive'` for the
  * project inactivity window. `git: true` refuses matches that are Git work
- * trees with uncommitted, unpushed, or stashed changes.
+ * trees with uncommitted, unpushed, or stashed changes. `git: 'clone'`
+ * matches only Git work trees with an https or ssh remote, and refuses them
+ * unless every worktree is clean and the remote still advertises every
+ * local commit. `registry: 'playwright'` keeps revisions that a Playwright
+ * package recorded in the registry's `.links` still launches.
  */
 
 export const OTHER_RULES = [
@@ -29,15 +33,10 @@ export const OTHER_RULES = [
     versionPattern: /^(?<family>[a-z_]+)-(?<version>\d+)$/,
     minAge: 'inactive',
     tier: 'safe',
-    busy: [
-      'playwright',
-      'playwright-mcp',
-      'chrome',
-      'chromium',
-      'headless_shell',
-      'firefox',
-      'webkit',
-    ],
+    registry: 'playwright',
+    // A running Playwright launches the revisions its package names, which
+    // the registry check keeps; a revision a browser runs from is open.
+    busy: [],
   },
   {
     id: 'playwright-go-drivers',
@@ -519,6 +518,23 @@ export const OTHER_RULES = [
     minAge: 'stale',
     busy: ['chrome', 'chromium', 'headless_shell'],
   },
+  {
+    id: 'tmp-playwright-browsers',
+    ecosystem: 'tmp',
+    scope: 'tmp',
+    description:
+      'Playwright browser installs and downloads in temporary directories',
+    paths: [
+      '{TMP}/playwright-download-*',
+      '{TMP}/ms-playwright',
+      '{TMP}/ms-playwright-*',
+      '{TMP}/*/ms-playwright',
+      '{TMP}/*/.cache/ms-playwright',
+      '{TMP}/*/Library/Caches/ms-playwright',
+    ],
+    minAge: 'stale',
+    busy: ['playwright', 'node', 'chrome', 'chromium', 'headless_shell'],
+  },
   {
     id: 'node-tmp-caches',
     ecosystem: 'tmp',
@@ -533,3 +549,33 @@ export const OTHER_RULES = [
     busy: ['node'],
   },
 ];
+
+/**
+ * Checkouts cloned into temporary directories by tools, tests and agents,
+ * checked after every named rule so a more specific rule claims its own
+ * paths first.
+ */
+export const TEMP_CLONE_RULES = [
+  {
+    id: 'temp-git-clones',
+    ecosystem: 'tmp',
+    scope: 'tmp',
+    description:
+      'Git clones in temporary directories whose commits all exist on a remote',
+    tier: 'safe',
+    paths: ['{TMP}/*', '{TMP}/*/*'],
+    directoryOnly: true,
+    minAge: 'stale',
+    git: 'clone',
+    busy: [
+      'git',
+      'claude',
+      'codex',
+      'opencode',
+      'agent',
+      'node',
+      'bun',
+      'cargo',
+    ],
+  },
+];

package/src/scan.js

@@ -377,13 +377,20 @@ async function scanEnvironmentScoped(
       block(item, env.scanPolicy.removalReason(target));
     }
   }
-  for (const message of env.accessErrors?.values() ?? []) {
+  for (const message of await accessErrorMessages(env)) {
     errors.push({ env: env.id, scanner: 'filesystem', message });
   }
   env.scanStatus = incomplete ? 'error' : 'complete';
   return items;
 }
 
+/** Report messages for paths the scan could not inspect. */
+function accessErrorMessages(env) {
+  return env.accessErrorMessages
+    ? env.accessErrorMessages()
+    : [...(env.accessErrors?.values() ?? [])];
+}
+
 async function attributeStorage(env, items) {
   if (env.writableLayer) {
     const usages = await env.usageMany([
@@ -516,6 +523,24 @@ export function filterItems(items, options, daemons = [], pathApi) {
   );
 }
 
+/**
+ * Items that share every block with an installed app (APFS clones): they
+ * free nothing, so they are not offered, but `du` counts them at full size.
+ */
+function sharedItems(items, options, pathApi) {
+  return filterItems(
+    items.filter((item) => item.sharedWith),
+    { ...options, minSizeBytes: 0 },
+    [],
+    pathApi
+  ).map((item) => ({
+    rule: item.rule,
+    path: item.path,
+    apparentBytes: item.apparentBytes,
+    sharedWith: item.sharedWith,
+  }));
+}
+
 function envDescriptor(env, depth, chain) {
   return {
     id: env.id,
@@ -530,13 +555,17 @@ function envDescriptor(env, depth, chain) {
   };
 }
 
-async function withDisk(env, descriptor) {
+async function withDisk(env, descriptor, options) {
   const target = env.platform === 'win32' ? env.currentHome : '/';
   const disk = await env.diskUsage(target).catch(() => null);
   return {
     ...descriptor,
     disk: disk ? { path: target, ...disk } : null,
-    swap: await readSwap(env),
+    swap: await readSwap(env, {
+      stateDir: options.cacheDir,
+      disk,
+      now: options.now?.(),
+    }),
   };
 }
 
@@ -661,18 +690,20 @@ async function scanScoped(input) {
     docker?.daemons ?? [],
     env.path
   );
+  const shared = sharedItems(hostItems, options, env.path);
   const environments = [envDescriptor(env, 0, [])];
   for (const inner of docker?.environments ?? []) {
     environments.push(inner);
   }
   environments[0] = await timed(env.timings, 'disk', () =>
-    withDisk(env, environments[0])
+    withDisk(env, environments[0], options)
   );
   environments[0].timings = env.timings.toJSON();
   const report = buildReport({
     options,
     env,
     items,
+    shared,
     environments,
     docker,
     errors,
@@ -703,6 +734,7 @@ export function buildReport({
   options,
   env,
   items,
+  shared = [],
   environments,
   docker,
   errors,
@@ -718,6 +750,7 @@ export function buildReport({
     options: reportOptions(options),
     environments,
     items,
+    shared,
     totals: tierTotals(items),
     docker: docker
       ? {