@piercebarney/whs-eleventy 2026.9.8 → 2026.9.10

package/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // whs — the web house style's Eleventy + Netlify tooling.
 //
+//   whs status [--hook]                    standard-version drift, at a glance
 //   whs compliance [--strict]              codebase-vs-standard conformance sweep
 //   whs doctor [--live|--deploy-preflight] infrastructure drift check
 //   whs links                              built-output link / CSP / JSON-LD integrity
@@ -16,6 +17,7 @@ const path = require("node:path");
 const { spawnSync } = require("node:child_process");
 
 const COMMANDS = {
+  status: "status.js",
   compliance: "compliance.js",
   doctor: "doctor.js",
   links: "check-links.js",

package/lib/compliance.js

@@ -832,4 +832,11 @@ if (require.main === module) main();
 
 // CHECKS is exported for the "coverage" test — nothing else should read it as
 // data (call runCompliance() for results).
-module.exports = { runCompliance, summarize, changelogSlugs, changelogEntries, CHECKS };
+module.exports = {
+  runCompliance,
+  summarize,
+  changelogSlugs,
+  changelogEntries,
+  versionDrift,
+  CHECKS,
+};

package/lib/status.js

@@ -0,0 +1,108 @@
+// Standard-version drift, at a glance (core.md#compliance). The delta-only
+// slice of `whs compliance` — how far the project's pinned standard-version is
+// behind the standard, and which chapters that means re-checking — without the
+// full codebase sweep. Cheap enough to run on every Claude Code SessionStart.
+//
+//   whs status           print the version delta + the re-check rows
+//   whs status --hook     silent when current; one line when behind (for the
+//                         SessionStart hook — never non-zero, never noisy)
+//
+// Exit code is always 0: like `compliance` without --strict, drift is a
+// backlog signal, not a build break.
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+// `status` answers "is there a newer standard available on this machine?" — so
+// before the compliance module resolves its standard text, prefer the local
+// canonical checkout (the ~/.claude symlink the README keeps) when one exists
+// and nothing more specific was set. `whs compliance` still measures the
+// codebase against the tooling's own bundled snapshot; `status` measures the
+// pin against the freshest tree available, which is what a "you're behind"
+// nudge should reflect. Machines without the symlink (CI, a fresh clone) fall
+// back to the bundled snapshot unchanged.
+if (!process.env.WHS_STANDARD) {
+  const local = path.join(os.homedir(), ".claude", "standards", "web-house-style");
+  if (fs.existsSync(path.join(local, "core.md"))) process.env.WHS_STANDARD = local;
+}
+
+const { versionDrift } = require("./compliance.js");
+const { resolveStandard } = require("./_project.js");
+
+// Distinct CHANGELOG dates after the pin — the "N versions behind" count. The
+// standard versions by date, and several entries can share one date (one
+// release); this counts releases, not entries.
+function versionsBehind(pin) {
+  const std = resolveStandard();
+  if (!std || !pin) return 0;
+  try {
+    const changelog = fs.readFileSync(path.join(std, "CHANGELOG.md"), "utf8");
+    const dates = new Set();
+    for (const line of changelog.split("\n")) {
+      const m = line.match(/^##\s+([0-9]{4}-[0-9]{2}-[0-9]{2})\b/);
+      if (m && m[1] > pin) dates.add(m[1]);
+    }
+    return dates.size;
+  } catch {
+    return 0;
+  }
+}
+
+function main() {
+  const hook = process.argv.includes("--hook");
+  const { pin, current, rows } = versionDrift();
+
+  const unresolved =
+    rows.length === 1 && rows[0].startsWith("MANUAL: standard text not resolvable");
+  if (unresolved) {
+    if (!hook) console.log(rows[0]);
+    return;
+  }
+
+  if (!rows.length) {
+    if (!hook) {
+      console.log(
+        pin && current
+          ? `web house style: up to date (pinned ${pin}, standard at ${current})`
+          : "web house style: standard-version not pinned in CLAUDE.md",
+      );
+    }
+    return;
+  }
+
+  const breaking = rows.filter((r) => r.startsWith("BREAKING:")).length;
+  const versions = versionsBehind(pin);
+  const behind = `${versions} version${versions === 1 ? "" : "s"} behind`;
+  const recheck = `${rows.length} re-check${rows.length === 1 ? "" : "s"}${
+    breaking ? ` (${breaking} breaking)` : ""
+  }`;
+
+  if (hook) {
+    console.log(
+      `⚠ web house style: ${behind}, ${recheck} — pinned ${pin}, standard at ${current}. ` +
+        `Run /whs:upgrade to catch up.`,
+    );
+    return;
+  }
+
+  console.log(
+    `\nstandard-version: pinned ${pin}, standard at ${current} — ${behind}, ${recheck}\n`,
+  );
+  for (const row of rows) console.log(`  ${row}`);
+
+  const hasUpgrade = fs.existsSync(
+    path.join(process.cwd(), ".claude", "commands", "whs", "upgrade.md"),
+  );
+  console.log(
+    hasUpgrade
+      ? "\nRun /whs:upgrade in a Claude Code session to work this backlog.\n"
+      : "\nThis project predates /whs:upgrade. Copy .claude/commands/whs/upgrade.md,\n" +
+          ".claude/hooks/standard-drift.sh, and the settings.json SessionStart entry\n" +
+          "from templates/eleventy-netlify/ in the standard, then run /whs:upgrade.\n",
+  );
+}
+
+if (require.main === module) main();
+
+module.exports = { versionsBehind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piercebarney/whs-eleventy",
-  "version": "2026.9.8",
+  "version": "2026.9.10",
   "description": "The web house style's Eleventy + Netlify tooling — the compliance sweep, the infra doctor, the link/CSP integrity check, and the a11y scan, shared by every project on the stack.",
   "bin": {
     "whs": "cli.js"

package/standard/CHANGELOG.md

@@ -18,6 +18,50 @@ enforced, new *opt-in* chapters/capabilities, tooling-only changes — is
 
 ---
 
+## 2026-09-10 — a one-command standard-version catch-up, and drift that surfaces itself [non-breaking]
+
+Catching an adopted project up to a moved-on standard was a hand-written prompt
+every time. The detection existed (`whs compliance`'s severity-tagged
+`re-check #<slug>` rows) but was passive — nothing said "you're behind" unless
+someone ran it. `core.md#compliance` already expects the assistant to run
+compliance "whenever `standard-version:` is behind"; this makes the Eleventy
+stack actually do that, and adds the command that works the result. Non-breaking:
+a project compliant before is still compliant — this is an opt-in reporter, a
+session-start notice, and a new command; no requirement changes. Eleventy-only
+pilot, same stance as `/whs:build`; Phoenix/SvelteKit keep the by-hand path
+until they have a tooling package.
+
+### stacks/eleventy-netlify.md: compliance
+
+- Documented `whs status` (the drift row alone — pinned vs. current version,
+  versions behind, the `re-check` list — no codebase sweep) and its
+  `SessionStart` wiring in the `compliance` section's **Wiring** bullet. Added a
+  migration-section note: an already-adopted project that has only fallen behind
+  runs `/whs:upgrade`; one scaffolded before the command shipped copies three
+  files from the template first.
+
+### templates/eleventy-netlify
+
+- New `/whs:upgrade` command (`.claude/commands/whs/upgrade.md`) — reads the
+  CHANGELOG delta since the pin, bumps `@piercebarney/whs-eleventy`, works the
+  `compliance` backlog one `re-check` row at a time (delegating to the
+  `brand`/`content`/`layout`/`pack` stage agents where a slug is theirs), then
+  re-pins `standard-version`. Never deploys. Structured like `/whs:build`.
+- New `.claude/hooks/standard-drift.sh` + a `SessionStart` entry in
+  `.claude/settings.json` — runs `whs status --hook` at the top of every Claude
+  Code session; one line when the pin is behind, silent when current, never
+  blocks.
+- `package.json` gains a `status` script (`whs status`).
+- `CLAUDE.md` points at `/whs:upgrade` for the behind-the-standard case.
+
+### packages/whs-eleventy
+
+- New `whs status` subcommand (`lib/status.js`) — reuses `compliance.js`'s
+  `versionDrift()` (now exported) and reports the delta without running the
+  `CHECKS` sweep. `--hook` mode: one compact line when behind, nothing when
+  current, always exit 0. Registered in `cli.js`. Tests in `test/status.test.js`
+  plus a `versionDrift`-export assertion in `test/compliance.test.js`.
+
 ## 2026-09-08 — content-ops: reservation becomes a real opt-in, not a hardcoded default [non-breaking]
 
 Found while building `/whs:build`'s Content stage agent, which needs to know

package/standard/core.md

@@ -1,6 +1,6 @@
 # Web project house style — CORE (stack-agnostic)
 
-**Version:** 2026-09-08 · **Status:** active
+**Version:** 2026-09-10 · **Status:** active
 
 This is the stack-agnostic contract every web project follows, regardless of
 framework, host, or CSS system. It says **what** must be true, with concrete
@@ -1422,7 +1422,7 @@ governs it and follow that chapter — the slugs are the index (a `<script>` →
 - production-url: https://example.com
 - content-type: tool           # tool | article  (article => feeds)
 - publishing-rate: ~5 pages/week
-- standard-version: 2026-09-08  # recommended — enables standard-version drift tracking (#compliance)
+- standard-version: 2026-09-10  # recommended — enables standard-version drift tracking (#compliance)
 ```
 
 If the section is absent, the assistant's first action is to run the flow above