@geraldmaron/construct 1.1.1 → 1.2.0

package/lib/diagram-export.mjs

@@ -0,0 +1,192 @@
+/**
+ * lib/diagram-export.mjs — distribution diagram styling for publish exports.
+ *
+ * Publish path renders hand-drawn D2 (--sketch geometry) and Mermaid (handDrawn
+ * look, Caveat handwriting) in a monochrome ink palette — black/grey strokes,
+ * light surfaces, near-black text — for an Excalidraw-adjacent human aesthetic
+ * that stays consistent with the document brand. Color is reserved for explicit
+ * per-node emphasis in the source, not the default theme.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ICON_DIR = path.join(REPO_ROOT, 'templates', 'distribution', 'icons');
+
+// Monochrome diagram palette, mirroring the ink ramp in construct-brand.typ so
+// embedded diagrams and surrounding body share one design language.
+
+const MONO = {
+  ink: '#0a0c10',
+  inkBody: '#23272e',
+  muted: '#565c66',
+  faint: '#9499a2',
+  hairline: '#e3e4e8',
+  hairlineStrong: '#cdd0d6',
+  surface: '#fafafa',
+  surfaceAlt: '#f3f4f6',
+  paper: '#ffffff',
+};
+
+export const DISTRIBUTION_D2_THEME = '0';
+export const DISTRIBUTION_D2_PAD = '16';
+export const DISTRIBUTION_D2_SCALE = '0.72';
+export const DISTRIBUTION_D2_SKETCH = '1';
+export const DISTRIBUTION_D2_FONT_SIZE = '14';
+export const DISTRIBUTION_MERMAID_MIME = 'image/png';
+export const DISTRIBUTION_MERMAID_WIDTH = '480';
+export const DISTRIBUTION_MERMAID_SCALE = '1';
+export const DISTRIBUTION_FIGURE_MAX_WIDTH = '58%';
+
+// Handwritten font for Mermaid labels so its hand-drawn look matches D2 sketch
+// mode. Caveat ships bundled (templates/distribution/fonts/handwritten) and is
+// installed for the headless Chrome that mmdc drives; the fallbacks stay in the
+// handwriting register so a missing face never drops to a serif.
+
+const MERMAID_FONT = 'Caveat, Comic Sans MS, cursive';
+
+const MERMAID_INIT = `%%{init: {
+  'theme': 'base',
+  'look': 'handDrawn',
+  'fontFamily': '${MERMAID_FONT}',
+  'themeVariables': {
+    'fontFamily': '${MERMAID_FONT}',
+    'fontSize': '19px',
+    'primaryColor': '${MONO.surfaceAlt}',
+    'primaryTextColor': '${MONO.ink}',
+    'primaryBorderColor': '${MONO.ink}',
+    'lineColor': '${MONO.muted}',
+    'secondaryColor': '${MONO.paper}',
+    'secondaryTextColor': '${MONO.ink}',
+    'secondaryBorderColor': '${MONO.ink}',
+    'tertiaryColor': '${MONO.surface}',
+    'tertiaryTextColor': '${MONO.ink}',
+    'tertiaryBorderColor': '${MONO.hairlineStrong}',
+    'clusterBkg': '${MONO.surface}',
+    'clusterBorder': '${MONO.hairlineStrong}',
+    'edgeLabelBackground': '${MONO.paper}',
+    'titleColor': '${MONO.ink}',
+    'noteBkgColor': '${MONO.surface}',
+    'noteTextColor': '${MONO.inkBody}',
+    'noteBorderColor': '${MONO.hairlineStrong}',
+    'actorBkg': '${MONO.surfaceAlt}',
+    'actorBorder': '${MONO.ink}',
+    'actorTextColor': '${MONO.ink}',
+    'actorLineColor': '${MONO.hairlineStrong}',
+    'signalColor': '${MONO.inkBody}',
+    'signalTextColor': '${MONO.inkBody}',
+    'labelBoxBkgColor': '${MONO.surface}',
+    'labelBoxBorderColor': '${MONO.hairlineStrong}',
+    'labelTextColor': '${MONO.ink}',
+    'loopTextColor': '${MONO.inkBody}',
+    'activationBkgColor': '${MONO.hairline}',
+    'activationBorderColor': '${MONO.muted}'
+  }
+}}%%`;
+
+const CHROME_CANDIDATES = [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/usr/bin/google-chrome',
+  '/usr/bin/chromium',
+  '/usr/bin/chromium-browser',
+];
+
+export function resolvePuppeteerExecutable(env = process.env) {
+  if (env.PUPPETEER_EXECUTABLE_PATH) return env.PUPPETEER_EXECUTABLE_PATH;
+  for (const candidate of CHROME_CANDIDATES) {
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch {
+      /* skip */
+    }
+  }
+  return null;
+}
+
+export function injectMermaidBrandTheme(code) {
+  const body = String(code || '').trim();
+  if (!body) return body;
+  if (/%%\{init:/.test(body)) return body;
+  return `${MERMAID_INIT}\n${body}\n`;
+}
+
+// `icon: @name` in a d2 block resolves to the bundled monochrome Lucide icon at
+// templates/distribution/icons/name.svg, keeping source markdown portable while
+// d2 (which runs in a temp dir) still receives an absolute path it can read.
+
+export function resolveIconTokens(code) {
+  return String(code || '').replace(
+    /icon:\s*@([a-z0-9-]+)/gi,
+    (match, name) => {
+      const file = path.join(ICON_DIR, `${name}.svg`);
+      return fs.existsSync(file) ? `icon: ${file}` : match;
+    },
+  );
+}
+
+export function injectD2DistributionDefaults(code) {
+  const body = resolveIconTokens(String(code || '').trim());
+  if (!body) return body;
+  if (/CONSTRUCT_D2_DEFAULTS/.test(body)) return body;
+  return `**: {
+  style.font-size: ${DISTRIBUTION_D2_FONT_SIZE}
+  style.font-color: "${MONO.ink}"
+  style.stroke: "${MONO.ink}"
+  style.fill: "${MONO.surfaceAlt}"
+}
+(** -> **)[*]: {
+  style.stroke: "${MONO.muted}"
+  style.font-color: "${MONO.inkBody}"
+}
+
+${body}
+`;
+}
+
+export function preprocessMarkdownDiagrams(content) {
+  let out = String(content);
+  out = out.replace(/```mermaid\n([\s\S]*?)```/g, (_match, inner) => `\`\`\`mermaid\n${injectMermaidBrandTheme(inner)}\`\`\``);
+  out = out.replace(/```d2\n([\s\S]*?)```/g, (_match, inner) => `\`\`\`d2\n${injectD2DistributionDefaults(inner)}\`\`\``);
+  return out;
+}
+
+export function countDiagramFences(content) {
+  const matches = String(content || '').match(/```(?:d2|mermaid)\n/g);
+  return matches ? matches.length : 0;
+}
+
+export function buildDistributionDiagramEnv(baseEnv = process.env) {
+  const env = {
+    ...baseEnv,
+    CONSTRUCT_D2_THEME: DISTRIBUTION_D2_THEME,
+    CONSTRUCT_D2_PAD: DISTRIBUTION_D2_PAD,
+    CONSTRUCT_D2_SCALE: DISTRIBUTION_D2_SCALE,
+    CONSTRUCT_D2_SKETCH: DISTRIBUTION_D2_SKETCH,
+    CONSTRUCT_MERMAID_THEME: 'construct',
+    CONSTRUCT_MERMAID_MIME: DISTRIBUTION_MERMAID_MIME,
+    CONSTRUCT_MERMAID_WIDTH: DISTRIBUTION_MERMAID_WIDTH,
+    CONSTRUCT_MERMAID_SCALE: DISTRIBUTION_MERMAID_SCALE,
+  };
+  const chrome = resolvePuppeteerExecutable(baseEnv);
+  if (chrome) env.PUPPETEER_EXECUTABLE_PATH = chrome;
+  return env;
+}
+
+export function distributionDiagramDefaults() {
+  return {
+    d2Theme: 'neutral',
+    d2ThemeId: DISTRIBUTION_D2_THEME,
+    d2Sketch: true,
+    d2Scale: Number(DISTRIBUTION_D2_SCALE),
+    d2FontSize: Number(DISTRIBUTION_D2_FONT_SIZE),
+    figureMaxWidth: DISTRIBUTION_FIGURE_MAX_WIDTH,
+    mermaidLook: 'handDrawn',
+    mermaidTheme: 'construct',
+    mermaidWidth: Number(DISTRIBUTION_MERMAID_WIDTH),
+    mermaidScale: Number(DISTRIBUTION_MERMAID_SCALE),
+    accent: MONO.ink,
+  };
+}

package/lib/diagram.mjs

@@ -6,10 +6,9 @@
  *
  * Tool evaluation (2026-06), against: visual distinctiveness, reproducible
  * from code, headless Node/CI SVG+PNG render, theming, license:
- *   - D2 (terrastruct, MPL-2.0): single self-contained Go binary, distinctive
- *     sketch look plus first-class themes, headless `d2 in.d2 out.svg|png`,
- *     deterministic from a text file. Chosen as PRIMARY for visual
- *     distinctiveness and one-binary install.
+ *   - D2 (terrastruct, MPL-2.0): single self-contained Go binary, clean neutral
+ *     theme plus `--sketch` hand-drawn mode (publish distribution path), headless
+ *     `d2 in.d2 out.svg|png`, deterministic from a text file. Chosen as PRIMARY.
  *   - Graphviz `dot` (EPL-1.0): ubiquitous, almost always already present on
  *     CI images and dev machines, headless `dot -Tsvg|-Tpng`. Chosen as
  *     FALLBACK for reach when D2 is absent.
@@ -157,8 +156,11 @@ export function generateDiagram({ description = '', type = null, theme = null }
 
 function renderWithD2(binary, sourcePath, outPath, { format, theme }) {
   const args = [];
-  if (theme) {
-    const themeId = D2_THEMES[theme.toLowerCase()];
+  const themeName = theme?.toLowerCase();
+  if (themeName === 'sketch') {
+    args.push('--sketch');
+  } else if (themeName) {
+    const themeId = D2_THEMES[themeName];
     if (themeId != null) args.push('--theme', String(themeId));
   }
   args.push(sourcePath, outPath);
@@ -176,7 +178,6 @@ const D2_THEMES = {
   'colorblind-clear': 8,
   'vanilla-nitro-cola': 100,
   'orange-creamsicle': 101,
-  sketch: 200,
 };
 
 function renderWithDot(binary, sourcePath, outPath, { format }) {
@@ -193,7 +194,7 @@ installed, writes the diagram SOURCE plus an install hint and exits 0.
 Options:
   --type <t>     architecture (default) | flow | sequence | state | er | class
   --format <f>   svg (default) | png
-  --theme <name> D2 theme name (e.g. neutral, sketch, cool-classics)
+  --theme <name> D2 theme name (default: neutral; sketch enables --sketch hand-drawn)
   --out <path>   Output path (default: .cx/diagrams/<slug>-<ts>.<ext>)
   --source-only  Always write the source file; skip rendering
   -h, --help     Show this message
@@ -205,7 +206,7 @@ Renderers (detected at runtime, never bundled):
 Examples:
   construct diagram "web app: client -> api -> db"
   construct diagram "auth flow" --type flow
-  construct diagram "client -> api -> db" --format png --theme sketch
+  construct diagram "client -> api -> db" --format png --theme neutral
 `);
 }
 
@@ -245,7 +246,8 @@ export async function runDiagramCli(argv = [], { cwd = process.cwd() } = {}) {
     process.exit(1);
   }
 
-  const result = generateDiagram({ description: options.description, type: options.type, theme: options.theme });
+  const effectiveTheme = options.theme || 'neutral';
+  const result = generateDiagram({ description: options.description, type: options.type, theme: effectiveTheme });
   const renderer = options.sourceOnly ? null : locateRenderer();
 
   const slug = slugify(options.description);
@@ -283,7 +285,7 @@ export async function runDiagramCli(argv = [], { cwd = process.cwd() } = {}) {
 
   const outPath = `${baseName}.${options.format}`;
   const render = renderer.engine === 'd2'
-    ? renderWithD2(renderer.binary, sourcePath, outPath, { format: options.format, theme: options.theme })
+    ? renderWithD2(renderer.binary, sourcePath, outPath, { format: options.format, theme: effectiveTheme })
     : renderWithDot(renderer.binary, sourcePath, outPath, { format: options.format });
 
   if (render.status === 0 && existsSync(outPath)) {

package/lib/docs-verify.mjs

@@ -20,6 +20,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { statSync, readFileSync, existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { hasIntakeReference } from "./intake/traceability.mjs";
 import { ensureCxDir } from "./project-init-shared.mjs";
 
@@ -27,6 +28,7 @@ const args = process.argv.slice(2);
 const quickMode = args.includes("--quick");
 const fixMode = args.includes("--fix");
 const stagedMode = args.includes("--staged");
+const strictMode = args.includes("--strict") || process.env.CI === 'true';
 const cwdArg = args.find(arg => arg.startsWith("--cwd="));
 const cwd = cwdArg ? path.resolve(cwdArg.split("=")[1]) : process.cwd();
 
@@ -195,6 +197,17 @@ function checkContextHasProgress(contextPath) {
 // not every artifact necessarily comes from an intake packet — but the absence
 // is a flag for the operator to either stamp the provenance or declare it
 // intake-independent.
+function gitTrackedMdFiles(cwd, dir) {
+  if (!fs.existsSync(dir)) return [];
+  const rel = path.relative(cwd, dir).split(path.sep).join('/');
+  const result = spawnSync('git', ['ls-files', '--', `${rel}/`], { cwd, encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout) return [];
+  return result.stdout
+    .split('\n')
+    .filter((line) => line.endsWith('.md') && !line.endsWith('/README.md'))
+    .map((line) => path.join(cwd, line));
+}
+
 function checkIntakeTraceability(cwd) {
   const intakeFedDirs = [
     path.join(cwd, 'docs', 'prd'),
@@ -203,13 +216,10 @@ function checkIntakeTraceability(cwd) {
   ];
   let inspected = 0;
   for (const dir of intakeFedDirs) {
-    if (!fs.existsSync(dir)) continue;
-    let entries;
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
-      if (entry.name.startsWith('_') || entry.name.toLowerCase() === 'readme.md') continue;
-      const filePath = path.join(dir, entry.name);
+    const files = gitTrackedMdFiles(cwd, dir);
+    for (const filePath of files) {
+      const base = path.basename(filePath);
+      if (base.startsWith('_')) continue;
       inspected += 1;
       if (!hasIntakeReference(filePath)) {
         warnings.push(
@@ -438,6 +448,14 @@ function main() {
     console.log("💡 Run `construct init:update` to update project to current standards");
     process.exit(1);
   }
+
+  if (strictMode && warnings.length > 0) {
+    console.log("❌ Strict mode: warnings are blocking:");
+    for (const warning of warnings) {
+      console.log(`  • ${warning}`);
+    }
+    process.exit(1);
+  }
   
   console.log("✅ Documentation validation passed with warnings");
   process.exit(0);

package/lib/doctor/index.mjs

@@ -24,9 +24,11 @@ import * as bdWatch from './watchers/bd-watch.mjs';
 import * as handoffs from './watchers/handoffs.mjs';
 import * as consistency from './watchers/consistency.mjs';
 import * as mcpProtocol from './watchers/mcp-protocol.mjs';
+import * as cxBudget from './watchers/cx-budget.mjs';
+import * as graphStaleness from './watchers/graph-staleness.mjs';
 
 const STATE_PATH = join(homedir(), '.construct', 'doctor.json');
-const WATCHERS = [disk, cost, processPressure, serviceHealth, bdWatch, handoffs, consistency, mcpProtocol];
+const WATCHERS = [disk, cost, processPressure, serviceHealth, bdWatch, handoffs, consistency, mcpProtocol, cxBudget, graphStaleness];
 
 let running = false;
 let timers = [];

package/lib/doctor/project-adapters.mjs

@@ -0,0 +1,44 @@
+/**
+ * lib/doctor/project-adapters.mjs — doctor checks for project-scoped host adapters.
+ *
+ * When inside a Construct-managed project, verifies gitignored adapter artifacts
+ * exist for installed hosts (.cursor/mcp.json, .vscode/mcp.json, construct.mdc).
+ */
+
+import { checkProjectParity } from '../parity.mjs';
+import { detectHostCapabilities } from '../host-capabilities.mjs';
+
+const HOST_REQUIRES = {
+  cursor: ['cursor'],
+  vscode: ['vscode'],
+};
+
+export function checkProjectAdaptersForDoctor({ rootDir, projectDir = rootDir }) {
+  const parity = checkProjectParity({ rootDir, projectDir });
+  if (parity.skipped) return { ok: true, label: 'Project adapters (not a Construct project)', warning: false };
+
+  const installed = new Set(
+    detectHostCapabilities()
+      .filter((h) => h.availability === 'installed')
+      .map((h) => h.host.toLowerCase().replace(/\s+/g, '')),
+  );
+  const installedIds = new Set();
+  if (installed.has('claudecode') || installed.has('claude')) installedIds.add('claude');
+  if (installed.has('vscode')) installedIds.add('vscode');
+  if (installed.has('cursor')) installedIds.add('cursor');
+
+  const failures = [];
+  for (const surface of parity.surfaces) {
+    if (surface.status === 'absent' && (surface.surface === 'cursor' || surface.surface === 'vscode')) {
+      if (installedIds.has(surface.surface)) failures.push(surface);
+    }
+    if (surface.status === 'drift') failures.push(surface);
+  }
+
+  const ok = failures.length === 0;
+  const label = ok
+    ? `Project adapters (${parity.summary.filter((s) => s.includes(': ok')).length}/${parity.surfaces.length} ok)`
+    : `Project adapters missing or stale — run \`npm run adapters\` (${failures.map((f) => f.surface).join(', ')})`;
+
+  return { ok, label, warning: !ok, parity };
+}

package/lib/doctor/watchers/cx-budget.mjs

@@ -0,0 +1,98 @@
+/**
+ * lib/doctor/watchers/cx-budget.mjs — .cx/ disk budget maintenance.
+ *
+ * When project .cx/ usage crosses the configured cap, runs age/count prune.
+ * When still over cap after retention prune, emergency-reclaims oldest
+ * traces and worker logs (hard-reject categories only).
+ *
+ * Tick: 15 min.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { record } from '../audit.mjs';
+import { escalate } from '../escalate.mjs';
+import {
+  measureUsage,
+  planPrune,
+  executePrune,
+  planEmergencyReclaim,
+} from '../../resources/budget.mjs';
+
+export const name = 'cx-budget';
+export const intervalMs = 15 * 60 * 1000;
+
+function projectRoot() {
+  return process.env.CONSTRUCT_PROJECT_ROOT || process.cwd();
+}
+
+export async function tick() {
+  const actions = [];
+  const escalations = [];
+  const root = projectRoot();
+  const cxDir = join(root, '.cx');
+  if (!existsSync(cxDir)) {
+    return { actions, escalations, notes: [{ skipped: 'no .cx directory' }] };
+  }
+
+  const before = measureUsage(root, process.env);
+  if (before.totalCxUsageRatio <= 0.8) {
+    return { actions, escalations, notes: [{ usageRatio: before.totalCxUsageRatio }] };
+  }
+
+  const planned = planPrune(root, process.env);
+  let reclaimed = { removed: [], bytesFreed: 0 };
+  if (planned.length) {
+    reclaimed = executePrune(planned);
+    record({
+      kind: 'action',
+      watcher: name,
+      action: 'prune',
+      target: '.cx/',
+      summary: `retention prune removed ${reclaimed.removed.length} file(s), freed ${reclaimed.bytesFreed} bytes`,
+      context: { planned: planned.length, removed: reclaimed.removed.length },
+    });
+    actions.push({ type: 'prune', target: '.cx/', removed: reclaimed.removed.length });
+  }
+
+  const afterPrune = measureUsage(root, process.env);
+  if (afterPrune.totalCxUsageRatio > 1) {
+    const emergency = planEmergencyReclaim(root, 0, process.env);
+    if (emergency.length) {
+      const emergencyResult = executePrune(emergency);
+      record({
+        kind: 'action',
+        watcher: name,
+        action: 'emergency-reclaim',
+        target: '.cx/traces|.cx/runtime/worker',
+        summary: `emergency reclaim removed ${emergencyResult.removed.length} file(s), freed ${emergencyResult.bytesFreed} bytes`,
+        context: emergencyResult,
+      });
+      actions.push({ type: 'emergency-reclaim', removed: emergencyResult.removed.length });
+    }
+  }
+
+  const after = measureUsage(root, process.env);
+  if (after.totalCxUsageRatio > 1) {
+    const usedMb = Math.round(after.totalCxBytes / 1024 / 1024);
+    const capMb = Math.round(after.totalCxCap / 1024 / 1024);
+    const r = await escalate({
+      watcher: name,
+      eventType: 'service.down',
+      summary: `.cx/ still over cap after prune (${usedMb}MB / ${capMb}MB) — raise resources.disk.totalCxMaxMb or delete load-bearing state manually`,
+      context: { usageRatio: after.totalCxUsageRatio, usedMb, capMb },
+    });
+    escalations.push({ eventType: 'service.down', result: r });
+  }
+
+  return {
+    actions,
+    escalations,
+    notes: [{
+      usageBefore: before.totalCxUsageRatio,
+      usageAfter: after.totalCxUsageRatio,
+      bytesFreed: reclaimed.bytesFreed,
+    }],
+  };
+}

package/lib/doctor/watchers/graph-staleness.mjs

@@ -0,0 +1,52 @@
+/**
+ * lib/doctor/watchers/graph-staleness.mjs — dependency graph freshness watcher.
+ *
+ * Ticks every 30 minutes. When registry/contracts/workflow seeds changed since
+ * the last `construct graph build`, records an audit entry so doctor surfaces
+ * stale-graph drift without waiting for the next Oracle tick.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { record } from '../audit.mjs';
+import { checkGraphStaleness } from '../../graph/staleness.mjs';
+import { isConstructPackageRepo } from '../../host-disposition.mjs';
+
+export const name = 'graph-staleness';
+export const intervalMs = 30 * 60 * 1000;
+
+function projectRoot() {
+  return process.env.CONSTRUCT_PROJECT_ROOT || process.cwd();
+}
+
+export async function tick() {
+  const actions = [];
+  const escalations = [];
+  const root = projectRoot();
+  const graphDir = join(root, '.cx', 'graph');
+
+  if (!existsSync(graphDir) && !isConstructPackageRepo(root)) {
+    return { actions, escalations, notes: [{ skipped: 'no graph and not construct package repo' }] };
+  }
+
+  const state = checkGraphStaleness(root);
+  if (!state.present) {
+    return { actions, escalations, notes: [{ present: false }] };
+  }
+  if (!state.stale) {
+    return { actions, escalations, notes: [{ present: true, stale: false }] };
+  }
+
+  record({
+    kind: 'action',
+    watcher: name,
+    action: 'graph-stale',
+    target: '.cx/graph/',
+    summary: state.staleReason,
+    context: { storedHash: state.storedHash, currentHash: state.currentHash },
+  });
+  actions.push({ type: 'graph-stale', target: '.cx/graph/' });
+
+  return { actions, escalations, notes: [state] };
+}

package/lib/doctor/watchers/process-pressure.mjs

@@ -2,9 +2,10 @@
  * lib/doctor/watchers/process-pressure.mjs — continuous process pressure guard.
  *
  * Runs the runtime-pressure cleanup on a recurring tick so stale Construct
- * helpers don't accumulate between `construct dev` invocations. Any killed
- * process is recorded; if the same service-class has been killed >=2 times
- * in the last hour, escalates so cx-sre can investigate the underlying churn.
+ * helpers and leaked VHS demo-recorder processes don't accumulate between
+ * `construct dev` invocations. Any killed process is recorded; if the same
+ * service-class has been killed >=2 times in the last hour, escalation lets
+ * cx-sre investigate the underlying churn.
  *
  * Tick: 60s.
  */