dsh-report-card 1.0.0 → 1.1.0

package/README.md

@@ -1,4 +1,4 @@
-# DSH Report Card
+# DSH Report Card
 
 An independent, **dynamic** benchmark for DeepSeek Harness plugins. It installs
 one plugin into a throwaway profile, boots the real harness with it, runs one
@@ -87,20 +87,26 @@ test fixture.
 
 ## Install
 
-The plugin ships as a bundle with metadata, `locale/en.json`, `locale/zh.json`
-and an icon. Install it from this directory with the plugin manager — it adds
+Published on npm as **`dsh-report-card@1.0.0`**. It ships as a bundle with
+metadata, `locale/en.json`, `locale/zh.json` and an icon. The plugin manager adds
 the dependency *and* enables the bundle in one step; removing it undoes both:
 
 ```
-plugin_manager install_bundle  target: "file:C:/path/to/dsh-report-card"
+plugin_manager install_bundle  target: "dsh-report-card@1.0.0"
 plugin_manager remove_bundle   target: "dsh-report-card"
 ```
 
-`install_bundle` is the sanctioned path because a bundle is composed through the
-profile's bundle list, not just `node_modules`. The bundle inserts one entry,
-`dsh-report-card`, which contributes one tool. It was installed this way on dsh
-0.2.2-rc.1 and appears in the profile's bundle list beside the existing plugins
-without touching them.
+or from a terminal:
+
+```powershell
+dsh plugin --profile web add dsh-report-card
+```
+
+For development from a checkout, pass a directory spec instead
+(`file:C:/path/to/dsh-report-card`). `install_bundle` is the sanctioned path
+because a bundle is composed through the profile's bundle list, not just
+`node_modules`; the bundle inserts one entry, `dsh-report-card`, which
+contributes one tool.
 
 ## Use
 
@@ -108,8 +114,12 @@ From a session (the tool is model-facing):
 
 ```
 report_card(pluginSpec: "dsh-trust-check@0.2.6", samples: 3)
+report_cards_recent(limit: 10)     # the last cards on disk, including automatic ones
 ```
 
+`report_card` measures on demand; `report_cards_recent` reads the card index so
+you can see what the background pass produced.
+
 From a terminal — the same code path, printable output:
 
 ```powershell
@@ -126,6 +136,48 @@ sample round (surface × 2, turn × 2) plus one discarded warm-up round. Pass
 `samples: 3` for a quick look and `samples: 8..10` when you need to resolve a
 few milliseconds.
 
+## Automatic measurement
+
+Since 1.1.0 the card is produced **after a plugin is installed**, without
+anyone asking. The plugin listens to the plugin manager's
+`plugin-manager/operation` event and watches the profile manifest, queues the
+new package, and measures it in the background — the same throwaway profile,
+three samples, one measurement at a time.
+
+```
+install a plugin
+      │  manager event (Plugins page, plugin_manager tool)
+      │  or profile package.json change (dsh plugin add)
+      ▼
+debounce 2.5 s → list installed third-party bundles → skip ones already carded
+      ▼
+queue → measure in a throwaway profile → save card under $DSH_HOME/report-cards
+      ▼
+report_cards_recent lists it
+```
+
+What it skips: shipped/optional/official bundles, bundles that failed to load,
+its own package, and any `name@version` that already has a card. What it does
+**not** do: measure plugins that were already installed before this version
+started, unless `autoBackfill` is on.
+
+Automatic cards take roughly 45 s each (three samples) and run serially; a
+manual `report_card` call queues behind a running automatic card so the two
+never compete for the machine.
+
+Config, in the profile patch (or the plugin's config in a preset):
+
+```yaml
+- id: dsh-report-card
+  config:
+    autoMeasure: true      # false turns the background behavior off
+    autoSamples: 3         # 3..10; steadier numbers cost more time
+    autoBackfill: false    # true: card already-installed plugins at startup
+    autoReportsDir: null   # default: <DSH_HOME>/report-cards
+```
+
+`DSH_REPORT_CARD_AUTO=0` disables it for one process without touching config.
+
 ## Reading a card
 
 ```
@@ -177,6 +229,7 @@ Tests:
 
 ```powershell
 node test/unit.test.mjs      # units, ~1 s
+node test/auto.test.mjs     # install trigger and queue, ~1 s
 node test/harness.test.mjs   # real boots against fixtures, ~80 s
 ```
 
@@ -227,6 +280,7 @@ check that was run against the packed artifact.
 | `harness/risk.mjs` | Static disclosure scan |
 | `harness/report.mjs` | Grades, digest, drift, card assembly |
 | `harness/render.mjs` | Markdown card |
+| `harness/auto.mjs` | Install trigger, eligibility, and the background measurement queue |
 | `harness/repeat.mjs` | Repeatability check for the harness itself |
 | `docs/` | An example card and the acceptance evidence |
 | `locale/`, `icon.svg`, `cordis.patch.yml` | Bundle metadata and its one insert row |

package/docs/example-card.md

@@ -1,4 +1,4 @@
-# Report card — @local/rc-fake-plugin@0.1.0
+# Report card — @local/rc-fake-plugin@0.1.0
 
 **Grade D** · graded boot +6.3 ms CPU · graded turn 0 ms · context +76 tok · risk D
 

package/docs/publishing.md

@@ -11,23 +11,24 @@ There are three publication surfaces, and they depend on each other in order:
 3. **Your own index (optional)** — a format-1 JSON document you host; users add
    it as an index source in Plugins → Discover.
 
-The rest of this file is the exact sequence for this package. Current state on
-this machine (checked 2026-11-10):
+The rest of this file is the exact sequence for this package. Release state
+(2026-11-10):
 
-| Check | Result |
+| Surface | State |
 |---|---|
-| `npm view dsh-report-card` | 404 — the name is free |
-| `npm whoami` | 401 — no npm credentials configured here; run `npm login` |
-| `git remote -v` | `github.com/tespio/dsh-report-card` (created for this release) |
-| `npm pack` | 24 files, 40.9 kB packed, 128.5 kB unpacked, probe included |
-| Install of the packed tarball in a throwaway profile | works; `report_card` registered, entry active, context tax +344 tok |
+| npm | `dsh-report-card@1.0.0` published (publisher `init3`), 25 files, 139 kB unpacked |
+| GitHub | <https://github.com/tespio/dsh-report-card>, tag `v1.0.0` |
+| Registry acceptance | `node harness/cli.mjs dsh-report-card@1.0.0 --samples 3` installs from npm, registers `report_card`, entry `active` |
+| Live profile | installed from the registry (`"dsh-report-card": "1.0.0"`), entry active |
+| Catalog | **pending** — add `data/plugins/tespio__dsh-report-card.yml` from [`catalog-entry.yml`](catalog-entry.yml) |
 
 ## 0. Create the repository
 
-The catalog entry points at a `https://github.com/owner/repo` URL, and the
-catalog's npm probe only maps a package whose own `repository` field points back
-at that repo. So the repo is not optional bookkeeping — it is the link between
-the catalog entry and the npm package.
+Already done for 1.0.0; kept as the initial-setup reference. The catalog entry
+points at a `https://github.com/owner/repo` URL, and the catalog's npm probe only
+maps a package whose own `repository` field points back at that repo. So the repo
+is not optional bookkeeping — it is the link between the catalog entry and the
+npm package.
 
 ```powershell
 cd dsh-report-card
@@ -56,7 +57,7 @@ catalog; the bundle keeps using the vector `icon.svg` for its in-app tile.
 ```powershell
 npm login                 # once per machine
 npm whoami                # must print your npm user name
-npm view dsh-report-card  # must still be 404 before the first publish
+npm view dsh-report-card  # 404 before the very first publish; already published as 1.0.0
 npm test                  # unit + end-to-end; prepublishOnly also runs the units
 npm publish --access public
 ```

package/harness/auto.mjs

@@ -0,0 +1,220 @@
+/**
+ * Automatic measurement of newly installed plugins.
+ *
+ * The trigger is the plugin manager's own event stream plus the profile
+ * manifest, so the card follows whatever path installed the bundle: the
+ * Plugins page, the `plugin_manager` tool, or a terminal `dsh plugin add`.
+ * Measurements run one at a time in the background; each is the same
+ * throwaway-profile measurement `report_card` performs, so nothing about the
+ * live profile is touched.
+ */
+import fs from 'node:fs'
+
+/** Bundles worth measuring: third-party, installed, readable, not our own. */
+export function eligibleBundles(bundles, { self = 'dsh-report-card' } = {}) {
+  return (bundles ?? []).filter((bundle) => bundle !== null
+    && typeof bundle === 'object'
+    && bundle.installed === true
+    && bundle.availability === 'profile'
+    && bundle.official !== true
+    && bundle.optional !== true
+    && bundle.error === undefined
+    && bundle.name !== self
+    && typeof bundle.version === 'string'
+    && bundle.version !== '')
+}
+
+/**
+ * The spec to measure for one installed bundle.
+ *
+ * Registry dependencies are pinned to the installed version, not to whatever
+ * range the profile saved. Local, link, and git sources are used verbatim,
+ * because that is the exact code the user installed.
+ */
+export function measureSpecOf(bundle) {
+  const source = typeof bundle?.source === 'string' ? bundle.source.trim() : ''
+  const local = /^(file:|link:|git\+|github:|https?:|\.{1,2}[\\/]|[A-Za-z]:[\\/])/.test(source)
+  if (source !== '' && local) return source
+  return `${bundle.name}@${bundle.version}`
+}
+
+/** Stable key for one measured package version. */
+export function bundleKey(bundle) {
+  return `${bundle?.name}@${bundle?.version}`
+}
+
+/**
+ * A serial queue with deduplication.
+ *
+ * @param options `{ measure, log }` — `measure(candidate)` resolves to a
+ *   generated report card; errors are contained and reported, never thrown
+ *   into the harness that scheduled them.
+ */
+export function createAutoQueue({ measure, log = () => {}, concurrency = 1 }) {
+  const pending = []
+  const known = new Set()
+  const results = []
+  let running = 0
+  let stopped = false
+
+  const pump = () => {
+    if (stopped) return
+    while (running < concurrency && pending.length > 0) {
+      const candidate = pending.shift()
+      running += 1
+      Promise.resolve()
+        .then(() => measure(candidate))
+        .then((card) => {
+          const entry = {
+            name: candidate.name,
+            version: candidate.version,
+            grade: card?.report?.grades?.overall ?? null,
+            digest: card?.report?.digest ?? null,
+            json: card?.paths?.json ?? null,
+            markdown: card?.paths?.markdown ?? null,
+          }
+          results.push(entry)
+          log(`measured ${bundleKey(candidate)} (grade ${entry.grade ?? '?'})`)
+        }, (error) => {
+          results.push({ name: candidate.name, version: candidate.version, error: String(error?.message ?? error) })
+          log(`failed ${bundleKey(candidate)}: ${String(error?.message ?? error)}`)
+        })
+        .finally(() => {
+          running -= 1
+          pump()
+        })
+    }
+  }
+
+  return {
+    /** Queue candidates not already queued or measured. Returns their keys. */
+    enqueue(candidates) {
+      const added = []
+      for (const candidate of candidates ?? []) {
+        const key = bundleKey(candidate)
+        if (known.has(key)) continue
+        known.add(key)
+        pending.push(candidate)
+        added.push(key)
+      }
+      if (added.length > 0) {
+        log(`queued ${added.join(', ')}`)
+        pump()
+      }
+      return added
+    },
+    /** Mark candidates as handled without measuring (startup baseline). */
+    markKnown(candidates) {
+      for (const candidate of candidates ?? []) known.add(bundleKey(candidate))
+    },
+    /** Whether this package version was queued or marked already. */
+    knows(bundle) {
+      return known.has(bundleKey(bundle))
+    },
+    stop() {
+      stopped = true
+      pending.length = 0
+    },
+    status() {
+      return { pending: pending.length, running, known: [...known], results: [...results] }
+    },
+  }
+}
+
+/**
+ * Start the automatic measurer.
+ *
+ * @param options `{ manager, reportsDir, samples, backfill, generate, log, initialDelayMs, debounceMs, profileDir }`
+ * @returns a handle with `sweep()`, `status()`, and `stop()`
+ */
+export function startAutoMeasurer({
+  manager,
+  reportsDir,
+  samples = 3,
+  backfill = false,
+  generate,
+  log = () => {},
+  initialDelayMs = 10_000,
+  debounceMs = 2500,
+  profileDir,
+  watch = true,
+}) {
+  const queue = createAutoQueue({
+    log,
+    measure: async (candidate) => {
+      const result = await generate({
+        spec: measureSpecOf(candidate),
+        samples,
+        save: true,
+        outDir: reportsDir,
+        log: () => {},
+      })
+      log(`card saved for ${bundleKey(candidate)}: ${result?.paths?.json ?? reportsDir}`)
+      return result
+    },
+  })
+
+  let initialised = false
+  let timer
+  let disposed = false
+  let watcher
+
+  const schedule = (delayMs = debounceMs) => {
+    if (disposed) return
+    if (timer !== undefined) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = undefined
+      sweep().catch((error) => log(`sweep failed: ${String(error?.message ?? error)}`))
+    }, delayMs)
+    if (typeof timer?.unref === 'function') timer.unref()
+  }
+
+  const sweep = async () => {
+    if (disposed) return
+    const bundles = eligibleBundles(await manager.listBundles())
+    if (!initialised) {
+      initialised = true
+      if (!backfill) {
+        // The first scan is the baseline: plugins that were already installed
+        // are not re-measured just because the harness restarted.
+        queue.markKnown(bundles)
+        log(`baseline: ${bundles.length} installed third-party bundle(s) known`)
+        return
+      }
+    }
+    const fresh = bundles.filter((bundle) => !queue.knows(bundle))
+    if (fresh.length > 0) queue.enqueue(fresh)
+  }
+
+  // A profile manifest change is the one signal both the manager and
+  // `dsh plugin add` produce; the manager's own events make it immediate.
+  if (watch && typeof profileDir === 'string' && profileDir !== '') {
+    try {
+      watcher = fs.watch(profileDir, { persistent: false }, (_event, filename) => {
+        if (filename !== null && filename !== 'package.json' && filename !== 'cordis.patch.yml') return
+        schedule()
+      })
+      watcher.on?.('error', () => {})
+    } catch (error) {
+      log(`manifest watch unavailable: ${String(error?.message ?? error)}`)
+    }
+  }
+
+  const initial = setTimeout(() => {
+    sweep().catch((error) => log(`initial sweep failed: ${String(error?.message ?? error)}`))
+  }, initialDelayMs)
+  if (typeof initial?.unref === 'function') initial.unref()
+
+  return {
+    sweep,
+    schedule,
+    status: () => queue.status(),
+    stop() {
+      disposed = true
+      clearTimeout(initial)
+      if (timer !== undefined) clearTimeout(timer)
+      watcher?.close?.()
+      queue.stop()
+    },
+  }
+}

package/index.js

@@ -1,21 +1,60 @@
 /**
  * DSH Report Card — an independent, dynamic quality benchmark for DSH plugins.
  *
- * The plugin contributes exactly one model-facing tool, `report_card`. The
- * measurement happens in disposable child processes: a fresh `DSH_HOME`, a
- * fresh profile copied from the shipped `headless` template, and a local
- * fixture endpoint instead of a real model. The plugin under test never runs
- * in this process, and never touches the profile that is serving you.
+ * The plugin contributes two tools and one background behavior:
  *
- * Every number the tool reports is wall-clock measured, not estimated from
- * source code, and every card stores its samples so a re-run can show drift.
+ *   report_card          measure a plugin in a throwaway profile, return a card
+ *   report_cards_recent  list the cards on disk, including automatic ones
+ *   auto-measure         after a plugin is installed, measure it in the
+ *                        background and save its card (configurable)
+ *
+ * The measurement always happens in disposable child processes: a fresh
+ * `DSH_HOME`, a fresh profile copied from the shipped `headless` template, and
+ * a local fixture endpoint instead of a real model. The plugin under test never
+ * runs in this process, and never touches the profile that is serving you.
  */
+import os from 'node:os'
+import path from 'node:path'
+import { startAutoMeasurer } from './harness/auto.mjs'
 import { generateReport } from './harness/generate.mjs'
+import { readIndex, resolveReportsDir } from './harness/store.mjs'
 
 export const name = 'dsh-report-card'
 
 export const inject = ['tools']
 
+/** Defaults for the automatic behavior; every field is overridable in config. */
+const DEFAULTS = {
+  autoMeasure: true,
+  autoSamples: 3,
+  autoBackfill: false,
+  autoReportsDir: null,
+}
+
+/** The tool description is the model's only contract; keep the cost visible. */
+const DESCRIPTION = [
+  'Benchmark one DSH plugin or bundle and return a report card: boot-time delta,',
+  'per-turn hook overhead, context tax (tokens the plugin adds to the assembled',
+  'prompt), capability surface, and static risk flags. It installs the plugin into',
+  'a throwaway profile with a fresh DSH_HOME and measures real harness processes,',
+  'so it takes roughly 60-90 seconds for the default five samples (pass samples: 3',
+  'for a quick look). Use it before installing an unknown plugin, or to compare a',
+  'plugin version against its previous card. The card is saved under ./report-cards',
+  'and is reproducible from the command it prints. Newly installed plugins are also',
+  'measured automatically in the background; report_cards_recent lists those cards.',
+].join(' ')
+
+/**
+ * Measurements are serialized: an automatic card and a requested card must not
+ * compete for the machine, or both numbers become noise.
+ */
+let measurementChain = Promise.resolve()
+function serialize(task) {
+  const run = measurementChain.then(task, task)
+  measurementChain = run.then(() => {}, () => {})
+  return run
+}
+
 /**
  * The directory relative specs resolve against.
  *
@@ -40,19 +79,8 @@ async function sessionCwd(ctx, exec) {
   return process.cwd()
 }
 
-/** The tool description is the model's only contract; keep the cost visible. */
-const DESCRIPTION = [
-  'Benchmark one DSH plugin or bundle and return a report card: boot-time delta,',
-  'per-turn hook overhead, context tax (tokens the plugin adds to the assembled',
-  'prompt), capability surface, and static risk flags. It installs the plugin into',
-  'a throwaway profile with a fresh DSH_HOME and measures real harness processes,',
-  'so it takes roughly 60-90 seconds for the default five samples (pass samples: 3',
-  'for a quick look). Use it before installing an unknown plugin, or to compare a',
-  'plugin version against its previous card. The card is saved under ./report-cards',
-  'and is reproducible from the command it prints.',
-].join(' ')
-
-export function apply(ctx) {
+/** Register `report_card`. */
+function registerReportCard(ctx) {
   ctx.effect(() => ctx.tools.register({
     name: 'report_card',
     description: DESCRIPTION,
@@ -90,7 +118,7 @@ export function apply(ctx) {
       // Clamp here too: a schema minimum is advisory on some tool pipelines,
       // and fewer than three samples cannot estimate the machine's noise.
       const samples = Math.min(10, Math.max(3, Math.trunc(args.samples ?? 5)))
-      const result = await generateReport({
+      const result = await serialize(() => generateReport({
         spec: args.pluginSpec,
         samples,
         task: args.task,
@@ -98,10 +126,114 @@ export function apply(ctx) {
         cwd,
         signal: exec?.signal,
         log: (line) => ctx.logger?.info?.(`report-card: ${line}`),
-      })
+      }))
       // The card already carries its saved paths, reproducer, and digest.
       return result.markdown
     },
   }))
 }
 
+/** Format the last cards for the model, newest first. */
+export function formatRecent(index, limit) {
+  const rows = [...(index?.reports ?? [])].slice(-limit).reverse()
+  if (rows.length === 0) {
+    return 'No report cards yet. Cards are written to ./report-cards (or the configured directory) and appear here after a measurement.'
+  }
+  const lines = [`${rows.length} most recent report card${rows.length === 1 ? '' : 's'}:`]
+  for (const row of rows) {
+    const boot = Number.isFinite(row.bootDeltaMs) ? `${Math.round(row.bootDeltaMs)} ms boot CPU` : 'no boot reading'
+    const context = Number.isFinite(row.contextDelta) ? `${Math.round(row.contextDelta)} tok context` : 'no context reading'
+    lines.push(`- ${row.subject} — grade ${row.grade}, ${boot}, ${context}, ${row.generatedAt}${row.json ? ` (${row.json})` : ''}`)
+  }
+  return lines.join('\n')
+}
+
+/** Register `report_cards_recent`. */
+function registerRecentTool(ctx, reportsDirFor) {
+  ctx.effect(() => ctx.tools.register({
+    name: 'report_cards_recent',
+    description: 'List the most recent DSH report cards on disk, including cards produced automatically after a plugin was installed. Returns one line per card: subject, grade, boot and context deltas, time, and the JSON path.',
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 50,
+          description: 'how many cards to list, newest first (default 10)',
+        },
+      },
+      additionalProperties: false,
+    },
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: value }],
+    },
+    execute(args) {
+      const limit = Math.min(50, Math.max(1, Math.trunc(args.limit ?? 10)))
+      return formatRecent(readIndex(reportsDirFor()), limit)
+    },
+  }))
+}
+
+/** Start automatic measurement of newly installed plugins. */
+function startAuto(ctx, settings, configuredDir) {
+  const log = (line) => ctx.logger?.info?.(`report-card auto: ${line}`)
+  ctx.inject(['pluginManager'], (sub) => {
+    const samples = Math.min(10, Math.max(3, Math.trunc(Number(settings.autoSamples) || 3)))
+    const manager = sub.pluginManager
+    const profileDir = typeof manager?.profile?.dir === 'string' ? manager.profile.dir : process.env.DSH_PROFILE_DIR
+    const reportsDir = configuredDir ?? dirFromProfile(profileDir)
+    const instrument = startAutoMeasurer({
+      manager,
+      reportsDir,
+      samples,
+      backfill: settings.autoBackfill === true,
+      profileDir,
+      generate: (options) => serialize(() => generateReport(options)),
+      log,
+    })
+    sub.effect(() => () => instrument.stop())
+    sub.on('plugin-manager/operation', (operation) => {
+      if (operation?.reason !== 'install' || operation?.phase !== 'settled') return
+      if (operation.application === 'failed' || operation.application === 'cancelled') return
+      instrument.schedule()
+    })
+    sub.on('plugin-manager/changed', () => instrument.schedule())
+  })
+}
+
+/** Where automatic cards live: the harness home, never the profile directory. */
+function dirFromProfile(profileDir) {
+  if (typeof process.env.DSH_HOME === 'string' && process.env.DSH_HOME !== '') {
+    return path.join(process.env.DSH_HOME, 'report-cards')
+  }
+  if (typeof profileDir === 'string' && profileDir !== '') {
+    // <home>/profiles/<name> -> <home>
+    return path.resolve(profileDir, '..', '..', 'report-cards')
+  }
+  return path.join(os.homedir(), 'report-cards')
+}
+
+/** Resolve the reports directory for the session tools, preferring the manager's profile. */
+function reportsDirFor(ctx, configured) {
+  if (configured !== undefined && configured !== null) return configured
+  try {
+    const manager = typeof ctx.reflect?.get === 'function' ? ctx.reflect.get('pluginManager') : undefined
+    if (typeof manager?.profile?.dir === 'string') return dirFromProfile(manager.profile.dir)
+  } catch {
+    // fall through to the environment
+  }
+  return dirFromProfile(process.env.DSH_PROFILE_DIR)
+}
+
+export function apply(ctx, config = {}) {
+  const settings = { ...DEFAULTS, ...(config ?? {}) }
+  const configuredDir = settings.autoReportsDir ?? undefined
+  registerReportCard(ctx)
+  registerRecentTool(ctx, () => reportsDirFor(ctx, configuredDir))
+  const disabled = settings.autoMeasure === false || process.env.DSH_REPORT_CARD_AUTO === '0'
+  if (!disabled) startAuto(ctx, settings, configuredDir)
+}
+
+export { resolveReportsDir }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-report-card",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "description": "Independent dynamic benchmark for DSH plugins: boot delta, per-turn hook overhead, context tax, capability surface and risk flags, measured in a throwaway profile.",
   "keywords": [
@@ -43,9 +43,9 @@
     "dsh": ">=0.2.2-rc.1 <0.3.0"
   },
   "scripts": {
-    "test": "node test/unit.test.mjs && node test/harness.test.mjs",
+    "test": "node test/unit.test.mjs && node test/auto.test.mjs && node test/harness.test.mjs",
     "card": "node harness/cli.mjs",
-    "prepublishOnly": "node test/unit.test.mjs"
+    "prepublishOnly": "node test/unit.test.mjs && node test/auto.test.mjs"
   },
   "dsh": {
     "manifestVersion": 1,