arkgate 4.8.13 → 4.8.15

package/bin/lib/architecture-scan.mjs

@@ -17,6 +17,7 @@ import {
   loadInvariantCoverageInputs,
 } from './invariant-coverage-io.mjs';
 import { loadArkRuleFileHints } from './arkrule-file-hints.mjs';
+import { collectGovernedFiles } from './scan-files.mjs';
 
 const HINT_CACHE_CAP = 16;
 /** Process-local hint map keyed by scoped path + content hash. Not a second engine. */
@@ -40,15 +41,34 @@ function normalizeScanRelPath(root, filePath) {
   return relative;
 }
 
-/** Empty / missing `files` stays unbounded (full governed set). */
-function fileLocalScope(root, files) {
+/**
+ * Empty / missing `files` stays unbounded (full governed set).
+ * A complete governed list is also unbounded — doctor and check always pass
+ * that list, and treating it as `--changed` paid import-closure + a second
+ * `resolveModuleName` pass on every full-tree run (#212).
+ */
+function fileLocalScope(root, files, config, { changed = false } = {}) {
   if (!Array.isArray(files) || files.length === 0) return null;
   const scoped = new Set();
   for (const file of files) {
     const rel = normalizeScanRelPath(root, file);
     if (rel) scoped.add(rel);
   }
-  return scoped.size > 0 ? scoped : null;
+  if (scoped.size === 0) return null;
+  // `--changed` is already a bounded envelope — do not re-walk the include tree (#205).
+  if (!changed && config && coversGovernedSet(root, scoped, config)) return null;
+  return scoped;
+}
+
+function coversGovernedSet(root, scoped, config) {
+  const governed = collectGovernedFiles(root, config);
+  if (governed.length === 0) return false;
+  if (scoped.size < governed.length) return false;
+  for (const absolute of governed) {
+    const rel = normalizeScanRelPath(root, absolute);
+    if (rel && !scoped.has(rel)) return false;
+  }
+  return true;
 }
 
 function filterHintPreload(fileContents, scoped) {
@@ -126,12 +146,20 @@ export function resolveArchitectureSnapshot({
     { ...config, rules: rules ?? config.rules },
     manifest
   );
+  const scoped = fileLocalScope(root, files, effectiveConfig, {
+    changed: args?.changed === true,
+  });
   const facts = resolveCandidateFacts({
     root,
     config: effectiveConfig,
     ts,
     ...(args?.tsconfig ? { tsconfig: args.tsconfig } : {}),
     observeInput,
+    ...(scoped
+      ? { scopeFiles: [...scoped] }
+      : args?.changed
+        ? { scopeFiles: [] }
+        : {}),
   });
   const arkRulesLoad = loadEffectiveArkRulesFromDisk(root, effectiveConfig, {
     observeInput,
@@ -145,7 +173,6 @@ export function resolveArchitectureSnapshot({
     err.issues = arkRulesLoad.errors;
     throw err;
   }
-  const scoped = fileLocalScope(root, files);
   const loadedContract = loadContract(effectiveConfig, configPath, {
     arkRules: arkRulesLoad.arkRules,
   });
@@ -162,7 +189,8 @@ export function resolveArchitectureSnapshot({
         ...coverageOptionsFromConfig(effectiveConfig),
       })
     : undefined;
-  // File-local structure sensors + hint load honor `files`; graph still uses full facts.
+  // File-local sensors honor the touched set. Facts (and graph) use that set plus
+  // its import closure — not the whole include tree. Unbounded `files` stays full-tree.
   const fileHints = loadHintsForScope(
     root,
     facts,

package/bin/lib/ark-order-doctor.mjs

@@ -12,6 +12,8 @@ import { composeMergePlanesHonesty, extraMergeTeethAllowed, isArkOrderRuleId, }
 export const ARK_ORDER_DOCTOR_SCHEMA_VERSION = '1.0';
 const RESIDUAL_RULE_CAP = 12;
 export const ARKORDER_ONE_BREATH = 'Layers stop a bad import. ArkOrder stops rewriting a big product choice — like the billing plan — as if it were a seat count. Change those choices through a valve, not a generic update.';
+/** First-contact next step. Reuses the billing gallery + existing doors. */
+export const ARKORDER_FIRST_CONTACT_NEXT = 'Next: examples/arkorder-billing, then /ark-adopt to turn the extra on and /ark-order to wire one candidate.';
 function closedMode(value) {
     return value === 'enforced' || value === 'advisory' ? value : null;
 }
@@ -129,7 +131,11 @@ export function formatArkOrderDoctorLines(section) {
     if (!section || section.notAScore !== true)
         return [];
     if (section.active !== true) {
-        return ['ArkOrder extra is off — silent on Layers (not a score).'];
+        return [
+            ARKORDER_ONE_BREATH,
+            'Off — Layers stay the same (not a score).',
+            ARKORDER_FIRST_CONTACT_NEXT,
+        ];
     }
     const mode = section.mode ?? 'unknown';
     const teeth = section.extraMergeTeeth === true ? 'armed' : 'not armed';

package/bin/lib/ark-order-report.mjs

@@ -1,7 +1,7 @@
 /**
  * HTML for the doctor ArkOrder advisory (report parity: data-advisory="arkOrder").
  */
-import { ARKORDER_ONE_BREATH } from './ark-order-doctor.mjs';
+import { ARKORDER_FIRST_CONTACT_NEXT, ARKORDER_ONE_BREATH } from './ark-order-doctor.mjs';
 
 export function formatArkOrderHtml(section, esc) {
   if (!section || typeof section !== 'object' || section.notAScore !== true) return '';
@@ -14,6 +14,7 @@ export function formatArkOrderHtml(section, esc) {
     <p class="dim" style="margin:.15rem 0 .55rem;font-size:.88rem">
       ${ARKORDER_ONE_BREATH}
       Off until you turn it on — Layers stay the same.
+      ${ARKORDER_FIRST_CONTACT_NEXT}
     </p>
     ${note}
   </section>`;

package/bin/lib/ark-run-doctor.mjs

@@ -11,6 +11,10 @@
 import { composeMergePlanesHonesty, extraMergeTeethAllowed, isArkRunRuleId, } from './extra-merge-teeth.mjs';
 export const ARK_RUN_DOCTOR_SCHEMA_VERSION = '1.0';
 const RESIDUAL_RULE_CAP = 12;
+/** Compact / details — only when `arkRun` is on. Absence stays silent. */
+export const ARKRUN_ONE_BREATH = 'Layers stop a bad import. ArkRun is an optional experimental runtime — in-memory, not Postgres. Data is gone on restart.';
+/** Next step when the extra is on and residual remains. */
+export const ARKRUN_FIRST_CONTACT_NEXT = 'Next: /ark-runtime to wire one candidate.';
 function closedMode(value) {
     return value === 'enforced' || value === 'advisory' ? value : null;
 }
@@ -126,6 +130,7 @@ export function formatArkRunDoctorLines(section) {
     const mode = section.mode ?? 'unknown';
     const teeth = section.extraMergeTeeth === true ? 'armed' : 'not armed';
     const lines = [
+        ARKRUN_ONE_BREATH,
         `mode: ${mode} · extra merge teeth ${teeth} · not a score`,
     ];
     if (section.residual.count > 0) {
@@ -134,6 +139,7 @@ export function formatArkRunDoctorLines(section) {
             ? ` (+${section.residual.count - section.residual.ruleIds.length} more)`
             : '';
         lines.push(`Residual: ${shown}${more}`);
+        lines.push(ARKRUN_FIRST_CONTACT_NEXT);
     }
     else {
         lines.push('Residual: none on this scan (not a score — green extras ≠ finished kernel wiring).');

package/bin/lib/ark-run-report.mjs

@@ -1,6 +1,8 @@
 /**
  * HTML for the doctor ArkRun advisory (report parity: data-advisory="arkRun").
  */
+import { ARKRUN_FIRST_CONTACT_NEXT, ARKRUN_ONE_BREATH } from './ark-run-doctor.mjs';
+
 export function formatArkRunHtml(section, esc) {
   if (!section || typeof section !== 'object' || section.notAScore !== true) return '';
   const escape = typeof esc === 'function' ? esc : (v) => String(v);
@@ -17,6 +19,7 @@ export function formatArkRunHtml(section, esc) {
   }
   const residual = section.residual && typeof section.residual === 'object' ? section.residual : { count: 0, ruleIds: [] };
   const ids = Array.isArray(residual.ruleIds) ? residual.ruleIds : [];
+  const next = residual.count > 0 ? ` ${ARKRUN_FIRST_CONTACT_NEXT}` : '';
   const residualHtml =
     residual.count > 0
       ? `<p><span class="tag warn">residual</span> ${ids
@@ -40,8 +43,9 @@ export function formatArkRunHtml(section, esc) {
   <section class="section card" data-advisory="arkRun">
     <h2>ArkRun <span class="muted">(not a score)</span></h2>
     <p class="dim" style="margin:.15rem 0 .55rem;font-size:.88rem">
-      <b>[ArkRun]</b> Kernel usage + declarations — separate from <b>[Layer]</b> imports and <b>[ArkRules]</b> shape.
-      Advisory never flips <code>valid</code>. Enforced extra teeth only when the layer plane is classified.
+      <b>[ArkRun]</b> ${ARKRUN_ONE_BREATH}
+      Kernel usage + declarations — separate from <b>[Layer]</b> imports and <b>[ArkRules]</b> shape.
+      Advisory never flips <code>valid</code>. Enforced extra teeth only when the layer plane is classified.${next}
     </p>
     ${merge}
     <div class="kpis" style="margin-bottom:.55rem">

package/bin/lib/arkrules-sensors.mjs

@@ -378,6 +378,87 @@ export function collectEmptyAppliesToFindings(arkRules, files) {
         a.arkruleId.localeCompare(b.arkruleId) ||
         a.message.localeCompare(b.message));
 }
+/** Intent prefixes are short tokens (`Domain.`, `Application.`). Bound the scan. */
+const INTENT_PREFIX_SCAN_LIMIT = 64;
+/**
+ * Strip trailing `.` without a regex. `\.+$` on config strings is CodeQL
+ * js/polynomial-redos (backtracking on long runs of `.`). Linear walk is enough.
+ */
+function stripTrailingDots(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 46) {
+        end -= 1;
+    }
+    return end === value.length ? value : value.slice(0, end);
+}
+function normalizeIntentPrefix(prefix) {
+    const trimmed = prefix.trim();
+    const bounded = trimmed.length > INTENT_PREFIX_SCAN_LIMIT
+        ? trimmed.slice(0, INTENT_PREFIX_SCAN_LIMIT)
+        : trimmed;
+    return stripTrailingDots(bounded);
+}
+function layerNameLooksDomain(layer) {
+    const lower = layer.toLowerCase();
+    return (lower.includes('domain') ||
+        lower.includes('entity') ||
+        lower.includes('aggregate') ||
+        lower.includes('model'));
+}
+function ownsDomainIntent(intentPrefixes) {
+    return intentPrefixes.some((prefix) => {
+        const normalized = normalizeIntentPrefix(prefix);
+        return normalized === 'Domain' || normalized.startsWith('Domain.');
+    });
+}
+/** Domain-role house: name or intentPrefixes. Keep aligned with rulesInventory. */
+export function isDomainRoleLayerName(layer, intentPrefixes = []) {
+    return layerNameLooksDomain(layer) || ownsDomainIntent(intentPrefixes);
+}
+/**
+ * §2 catalog residual — ArkRules is on, Domain has code, invariants[] is empty.
+ * Advisory by default. failsStrict only when a domain structure rule is already
+ * enforced (the project opted into ArkRules merge teeth). Not freezable.
+ */
+export function collectEmptyInvariantCatalogFindings(input) {
+    if (input.arkRulesActive !== true)
+        return [];
+    const domainLayers = (input.layers ?? [])
+        .filter((layer) => isDomainRoleLayerName(layer.name, layer.intentPrefixes ?? []))
+        .map((layer) => layer.name);
+    if (domainLayers.length === 0)
+        return [];
+    const domainSet = new Set(domainLayers);
+    const domainPopulated = (input.files ?? []).some((file) => {
+        const layer = typeof file.layer === 'string' ? file.layer : '';
+        return layer.length > 0 && domainSet.has(layer);
+    });
+    if (!domainPopulated)
+        return [];
+    const domainInvariants = (input.arkRules.invariants ?? []).filter((inv) => domainSet.has(inv.provenance.layer));
+    if (domainInvariants.length > 0)
+        return [];
+    const fillLayer = domainLayers.find((name) => input.arkRules.byLayer?.[name]) ?? domainLayers[0];
+    const fillPath = input.arkRules.byLayer?.[fillLayer]?.sourceFile ?? `arkrules/${fillLayer}.json`;
+    const optedIntoTeeth = (input.arkRules.structure ?? []).some((rule) => rule.mode === 'enforced' &&
+        domainSet.has(rule.provenance.layer) &&
+        !isTier2(rule.sensor));
+    return [
+        {
+            ruleId: 'INVARIANT_CATALOG_EMPTY',
+            code: 'invariant-catalog-empty',
+            message: `ArkRules is on and ${fillLayer} has code, but invariants[] is empty — there are no phrases the code must preserve. Add 1–2 short phrases in ${fillPath}.`,
+            file: fillPath,
+            line: 1,
+            fromLayer: fillLayer,
+            arkruleId: 'invariant-catalog',
+            arkruleSource: fillPath,
+            severity: optedIntoTeeth ? 'error' : 'warning',
+            sensor: 'invariant-coverage',
+            failsStrict: optedIntoTeeth,
+        },
+    ];
+}
 /** IO / ORM import evidence. postgres and drizzle-orm include package subpaths. Keep in lockstep with arkOrderFacts. */
 const IO_IMPORT_HINT_RE = /\bfrom\s+['"](?:@?prisma\/client|@supabase\/|drizzle-orm(?:\/[^'"]+)?|postgres(?:\/[^'"]+)?|typeorm|knex|mongodb|pg|mysql2|mongoose|better-sqlite3|ioredis|redis|kysely|sequelize)['"]|require\(\s*['"](?:@?prisma\/client|pg|postgres(?:\/[^'"]+)?|drizzle-orm(?:\/[^'"]+)?|knex|typeorm|mongoose)/;
 /**

package/bin/lib/baseline-key.mjs

@@ -9,7 +9,10 @@
  */
 
 /** Config diagnostics that are never code debt. Not a schema key. */
-export const NON_FREEZABLE_BASELINE_RULE_IDS = ['ARKRULE_SCOPE_EMPTY'];
+export const NON_FREEZABLE_BASELINE_RULE_IDS = [
+    'ARKRULE_SCOPE_EMPTY',
+    'INVARIANT_CATALOG_EMPTY',
+];
 /**
  * STRUCTURE freeze `target`: sensor id, plus `:symbol` when a method/class is known.
  * V1 empty-target keys (`ARKRULE_STRUCTURE|file|layer||`) stay exact-match only —

package/bin/lib/check-args.mjs

@@ -14,7 +14,55 @@ export function resolveDesignDeltaBaseRef(root, explicit, env = process.env) {
   return discoverLocalBaseRef(root) || undefined;
 }
 
-export function parseArgs(argv) {
+/** Opt-in local / multi-worktree cheap check. Ignored values: empty, 0, false, no, off. */
+export function envFlagOn(value) {
+  return /^(1|true|yes)$/i.test(String(value ?? '').trim());
+}
+
+export const LOCAL_STRICT_MERGE_MESSAGE =
+  '--local cannot be combined with --strict-merge: CI stays the full fail-closed check. Use --local (or ARK_CHECK_LOCAL=1) only on the local / pre-push path.';
+
+export const LOCAL_TREE_MODE_MESSAGE =
+  '--local cannot be combined with report modes that need the whole tree (--doctor, --coverage, --plan, --report, --promote). Use --local --base <ref> for the cheap local check.';
+
+export function localCheckEnvelope(args, root) {
+  if (!args?.local) return {};
+  return {
+    local: true,
+    scope: 'changed',
+    analysisRoot: path.resolve(root),
+  };
+}
+
+/**
+ * `--local` / `ARK_CHECK_LOCAL=1` reuse `--changed`. Env is ignored under
+ * `--strict-merge` and under full-tree report modes so CI / doctor stay whole-tree.
+ */
+export function applyLocalCheckMode(args, env = process.env) {
+  const explicit = args.local === true;
+  const fromEnv = envFlagOn(env.ARK_CHECK_LOCAL);
+  if (!explicit && !fromEnv) return args;
+  const treeModes = [
+    args.doctor && '--doctor',
+    args.coverage && '--coverage',
+    args.plan && '--plan',
+    args.report && '--report',
+    args.promote && '--promote',
+  ].filter(Boolean);
+  if (args.strictMerge) {
+    if (explicit) throw new Error(LOCAL_STRICT_MERGE_MESSAGE);
+    return args;
+  }
+  if (treeModes.length > 0) {
+    if (explicit) throw new Error(LOCAL_TREE_MODE_MESSAGE);
+    return args;
+  }
+  args.local = true;
+  args.changed = true;
+  return args;
+}
+
+export function parseArgs(argv, env = process.env) {
   const args = {
     root: process.cwd(),
     config: 'ark.config.json',
@@ -39,6 +87,7 @@ export function parseArgs(argv) {
     contractSession: false,
     contractDiff: false,
     changed: false,
+    local: false,
     against: undefined,
     base: undefined,
     persona: undefined,
@@ -180,6 +229,7 @@ export function parseArgs(argv) {
     else if (arg === '--contract-session') args.contractSession = true;
     else if (arg === '--contract-diff') args.contractDiff = true;
     else if (arg === '--changed') args.changed = true;
+    else if (arg === '--local') args.local = true;
     else if (arg === '--against') args.against = requireValue(arg, i++);
     else if (arg === '--base') args.base = requireValue(arg, i++);
     else if (arg === '--persona') args.persona = requireValue(arg, i++);
@@ -238,5 +288,5 @@ export function parseArgs(argv) {
       );
     }
   }
-  return args;
+  return applyLocalCheckMode(args, env);
 }

package/bin/lib/ci-and-commands.mjs

@@ -338,6 +338,8 @@ files; never weaken the gate via subagents.
 
 **Escapes, not a second curriculum.** Do **not** run overlapping skills for the same job.
 Pick **one** primary skill. Prefer doctor top action #1 when unsure.
+Filter: **Contener · Guiar · Ordenar** — contain the write, guide the next step, order leftover mess. Skills never enforce. First-class extras:
+\`/ark-runtime\` (ArkRun) · \`/ark-order\` (ArkOrder).
 
 | When | Invoke | Not this |
 |------|--------|----------|
@@ -352,10 +354,11 @@ Pick **one** primary skill. Prefer doctor top action #1 when unsure.
 | Gate violation on a change (small cluster) | \`/ark-autopilot\` | leftover \`/ark-fix\` |
 | Drive plan **A** to goal.met | \`/ark-autopilot\` | leftover \`/ark-loop\` |
 | Ark **fitness** only (governed%, gates, baseline, install gaps) | \`/ark-coverage\` | leftover design work (use single path above) |
-| One design decision, 2–3 options | \`/ark-think\` | full Shape residual (use single path) |
+| One design decision, 2–3 options | \`/ark-explore\` (one decision) | leftover \`/ark-think\`; apply → autopilot |
 | Explain / HTML report tour | \`/ark-explain\` | explore |
 | Bump arkgate + refresh hosts | \`/ark-upgrade\` | — |
-| Optional runtime kernel evaluate | \`/ark-runtime\` | — |
+| Optional runtime kernel evaluate | \`/ark-runtime\` | leftover \`/ark-run\` (not a skill); order plane → \`/ark-order\` |
+| Optional ArkOrder evaluate / wire | \`/ark-order\` | extra off → \`/ark-adopt\`; skip grind → \`/ark-autopilot\` |
 
 **Post-green door:** when doctor reports ENFORCE · leftover design work, the **primary** next action is the single Shape path above — not a choice among explore / coverage / think. Doctor JSON: \`postGreenPath\` / \`primaryNextAction\`.
 
@@ -405,6 +408,8 @@ ${projectionBlock}
 
 **Primary path (do this):**
 
+Contener · Guiar · Ordenar — contain the write, guide the next step, order leftover mess.
+
 1. Status anytime: \`${doctorCmd}\` — what's wrong and what to do first.
 2. Read the **Improvement compass** section (not a score). Name residual lenses in plain language when present (SoC, DIP, domain, …). Out-of-scope lenses (performance, app security tooling, full resilience) stay honest — do not invent Ark enforcement for them.
 3. CLI-first: if the local CLI already resolved this project root, do not wait on MCP “still connecting”. Identity handshake is optional in that case. When you do trust MCP evidence: call \`ark_identity\` with \`project.expectedRoot\` set to this project's exact absolute root, then reuse that root plus the returned \`projectIdentity.projectId\` on every Ark MCP call. A descendant path is authoritative only with that matching id. Missing tool, non-\`matched\` binding, or wrong root means this is not proven to be the right project: restart the host and use the local CLI meanwhile.

package/bin/lib/config-contract.mjs

@@ -9,9 +9,40 @@
  */
 
 import { ARK_ORDER_SCHEMA_DEF, ARK_RUN_SCHEMA_DEF, defaultedArkOrder, defaultedArkRun, validateArkOrderExtra, validateArkRunExtra, } from './config-extras.mjs';
+import { canonicalStewardId } from './team-parliament.mjs';
 /** Current published ark.config.json schema version (ADR 0027: 1.3 adds optional arkOrder). */
 export const ARK_CONFIG_SCHEMA_VERSION = '1.3';
-export const ARK_CONFIG_SCHEMA_URL = 'https://unpkg.com/arkgate@2/schemas/ark.config.schema.json';
+/** Closed layer trust tags. Optional; absence is silent. Not a schemaVersion bump. */
+export const LAYER_TRUST_BOUNDARIES = ['public', 'auth', 'admin', 'internal'];
+/** Future house: empty globs are expected; missing owners stay silent even when required. */
+export function isFutureHouseLayer(layer) {
+    return layer?.optional === true || layer?.reserved === true || layer?.allowEmpty === true;
+}
+/**
+ * Present `layers[].owners` as non-empty strings. Absence / empty / wrong type → undefined.
+ */
+export function layerOwnersList(layer) {
+    const raw = layer && typeof layer === 'object' ? layer.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;
+}
+/**
+ * Layer names that must name owners when `requireLayerOwners` is on.
+ * Empty when the require flag is absent or false.
+ */
+export function layersMissingRequiredOwners(config) {
+    if (config?.requireLayerOwners !== true || !Array.isArray(config.layers))
+        return [];
+    return config.layers
+        .filter((layer) => !isFutureHouseLayer(layer) && !layerOwnersList(layer))
+        .map((layer) => layer.name);
+}
+export function missingLayerOwnersNextAction(layerName) {
+    return `Add a GitHub handle or email to ${layerName}'s owners in ark.config.json (/ark-adopt).`;
+}
+export const ARK_CONFIG_SCHEMA_URL = 'https://unpkg.com/arkgate@4/schemas/ark.config.schema.json';
 const DEFAULT_LAYER_NAMES = [
     'DomainModel',
     'ApplicationOrchestration',
@@ -121,6 +152,11 @@ export const ARK_CONFIG_SCHEMA = {
         arkOrder: { $ref: '#/$defs/arkOrder' },
         /** Team parliament — GitHub handles or emails who may loosen the law (not part of policy hash). */
         stewards: { ...stringArraySchema, default: [] },
+        /**
+         * When true, every non-reserved layer must name owners. Absence/false is
+         * silent. Policy teeth — stays in policyHash. Owners stay metadata.
+         */
+        requireLayerOwners: { type: 'boolean' },
     },
     $defs: {
         layer: {
@@ -133,6 +169,8 @@ export const ARK_CONFIG_SCHEMA = {
                 exclude: stringArraySchema,
                 intentPrefixes: stringArraySchema,
                 description: { type: 'string', minLength: 1 },
+                trustBoundary: { type: 'string', enum: [...LAYER_TRUST_BOUNDARIES] },
+                owners: { ...stringArraySchema, minItems: 1 },
                 forbiddenGlobals: stringArraySchema,
                 capabilities: {
                     type: 'object',
@@ -351,6 +389,30 @@ function validateNode(value, schema, path, root, issues) {
         }
     }
 }
+function validateLayerOwners(candidate, issues) {
+    const layers = candidate.layers;
+    if (!Array.isArray(layers))
+        return;
+    layers.forEach((layer, index) => {
+        if (!layer || typeof layer !== 'object' || Array.isArray(layer))
+            return;
+        if (!('owners' in layer))
+            return;
+        const owners = layer.owners;
+        if (!Array.isArray(owners))
+            return;
+        owners.forEach((entry, ownerIndex) => {
+            if (typeof entry !== 'string')
+                return;
+            if (!canonicalStewardId(entry)) {
+                issues.push({
+                    path: `$.layers[${index}].owners[${ownerIndex}]`,
+                    message: 'must be a GitHub handle or email (not a display name)',
+                });
+            }
+        });
+    });
+}
 function defaultedConfig(input) {
     const result = {
         ...input,
@@ -456,6 +518,7 @@ export function loadArkConfigContract(input, source = 'ark.config.json') {
     validateNode(candidate, ARK_CONFIG_SCHEMA, '$', ARK_CONFIG_SCHEMA, issues);
     validateArkRunExtra(candidate, issues);
     validateArkOrderExtra(candidate, issues);
+    validateLayerOwners(candidate, issues);
     if (issues.length > 0)
         throw new ArkConfigValidationError(source, issues);
     return { config: candidate, migratedFrom };

package/bin/lib/design-smells.mjs

@@ -493,6 +493,25 @@ export function summarizeDesignFitness(smells, ctx = {}) {
 /** How many smell ids the green-run pointer names before it counts the rest. */
 export const GREEN_PLAN_POINTER_MAX_IDS = 4;
 
+/** When a smell has no evidence path, say so — do not leave the reader hunting. */
+export const SMELL_UNATTRIBUTED =
+  'no file — leftover design, not a specific line';
+
+/**
+ * One named smell with its first evidence path (or an explicit "no file").
+ * The pointer used to print only the id, so "1 design smell (domain-logic-in-ui)"
+ * could not answer "did my change cause this?"
+ */
+export function formatSmellPointerName(id, smells) {
+  const match = (smells || []).find((smell) => smell?.id === id);
+  const evidence = Array.isArray(match?.evidence)
+    ? match.evidence.filter((entry) => typeof entry === 'string' && entry.trim())
+    : [];
+  if (evidence.length === 0) return `${id} (${SMELL_UNATTRIBUTED})`;
+  const extra = evidence.length - 1;
+  return extra > 0 ? `${id} at ${evidence[0]} (+${extra} more)` : `${id} at ${evidence[0]}`;
+}
+
 /**
  * Name `--plan` on a run that passed.
  *
@@ -528,7 +547,8 @@ export function formatGreenPlanPointer(smells, ctx = {}, planCommand = 'ark-chec
   if (ids.length === 0) return null;
   const shown = ids.slice(0, GREEN_PLAN_POINTER_MAX_IDS);
   const hidden = ids.length - shown.length;
-  const named = hidden > 0 ? `${shown.join(', ')}, +${hidden} more` : shown.join(', ');
+  const namedIds = shown.map((id) => formatSmellPointerName(id, smells));
+  const named = hidden > 0 ? `${namedIds.join(', ')}, +${hidden} more` : namedIds.join(', ');
   const plural = ids.length === 1 ? '' : 's';
   const suppressed = ctx.suppressedCount ?? 0;
   const opening =

package/bin/lib/diagnostic-catalog.mjs

@@ -32,7 +32,7 @@ function entry(ruleId, category, title, why, fix, extras) {
  */
 export const DIAGNOSTIC_CATALOG = Object.freeze([
     // ── layer / graph ────────────────────────────────────────────────────────
-    entry('LAYER_IMPORT_VIOLATION', 'layer', 'Layer import not allowed', 'A module import (or re-export) crosses a layer edge that ark.config.json does not allow. The architecture contract forbids that dependency direction so outer infrastructure cannot leak into pure or inner layers.', 'Branch by import kind: constants/types/pure → adopt into DomainModel or SharedKernel (do not invent a port); kernel/events/bootstrap from Persistence → inject a port or move the map to SharedTypes (Persistence must not emit); define a port only when the target is a real use-case. Type-only edges use `import type`. Then preflight again. Do not weaken the layer rule without a hash-bound policy acknowledgement.'),
+    entry('LAYER_IMPORT_VIOLATION', 'layer', 'This import is not allowed', 'This file imported a folder it may not reach. The write doesn’t land. The same check fails the pull request.', 'Branch by import kind: constants/types/pure → adopt into DomainModel or SharedKernel (do not invent a port); kernel/events/bootstrap from Persistence → inject a port or move the map to SharedTypes (Persistence must not emit); define a port only when the target is a real use-case. Type-only edges use `import type`. Then preflight again. Do not weaken the layer rule without a hash-bound policy acknowledgement.'),
     entry('LAYER_INTENT_REFERENCE_VIOLATION', 'layer', 'Intent referenced across a blocked layer edge', 'A string intent (or intent-like reference) names a layer that the file’s layer may not reach under the contract rules — the same plane as import edges, for event/intent coupling.', 'Reference that intent from a layer allowed to know about it (usually an adapter or application layer), or relocate the reference — then preflight again.'),
     entry('LAYER_REFERENCE_VIOLATION', 'layer', 'Layer reference blocked (snippet / AI gate)', 'Snippet analysis found an intent or string reference that would couple layers in a direction the architecture profile forbids.', 'Move the reference to an allowed layer or introduce a port/event boundary, then re-run the snippet gate.'),
     entry('CIRCULAR_DEPENDENCY', 'layer', 'Dependency cycle', 'Two or more modules import each other in a loop. Cycles make ownership unclear and break stable layer direction.', 'Extract the shared dependency into a third module, invert one edge behind a port, or merge units that are truly one — then preflight again.'),
@@ -56,6 +56,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('ARKRULE_INVARIANT', 'arkrules', 'ArkRule invariant failed', 'Reserved / remediation-recognized code for invariant-plane failures bound to an ArkRule id (coverage path also emits INVARIANT_UNCOVERED).', 'Fix the invariant for the ArkRule declared in arkrules/<Layer>.json, then preflight again. Do not demote without acknowledgement.'),
     entry('ARKRULE_SCOPE_EMPTY', 'arkrules', 'ArkRule appliesTo matched zero files', 'An ArkRule’s appliesTo globs matched no governed files — the rule cannot observe what it claims to protect.', 'Fix appliesTo globs so they match governed files, or remove the rule. Enforced empty scope fails; advisory empty scope warns.', { oftenAdvisory: true }),
     entry('ARKRULE_HINT_BUDGET_EXHAUSTED', 'arkrules', 'Structural-hint budget exhausted', 'orchestration-only, thin-adapter, and writes-via-aggregate only evaluate files the hint loader preloaded. When eligible governed files exceed that budget (coverage.maxFiles, default 400 — there is no arkrules.hintBudget), those sensors never saw the rest of their scope. Enforced + unreviewed is not green. The finding names exact hinted/governed counts and per-sensor reviewed N/M of scope.', 'Raise coverage.maxFiles in ark.config.json (this cap also bounds structural-hint preload; --doctor names the coupling) so hinted/governed counts match, then re-run with --strict-config. An enforced hint sensor that cannot see its scope fails strict.'),
+    entry('INVARIANT_CATALOG_EMPTY', 'arkrules', 'Domain invariant catalog is empty', 'ArkRules is on and a Domain-role layer has code, but invariants[] has no phrases the code must preserve. Empty looks like “done” until someone fills the catalog.', 'Add 1–2 short phrases to invariants[] in arkrules/<Domain>.json (or the mapped file). Starters show the shape. Advisory unless a domain structure rule is already enforced — then --strict-merge can refuse. Do not freeze this finding.', { oftenAdvisory: true }),
     entry('INVARIANT_UNCOVERED', 'arkrules', 'Invariant without coverage evidence', 'An ArkRules invariant is under contract but no covering test title or declared symbol evidence was found (or coverage is partial). Kind is never-had-tests (adopt residual) vs tests-disappeared (suite exists).', 'Add a test title or declared symbol covering the arkruleId, then preflight again. Treat never-had-tests as adopt residual; treat tests-disappeared as a regression. Missing test globs report partial — never fake green. When the message reports an exhausted file budget, raise coverage.maxFiles (or narrow coverage.testGlobs) in ark.config.json.'),
     entry('INVARIANT_COVERAGE_OUTSIDE_ROOTS', 'arkrules', 'Covering test outside the declared coverage roots', 'The only test naming this invariant sits outside coverage.coverageRoots — the places the project declares its runner executes. ArkGate matches declared text and never executes tests, so it cannot tell whether that file is ever run: coverage there is a test that exists, not a test that runs.', 'Move the test under a declared coverage root, or add its root to coverage.coverageRoots in ark.config.json. Advisory: it never fails strict, but promotion to enforced refuses on it.', { oftenAdvisory: true }),
     // ── ArkRun (opt-in extra; RN05 dual-depth nextAction) ────────────────────
@@ -75,7 +76,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('ARKORDER_INFORMATION_BUDGET', 'arkorder', 'Projection observes a forbidden kind', 'h(ξ) allowedKinds includes a kind listed in informationBudget.cannotObserve. A scale may not look at what it was told not to see.', 'Cut that kind from the projector or from cannotObserve, then preflight again. Never mechanical-safe.'),
     entry('ARKORDER_XI_TTL', 'arkorder', 'Slow key carries a freshness field', 'ξ named ttl/freshUntil/maxAge. Freshness belongs on σ. A slow parameter that expires per transaction is not slow.', 'Move freshness onto σ (freshUntil) and keep ξ stable, then preflight again. Never mechanical-safe.'),
     entry('ARKORDER_STALE_SIGMA', 'arkorder', 'σ is stale', 'ingest ran after σ.freshUntil (or sigmaMaxAgeMs). ξ does not TTL.', 'Call refreshSigma and ingest again, or proposeRelease then apply(ProposeResult) if the pattern changed. Never mechanical-safe.'),
-    entry('ARKORDER_UNVALVED_RELEASE', 'arkorder', 'Unvalved second freeze of ξ', 'release() ran after a pattern was already frozen and the new ξ differs. First freeze is release(); later pattern change is proposeRelease then apply.', 'Change ξ with proposeRelease then apply(ProposeResult). release() is only the first freeze. Never mechanical-safe.'),
+    entry('ARKORDER_UNVALVED_RELEASE', 'arkorder', 'Second freeze without the valve', 'release() already froze the big choice. A later release() with a different value does not land. First freeze is release(); later change is proposeRelease then apply.', 'Change the choice with proposeRelease then apply. release() is only the first freeze. Never mechanical-safe.'),
     // ── atomic preflight / change set ────────────────────────────────────────
     entry('INVALID_CHANGE_PATH', 'preflight', 'Unsafe change path', 'A change set entry is not a safe, non-empty project-relative path (absolute, escape, empty, or NUL).', 'Use canonical project-relative paths only in the atomic change set, then preflight again.'),
     entry('DUPLICATE_CHANGE_PATH', 'preflight', 'Duplicate path in change set', 'The atomic change set lists more than one operation for the same path.', 'Collapse to one create/update/delete per path, then preflight again.'),
@@ -90,7 +91,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('DESIGN_SMELL_REGRESSION', 'preflight', 'Design smell regression on base-relative ratchet', 'Compared to the base ref, the candidate introduces a created-path domain-logic-in-ui file under --strict-merge, or introduces or worsens a blocking design-smell class under --fail-on-new-smells.', 'Move the new UI business rule out of the created file (or revert a --fail-on-new-smells regression), then re-run with the same base ref.'),
     // ── analysis completeness / host ─────────────────────────────────────────
     entry('ANALYSIS_PARSE_INCOMPLETE', 'analysis', 'Parse incomplete', 'Governed source could not be fully parsed; evidence includes the TypeScript diagnostic (line + message). Incremental mid-edit parse is normal for agents. Contract exclude paths skip the write hook.', 'Finish the source or fix the reported syntax error, then re-run `npx arkgate-check`. The write hook does not deny solely on mid-edit parse. Partial never means pass.'),
-    entry('LEXICAL_EVIDENCE_INCOMPLETE', 'analysis', 'Lexical evidence incomplete', 'Single-file validation cannot prove project module resolution. The write hook is already the verdict.', 'Re-run `npx arkgate-check --root . --config ark.config.json`, or treat the hook deny as final. Do not call ark_prepare_change from a hook deny.'),
+    entry('LEXICAL_EVIDENCE_INCOMPLETE', 'analysis', 'Lexical evidence incomplete', 'This check only saw one file, so it cannot fully prove how the import resolves. The result is provisional — `ark-check` on the project is the authority.', 'Run `npx arkgate-check --root . --config ark.config.json` to confirm. Do not call ark_prepare_change from a hook deny.'),
     entry('ANALYSIS_COVERS_NO_FILES', 'analysis', 'Analysis covered no files', 'No file matched the contract include and layer patterns under the analyzed root, so the run had nothing to check. Every rule is vacuously satisfied on an empty set: a green here would read exactly like a green over a governed tree while certifying nothing. Usual causes are a --root that is not the tree the contract describes (including a contract found outside the requested root, whose directory is then adopted as the project root), include / exclude patterns that match nothing, or layer patterns written for a different layout.', 'Point --root at the tree the contract describes, or keep the contract inside that tree, or fix the include / exclude / layer patterns so they match real files — then re-run `npx arkgate-check --root . --config ark.config.json`. This is a refusal about ArkGate\u2019s own inputs, not a finding about your code; no baseline or policy acknowledgement can suppress it.'),
     entry('ANALYSIS_HOST_UNAVAILABLE', 'analysis', 'Analysis host unavailable', 'No usable TypeScript / analysis host was available for this invocation.', 'Install a supported TypeScript version visible to the project, then re-run. Unavailable analysis is fail-closed.'),
     entry('ADAPTER_NOT_ALLOWED_FOR_PORT', 'adapter', 'Adapter not allowed for port', 'Runtime/port wiring selected an adapter implementation that the architecture profile does not allow for that port.', 'Bind an allowed adapter for the port, or adjust the profile with an explicit policy decision — then re-run.'),
@@ -116,6 +117,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('CONFIG_RULE_UNKNOWN_TO_LAYER', 'config', 'Rule unknown to layer', 'A dependency rule references a target layer name that is not declared.', 'Fix the rule’s to field to a declared layer name.', { oftenAdvisory: true }),
     entry('CONFIG_AMBIGUOUS_LAYERS', 'config', 'Ambiguous layer classification', 'Some files match multiple layers at equal specificity; classification falls back to declaration order.', 'Disambiguate overlapping patterns so each file has one clear layer owner.', { oftenAdvisory: true }),
     entry('CONFIG_UNCLASSIFIED_FILES', 'config', 'Unclassified included files', 'Included source files match no layer pattern; import rules will not enforce on them.', 'Extend layer patterns or narrow include so every governed file is classified.', { oftenAdvisory: true }),
+    entry('CONFIG_LAYER_MISSING_OWNER', 'config', 'Layer missing owner', 'requireLayerOwners is on and this layer has no owners. Writes to that house fail closed, like a folder with no name on the door.', 'Add a GitHub handle or email to that layer’s owners in ark.config.json (/ark-adopt), then re-run. Reserved/allowEmpty houses may stay unnamed. Turn the flag off only if you no longer want owners required.'),
     // ── literal path drift ───────────────────────────────────────────────────
     entry('LITERAL_PATH_DRIFT', 'drift', 'Literal path moved by a rename', 'A repo path written inside a string, a comment or a docstring no longer resolves, and the rename set says where it went. Nothing in the gate sees this class: `tsc` resolves imports, not strings, and ESLint does not either, so the rename compiles green and the reference lies afterwards. It appears in four forms — the tsconfig alias, a relative literal, a path written without the include-root prefix, and prose — and a hand sweep reliably covers one of them.', 'Apply the suggested replacement, or re-run `npx arkgate-check --path-drift --base-ref <ref> --write` to apply every writable anchored replacement at once. The rewrite is mechanical and one-directional: the destination comes from the rename, it must itself resolve and be path-shaped, and the token is rewritten in the form the author wrote it in. A destination that leaves the alias root of the literal is reported with the target only and must be rewritten by hand.'),
     entry('LITERAL_PATH_UNRESOLVED', 'drift', 'Literal path does not resolve', 'A literal that looks like a repo path does not resolve under this root, and no rename explains where it went. Unlike LITERAL_PATH_DRIFT this is a candidate, not a verdict: with nothing to anchor it, ArkGate cannot tell a dead reference from an illustrative path in a comment, an example in documentation, or a path belonging to another tree.', 'Read the candidate and decide: fix the path, or leave it. Advisory only — it never fails a run and is never rewritten by --write, because there is no destination to propose. Run `--path-drift --all` to list the sweep.', { oftenAdvisory: true }),