arkgate 4.8.13 → 4.8.15

package/bin/lib/html-report-depth.mjs

@@ -127,6 +127,8 @@ export function buildReportDepthPayload(
     selfHost:
       packageVersionTruth?.selfHost === true ||
       packageVersionTruth?.code === 'PACKAGE_PIN_SELF_HOST',
+    nativeFailClosed: writePath?.nativeFailClosed,
+    nativeFailClosedPolicy: writePath?.nativeFailClosedPolicy,
   });
   const classification = {
     governedPercent: coverage?.governed?.percent ?? null,

package/bin/lib/html-report.mjs

@@ -25,7 +25,7 @@ import { capabilityBadgesFor, renderAdvisorySections } from './html-report-advis
 import { renderEvolutionSection } from './html-report-evolution.mjs';
 import { arkGitignoreAppendDecision } from './ark-gitignore.mjs';
 import { captureGitSnapshot } from './report-snapshot-context.mjs';
-import { layerDescriptionCaption } from './layer-description.mjs';
+import { layerDescriptionCaption, layerGuidanceLine, layerOwners, layerTrustBoundary } from './layer-description.mjs';
 
 export { arkGitignoreAppendDecision, gitignoreCoversArkState, gitignoreHasArkNegationException } from './ark-gitignore.mjs';
 
@@ -423,8 +423,13 @@ export function renderBeginnerHtmlReport({ root, config, violations, ok, version
   const placementRows = layers
     .map((layer) => {
       const purpose = layerDescriptionCaption(layer) || 'See ark.config.json';
+      const guidance = layerGuidanceLine(layer);
+      const extra = guidance && guidance !== purpose ? guidance.slice(purpose.length).replace(/^ · /, '') : '';
+      const purposeCell = extra
+        ? `${esc(purpose)} <span class="tag">${esc(extra)}</span>`
+        : esc(purpose);
       const folders = (layer.patterns || []).join(', ') || '—';
-      return `<tr><td><strong>${esc(layer.name)}</strong></td><td>${esc(purpose)}</td><td><code>${esc(folders)}</code></td></tr>`;
+      return `<tr><td><strong>${esc(layer.name)}</strong></td><td>${purposeCell}</td><td><code>${esc(folders)}</code></td></tr>`;
     })
     .join('\n');
 
@@ -776,6 +781,12 @@ export function renderHtmlReport({
           ? `<span class="tag">${layer.intentPrefixes.map(esc).join(' ')}</span>`
           : '',
         layer.optional ? '<span class="tag dim-tag">optional</span>' : '',
+        layerTrustBoundary(layer)
+          ? `<span class="tag">trust: ${esc(layerTrustBoundary(layer))}</span>`
+          : '',
+        layerOwners(layer)
+          ? `<span class="tag">owner: ${esc(layerOwners(layer).map((id) => (id.includes('@') ? id : `@${id}`)).join(', '))}</span>`
+          : '',
       ].join(' ');
       const example = exampleByLayer?.get?.(layer.name);
       const files = counts.get(layer.name) || 0;

package/bin/lib/import-resolve.mjs

@@ -4,7 +4,46 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { layerForFile } from '../ark-layer-match.mjs';
+import {
+  layerForRelativePath,
+  matchingLayersForRelativePath,
+} from '../ark-layer-match.mjs';
+
+/**
+ * Same candidate list as ark-check `resolveSpecifier` (src/kernel/moduleGraph.ts).
+ * The write hook must feed `layerForRelativePath` a path with the extension
+ * ark-check already sees on disk — otherwise an explicit `money.ts` pattern
+ * loses to a broader `src/lib/**` bag.
+ */
+const SPECIFIER_SUFFIXES = Object.freeze([
+  '',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '/index.ts',
+  '/index.tsx',
+]);
+
+const SOURCE_EXT = /\.(?:[cm]?[jt]sx?)$/i;
+
+function posixRel(value) {
+  return String(value).split(/[/\\]/).join('/');
+}
+
+function specifierRelCandidates(rel) {
+  const base = posixRel(rel);
+  if (SOURCE_EXT.test(base)) return [base];
+  return SPECIFIER_SUFFIXES.map((suffix) => `${base}${suffix}`);
+}
+
+function isOnDiskFile(root, rel) {
+  try {
+    return fs.statSync(path.join(root, rel)).isFile();
+  } catch {
+    return false;
+  }
+}
 
 /**
  * Read tsconfig path aliases via the TypeScript config parser (JSONC + extends).
@@ -86,16 +125,38 @@ function filePathToRel(filePath, root) {
   return relative.split(path.sep).join('/');
 }
 
+/**
+ * Classify a specifier-relative path with the same specificity scorer as ark-check.
+ * Prefer an on-disk candidate; otherwise pick the candidate whose winning
+ * `layerForRelativePath` pattern scores highest (explicit file beats `src/lib/**`).
+ */
 function classifyProbe(root, rel, layers) {
-  let probe = rel;
-  try {
-    if (fs.statSync(path.join(root, rel)).isDirectory()) probe = `${rel}/index.ts`;
-  } catch {
-    /* not on disk */
+  const candidates = specifierRelCandidates(rel);
+  const existing = candidates.find((candidate) => isOnDiskFile(root, candidate));
+  if (existing) {
+    return {
+      relPath: existing,
+      layer: layerForRelativePath(existing, layers),
+      onDisk: true,
+    };
   }
-  return (
-    layerForFile(root, probe, layers) || layerForFile(root, `${rel}/index.ts`, layers)
-  );
+  let bestRel = posixRel(rel);
+  let bestLayer;
+  let bestScore = -1;
+  for (const candidate of candidates) {
+    const layer = layerForRelativePath(candidate, layers);
+    if (!layer) continue;
+    const hit = matchingLayersForRelativePath(candidate, layers).find(
+      (row) => row.layer === layer
+    );
+    const score = hit?.score ?? -1;
+    if (score > bestScore) {
+      bestScore = score;
+      bestLayer = layer;
+      bestRel = candidate;
+    }
+  }
+  return { relPath: bestRel, layer: bestLayer, onDisk: false };
 }
 
 /**
@@ -114,7 +175,7 @@ export function createImportTargetResolver(ts, root, config) {
     if (path.isAbsolute(specifierOrFilePath)) {
       const relPath = filePathToRel(specifierOrFilePath, root);
       if (!relPath) return undefined;
-      return { relPath, layer: classifyProbe(root, relPath, layers) };
+      return classifyProbe(root, relPath, layers);
     }
 
     // Relative or path-alias import
@@ -130,7 +191,7 @@ export function createImportTargetResolver(ts, root, config) {
         tsAliases
       );
       if (!rel) return undefined;
-      return { relPath: rel, layer: classifyProbe(root, rel, layers) };
+      return classifyProbe(root, rel, layers);
     }
 
     // Try as import alias / bare package first
@@ -141,13 +202,13 @@ export function createImportTargetResolver(ts, root, config) {
       tsAliases
     );
     if (asImport) {
-      return { relPath: asImport, layer: classifyProbe(root, asImport, layers) };
+      return classifyProbe(root, asImport, layers);
     }
 
     // Repo-relative source file path (not an import specifier)
     const asFile = filePathToRel(specifierOrFilePath, root);
     if (asFile) {
-      return { relPath: asFile, layer: classifyProbe(root, asFile, layers) };
+      return classifyProbe(root, asFile, layers);
     }
 
     return undefined;

package/bin/lib/improvement-compass-doctor.mjs

@@ -42,7 +42,12 @@ export function buildDoctorImprovementCompass(input = {}) {
     if (id.includes('PEER_ISOLATION')) peerIsolationCount += 1;
     if (id === 'CAPABILITY_VIOLATION') pureOrCapabilityResidual += 1;
     if (id === 'FORBIDDEN_GLOBAL' || id.startsWith('FORBIDDEN_')) forbiddenGlobalResidual += 1;
-    if (id.startsWith('ARKRULE_') || id === 'INVARIANT_UNCOVERED') arkRulesStructureResidual += 1;
+    if (
+      id.startsWith('ARKRULE_') ||
+      id === 'INVARIANT_UNCOVERED' ||
+      id === 'INVARIANT_CATALOG_EMPTY'
+    )
+      arkRulesStructureResidual += 1;
   }
 
   const pcFindings = input.physicalCohesion?.findings;

package/bin/lib/improvement-compass-map.mjs

@@ -260,7 +260,9 @@ function mapViolations(byId, violations) {
             });
             continue;
         }
-        if (upper.startsWith('ARKRULE_') || upper === 'INVARIANT_UNCOVERED') {
+        if (upper.startsWith('ARKRULE_') ||
+            upper === 'INVARIANT_UNCOVERED' ||
+            upper === 'INVARIANT_CATALOG_EMPTY') {
             attach('encapsulation', 'ArkRules structure / invariant residual inside a layer.', {
                 kind: 'skill',
                 ref: '/ark-autopilot',

package/bin/lib/install-migrate.mjs

@@ -37,6 +37,8 @@ import {
   hasCheckArchitectureScript,
   ensureTypecheckScript,
   compactRouterHost,
+  mergeArkMcpJson,
+  MCP_JSON_GATE_FILES,
   writeTemplate,
 } from './gate-files.mjs';
 import {
@@ -573,6 +575,27 @@ export function runInstallAgentGates(args) {
       // Upsert ark-write-gate without requiring --force; never wipe sibling named hooks.
       return writeTemplate(root, relativePath, merged, true);
     }
+    if (MCP_JSON_GATE_FILES.includes(relativePath)) {
+      const fullPath = path.join(root, relativePath);
+      let existing = '';
+      try {
+        existing = fs.readFileSync(fullPath, 'utf8');
+      } catch {
+        // Missing MCP JSON → write generated ark server.
+      }
+      if (!existing) {
+        return writeTemplate(root, relativePath, content, true);
+      }
+      const merged = mergeArkMcpJson(existing, content);
+      if (merged == null) {
+        return args.force
+          ? writeTemplate(root, relativePath, content, true)
+          : { relativePath, status: 'skipped-non-ark' };
+      }
+      if (merged === existing) return { relativePath, status: 'skipped' };
+      // Upsert mcpServers.ark without requiring --force; never wipe sibling servers.
+      return writeTemplate(root, relativePath, merged, true);
+    }
     return writeTemplate(
       root,
       relativePath,

package/bin/lib/layer-description.mjs

@@ -1,8 +1,12 @@
 /**
- * App-context caption from `layers[].description`.
+ * App-context caption, optional trust tag, and optional owners from layer metadata.
  * Metadata only — callers project it; policyHash strips it elsewhere.
- * Present non-empty string is returned; absence/empty/non-string is undefined.
- *
+ * Present values are returned; absence/empty/invalid is omitted.
+ */
+
+export const LAYER_TRUST_BOUNDARIES = Object.freeze(['public', 'auth', 'admin', 'internal']);
+
+/**
  * @param {{ description?: unknown } | null | undefined} layerOrPlacement
  * @returns {string | undefined}
  */
@@ -15,13 +19,91 @@ export function layerDescriptionCaption(layerOrPlacement) {
 }
 
 /**
- * Project the caption onto place / prepare-write / coverage / doctor JSON.
- * Absence omits the field (never empty string).
+ * @param {{ trustBoundary?: unknown } | null | undefined} layerOrPlacement
+ * @returns {'public' | 'auth' | 'admin' | 'internal' | undefined}
+ */
+export function layerTrustBoundary(layerOrPlacement) {
+  const tag =
+    layerOrPlacement && typeof layerOrPlacement === 'object'
+      ? layerOrPlacement.trustBoundary
+      : undefined;
+  return typeof tag === 'string' && LAYER_TRUST_BOUNDARIES.includes(tag) ? tag : undefined;
+}
+
+/**
+ * @param {{ owners?: unknown } | null | undefined} layerOrPlacement
+ * @returns {string[] | undefined}
+ */
+export function layerOwners(layerOrPlacement) {
+  const raw =
+    layerOrPlacement && typeof layerOrPlacement === 'object' ? layerOrPlacement.owners : undefined;
+  if (!Array.isArray(raw) || raw.length === 0) return undefined;
+  const ids = raw.filter((entry) => typeof entry === 'string' && entry.length > 0);
+  return ids.length > 0 ? ids : undefined;
+}
+
+function formatOwnerMention(id) {
+  return id.includes('@') ? id : `@${id}`;
+}
+
+/**
+ * One guidance fragment: caption and/or `trust: public` and/or `owner: @handle`.
+ * @param {{ description?: unknown, trustBoundary?: unknown, owners?: unknown } | null | undefined} layerOrPlacement
+ * @returns {string | undefined}
+ */
+export function layerGuidanceLine(layerOrPlacement) {
+  const caption = layerDescriptionCaption(layerOrPlacement);
+  const trust = layerTrustBoundary(layerOrPlacement);
+  const owners = layerOwners(layerOrPlacement);
+  const ownerBit = owners ? `owner: ${owners.map(formatOwnerMention).join(', ')}` : undefined;
+  const bits = [caption, trust ? `trust: ${trust}` : undefined, ownerBit].filter(Boolean);
+  return bits.length > 0 ? bits.join(' · ') : undefined;
+}
+
+/**
+ * Project caption + trust tag + owners onto place / prepare-write / coverage / doctor JSON.
+ * Absence omits the field (never empty string / empty array).
  *
- * @param {{ description?: unknown } | null | undefined} layerOrPlacement
- * @returns {{ description: string } | {}}
+ * @param {{ description?: unknown, trustBoundary?: unknown, owners?: unknown } | null | undefined} layerOrPlacement
+ * @returns {{ description?: string, trustBoundary?: string, owners?: string[] }}
  */
 export function placementDescriptionFields(layerOrPlacement) {
   const caption = layerDescriptionCaption(layerOrPlacement);
-  return caption ? { description: caption } : {};
+  const trust = layerTrustBoundary(layerOrPlacement);
+  const owners = layerOwners(layerOrPlacement);
+  return {
+    ...(caption ? { description: caption } : {}),
+    ...(trust ? { trustBoundary: trust } : {}),
+    ...(owners ? { owners } : {}),
+  };
+}
+
+/**
+ * Doctor residual when requireLayerOwners is on and a live house has no owners.
+ * Absent/false require → null (silent). Not a computeDoctorAdvisories key.
+ *
+ * @param {{ requireLayerOwners?: unknown, layers?: Array<{ name?: string, owners?: unknown, optional?: boolean, reserved?: boolean, allowEmpty?: boolean }> } | null | undefined} config
+ * @returns {{ required: true, missingLayers: string[], ask: string, nextAction: string } | null}
+ */
+export function collectLayerOwnerResidual(config) {
+  if (config?.requireLayerOwners !== true || !Array.isArray(config.layers)) return null;
+  const missing = config.layers
+    .filter(
+      (layer) =>
+        layer &&
+        layer.optional !== true &&
+        layer.reserved !== true &&
+        layer.allowEmpty !== true &&
+        !layerOwners(layer)
+    )
+    .map((layer) => layer.name)
+    .filter((name) => typeof name === 'string' && name.length > 0);
+  if (missing.length === 0) return null;
+  const named = missing[0];
+  return {
+    required: true,
+    missingLayers: missing,
+    ask: `${named} has no owner. Add a GitHub handle or email to layers[].owners.`,
+    nextAction: `Add a GitHub handle or email to ${named}'s owners in ark.config.json (/ark-adopt).`,
+  };
 }

package/bin/lib/mcp-hook-payload.mjs

@@ -308,13 +308,69 @@ export function emitHostAllow(output, { antigravityStyle, cursorStyle }) {
   emitCursorAllow(output, cursorStyle);
 }
 
+/** Host-native deny envelopes. Exit 2 is still set by the caller. */
+export function emitHostDeny(output, { antigravityStyle, cursorStyle, grokStyle, message, file }) {
+  const text = String(message || '').endsWith('\n') ? String(message) : `${message}\n`;
+  output.stderr(text);
+  if (antigravityStyle || grokStyle) {
+    output.stdout(`${JSON.stringify({ decision: 'deny', reason: String(message || '').trim() })}\n`);
+  }
+  if (cursorStyle) {
+    output.stdout(
+      JSON.stringify({
+        permission: 'deny',
+        agent_message: String(message || '').trim(),
+        user_message: `ArkGate blocked write to ${file || 'this file'}`,
+      }) + '\n'
+    );
+  }
+}
+
+/** File-local twin of CONFIG_UNCLASSIFIED_FILES — included, no layer, write must not land. */
+export function unclassifiedIncludedWriteDeny(relativePath) {
+  const file = String(relativePath || 'this file');
+  return {
+    ruleId: 'CONFIG_UNCLASSIFIED_FILES',
+    message: `${file} is included but matches no layer, so import rules will not run on it.`,
+    nextAction:
+      'Put it in a layer folder with /ark-place, or extend layer patterns / narrow include.',
+  };
+}
+
+/** File-local twin of CONFIG_LAYER_MISSING_OWNER — required owners, this house has none. */
+export function unownedLayerWriteDeny(relativePath, layerName) {
+  const file = String(relativePath || 'this file');
+  const house = String(layerName || 'this layer');
+  return {
+    ruleId: 'CONFIG_LAYER_MISSING_OWNER',
+    message: `${file} is in ${house}, and that folder has no owner.`,
+    nextAction: `Add a GitHub handle or email to ${house}'s owners in ark.config.json (/ark-adopt).`,
+  };
+}
+
+/**
+ * Fail-closed write when requireLayerOwners is on and this house has no owners.
+ * Silent when the flag is off, the layer is reserved, or owners are present.
+ */
+export function requiredOwnerWriteDeny(config, layerName, relativePath) {
+  if (config?.requireLayerOwners !== true || !layerName) return null;
+  const layer = (config.layers ?? []).find((entry) => entry?.name === layerName);
+  if (!layer) return null;
+  if (layer.optional === true || layer.reserved === true || layer.allowEmpty === true) return null;
+  const owners = Array.isArray(layer.owners)
+    ? layer.owners.filter((entry) => typeof entry === 'string' && entry.length > 0)
+    : [];
+  if (owners.length > 0) return null;
+  return unownedLayerWriteDeny(relativePath, layerName);
+}
+
 /**
  * Socket-style write-gate deny: two lines first. Pass/fail, no score.
  * Rule id stays on a following line, not the first sentence.
  */
 export function formatWriteGateDeny({ file, reason, ruleId, nextAction, extraLines = [] }) {
   const target = file || 'this write';
-  const why = String(reason || 'this change breaks the architecture layers').replace(/\s+/g, ' ').trim();
+  const why = String(reason || 'a bad import — the write doesn’t land').replace(/\s+/g, ' ').trim();
   const next =
     nextAction && /place|move|import|port/i.test(nextAction)
       ? nextAction

package/bin/lib/no-domain-frontend.mjs

@@ -0,0 +1,91 @@
+/**
+ * Soft no-Domain / all-logic-in-frontend residual (P2 §3 / Guiar).
+ * Tooling I/O. Never a gate fail.
+ *
+ * Projects facts doctor already has: empty Domain-role layer + presentation
+ * file share, or the existing `domain-logic-in-ui` smell. No second tree walk.
+ * Silent when there is no frontend, Domain already has files, or the bag is
+ * too thin to call “all logic in the UI.”
+ */
+
+import { isDomainRoleLayerName } from './arkrules-sensors.mjs';
+
+export const NO_DOMAIN_FRONTEND_ASK =
+  'Business rules live in the UI, and Domain is still empty.';
+
+export const NO_DOMAIN_FRONTEND_NEXT =
+  'Put one pure rule in a Domain file (/ark-place), then one small refactor with /ark-autopilot. Do not pile more rules in pages.';
+
+/** Presentation-role house by name. Align with design-smells presentation heuristic. */
+export function isPresentationRoleLayerName(name) {
+  return typeof name === 'string' && /presentation|ui|view|frontend/i.test(name);
+}
+
+function layerRows(input) {
+  return Array.isArray(input.coverage?.layers) ? input.coverage.layers : [];
+}
+
+function configLayers(input) {
+  return Array.isArray(input.config?.layers) ? input.config.layers : [];
+}
+
+function emptyLayerSet(input) {
+  return new Set(Array.isArray(input.coverage?.emptyLayers) ? input.coverage.emptyLayers : []);
+}
+
+function totalGovernedFiles(input) {
+  const governed = input.coverage?.governed?.totalFiles;
+  if (Number.isFinite(governed) && governed >= 0) return governed;
+  const total = input.coverage?.totalFiles;
+  return Number.isFinite(total) && total >= 0 ? total : 0;
+}
+
+function hasDomainLogicInUiSmell(designSmells) {
+  return (Array.isArray(designSmells) ? designSmells : []).some(
+    (smell) => smell && smell.id === 'domain-logic-in-ui'
+  );
+}
+
+/**
+ * Soft residual when Domain is declared but empty and the UI holds the rules.
+ * Never flips valid / goal.met.
+ *
+ * @param {{ config?: object, coverage?: object, designSmells?: object[] }} [input]
+ * @returns {{ kind: 'ui-logic' | 'presentation-bag', ask: string, nextAction: string, domainLayers: string[], presentationFiles: number } | null}
+ */
+export function collectNoDomainFrontendResidual(input = {}) {
+  const totalFiles = totalGovernedFiles(input);
+  if (totalFiles <= 0) return null;
+
+  const declared = configLayers(input);
+  const domainLayers = declared.filter((layer) =>
+    isDomainRoleLayerName(layer.name, layer.intentPrefixes ?? [])
+  );
+  if (domainLayers.length === 0) return null;
+
+  const rows = layerRows(input);
+  const empty = emptyLayerSet(input);
+  const domainEmpty = domainLayers.every((layer) => {
+    const row = rows.find((entry) => entry.name === layer.name);
+    const files = Number(row?.files) || 0;
+    return files === 0 || empty.has(layer.name);
+  });
+  if (!domainEmpty) return null;
+
+  const presentationFiles = rows
+    .filter((row) => isPresentationRoleLayerName(row.name))
+    .reduce((sum, row) => sum + (Number(row.files) || 0), 0);
+  if (presentationFiles <= 0) return null;
+
+  const uiLogic = hasDomainLogicInUiSmell(input.designSmells);
+  const presentationShare = presentationFiles / totalFiles;
+  if (!uiLogic && (presentationShare < 0.5 || presentationFiles < 3)) return null;
+
+  return {
+    kind: uiLogic ? 'ui-logic' : 'presentation-bag',
+    ask: NO_DOMAIN_FRONTEND_ASK,
+    nextAction: NO_DOMAIN_FRONTEND_NEXT,
+    domainLayers: domainLayers.map((layer) => layer.name),
+    presentationFiles,
+  };
+}

package/bin/lib/presets.mjs

@@ -670,8 +670,7 @@ export const ARCHITECTURE_PRESETS = {
           },
           {
             name: 'ApplicationOrchestration',
-            description:
-              'Use cases and services that coordinate the domain through ports. Next App Router API (`app/api/**`) and Pages API (`pages/api/**`) are orchestration shells, not UI.',
+            description: 'Use cases and services that coordinate the domain through ports.',
             patterns: [
               '**/application/**',
               '**/use-cases/**',
@@ -687,7 +686,7 @@ export const ARCHITECTURE_PRESETS = {
           {
             name: 'PresentationAdapters',
             description:
-              'Entrypoints — UI, framework app/pages dirs, controllers. Next `app/api` is Application, not this layer. Never bare lib/** (data clients are Persistence).',
+              'Entrypoints — UI, pages, controllers when present. Never bare lib/** (data clients are Persistence).',
             patterns: [
               '**/app/**',
               '**/pages/**',
@@ -760,7 +759,7 @@ export const ARCHITECTURE_PRESETS = {
           {
             name: 'ApplicationOrchestration',
             description:
-              'Server actions, features, Next API routes (`app/api/**` / `pages/api/**`), and non-UI lib orchestration (when present).',
+              'Server actions, features, and non-UI lib orchestration (when present).',
             patterns: [
               'src/features/**',
               'src/server/**',

package/bin/lib/product-copy.mjs

@@ -6,6 +6,25 @@
  * common software words. See docs/product-voice.md.
  */
 
+/** First-contact north star. Ordinary English. Spanish names once. */
+export const NORTH_STAR_ONE_LINE =
+  'Contener · Guiar · Ordenar — contain the write, guide the next step, order leftover mess.';
+
+/**
+ * Compact doctor / details — only when `arkRules` is on.
+ * Absence stays silent (unlike ArkOrder, which speaks when off).
+ */
+export const ARKRULES_ONE_BREATH =
+  'Layers stop a bad import. ArkRules is optional policies inside one folder.';
+
+/** Next step when the map is on and something still needs a human. */
+export const ARKRULES_FIRST_CONTACT_NEXT =
+  'Next: ark-check --rules-inventory — then /ark-adopt to write one rule, or /ark-autopilot to promote.';
+
+/** Next step when Domain has code but invariants[] is empty. */
+export const ARKRULES_EMPTY_CATALOG_NEXT =
+  'Next: add 1–2 short phrases to invariants[] in the Domain rules file, then ark-check --doctor.';
+
 /** Status-light leftover-design qualifier (was “design-weak”). */
 export const LEFTOVER_DESIGN_LABEL = 'leftover design work';