arkgate 4.8.11 → 4.8.13

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

@@ -0,0 +1,154 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/arkOrderDoctor.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/ark-order-doctor.mjs). Zero Node I/O.
+ */
+
+import { composeMergePlanesHonesty, extraMergeTeethAllowed, isArkOrderRuleId, } from './extra-merge-teeth.mjs';
+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.';
+function closedMode(value) {
+    return value === 'enforced' || value === 'advisory' ? value : null;
+}
+function uniqueArkOrderRuleIds(findings) {
+    const seen = new Set();
+    if (!Array.isArray(findings))
+        return [];
+    for (const finding of findings) {
+        const id = finding?.ruleId;
+        if (typeof id !== 'string' || !isArkOrderRuleId(id) || seen.has(id))
+            continue;
+        seen.add(id);
+    }
+    return [...seen].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+}
+function extraFromConfig(arkOrder) {
+    if (!arkOrder || typeof arkOrder !== 'object') {
+        return { present: false, mode: null, roots: 0, layers: 0, xiKeys: [] };
+    }
+    const xiKeys = Array.isArray(arkOrder.xiKeys)
+        ? arkOrder.xiKeys.filter((key) => typeof key === 'string' && key.length > 0)
+        : [];
+    return {
+        present: true,
+        mode: closedMode(arkOrder.mode),
+        roots: Array.isArray(arkOrder.planeRoots) ? arkOrder.planeRoots.length : 0,
+        layers: Array.isArray(arkOrder.managedLayers) ? arkOrder.managedLayers.length : 0,
+        xiKeys,
+    };
+}
+/**
+ * Doctor / HTML ArkOrder advisory. Always emitted; absence is an honest silent row.
+ */
+export function summarizeArkOrderSection(input = {}) {
+    const extra = extraFromConfig(input.arkOrder);
+    const uniqueIds = extra.present ? uniqueArkOrderRuleIds(input.findings) : [];
+    const ruleIds = uniqueIds.slice(0, RESIDUAL_RULE_CAP);
+    const residualCount = uniqueIds.length;
+    const mergePlanes = composeMergePlanesHonesty({
+        classification: input.classification,
+        arkRules: {
+            active: input.arkRules?.active === true,
+            structureEnforced: input.arkRules?.structureEnforced,
+            structureTotal: input.arkRules?.structureTotal,
+            structureAdvisory: input.arkRules?.structureAdvisory,
+            invariantEnforced: input.arkRules?.invariantEnforced,
+            invariantTotal: input.arkRules?.invariantTotal,
+            invariantAdvisory: input.arkRules?.invariantAdvisory,
+            covered: input.arkRules?.covered,
+            uncovered: input.arkRules?.uncovered,
+        },
+        arkRun: {
+            present: input.arkRun?.present === true,
+            mode: input.arkRun?.mode ?? null,
+            residualCount: input.arkRun?.residualCount,
+        },
+        arkOrder: {
+            present: extra.present,
+            mode: extra.mode,
+            residualCount,
+        },
+    });
+    const extraMergeTeeth = extra.present && extra.mode === 'enforced' && extraMergeTeethAllowed(input.classification);
+    let note;
+    if (!extra.present) {
+        note = 'Absence of arkOrder is silent — Layers verdicts unchanged. Not a score.';
+    }
+    else if (extra.mode === 'advisory') {
+        note =
+            'Advisory ArkOrder residual only — never flips valid or --strict-merge. Residual is a finding-id count, never a score.';
+    }
+    else if (extraMergeTeeth) {
+        note =
+            'Enforced ArkOrder is on the extra merge plane. Residual is a finding-id count, never a score.';
+    }
+    else {
+        note =
+            'Enforced ArkOrder extra teeth stay demoted until the layer plane is honestly classified. Residual is a finding-id count, never a score.';
+    }
+    return {
+        schemaVersion: ARK_ORDER_DOCTOR_SCHEMA_VERSION,
+        notAScore: true,
+        active: extra.present,
+        mode: extra.mode,
+        planeRoots: extra.roots,
+        managedLayers: extra.layers,
+        xiKeys: extra.xiKeys,
+        residual: { count: residualCount, ruleIds },
+        extraMergeTeeth,
+        failMergeWhen: mergePlanes.failMergeWhen,
+        note,
+        mergePlanes,
+    };
+}
+/** Thin status slice — counts only; residual null means unknown, not green. */
+export function projectStatusArkOrder(input = {}) {
+    const present = input.present === true;
+    const mode = closedMode(input.mode);
+    const residualRaw = input.residual;
+    let residual = null;
+    if (typeof residualRaw === 'number' && Number.isFinite(residualRaw) && residualRaw >= 0) {
+        residual = Math.floor(residualRaw);
+    }
+    if (!present)
+        residual = residual == null ? 0 : residual;
+    return {
+        notAScore: true,
+        present,
+        mode: present ? mode : null,
+        extraMergeTeeth: present && mode === 'enforced' && input.extraMergeTeeth === true,
+        residual,
+    };
+}
+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).'];
+    }
+    const mode = section.mode ?? 'unknown';
+    const teeth = section.extraMergeTeeth === true ? 'armed' : 'not armed';
+    const keys = section.xiKeys.length > 0 ? section.xiKeys.join(', ') : '(none named — field-write sensor silent)';
+    const lines = [
+        ARKORDER_ONE_BREATH,
+        `mode: ${mode} · xiKeys: ${keys} · extra merge teeth ${teeth} · not a score`,
+    ];
+    if (section.residual.count > 0) {
+        const shown = section.residual.ruleIds.join(', ');
+        const more = section.residual.count > section.residual.ruleIds.length
+            ? ` (+${section.residual.count - section.residual.ruleIds.length} more)`
+            : '';
+        lines.push(`Residual: ${shown}${more}`);
+    }
+    else {
+        lines.push('Residual: none on this scan (not a score — green extras ≠ a frozen billing plan).');
+    }
+    if (section.failMergeWhen)
+        lines.push(section.failMergeWhen);
+    return lines;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * HTML for the doctor ArkOrder advisory (report parity: data-advisory="arkOrder").
+ */
+import { ARKORDER_ONE_BREATH } from './ark-order-doctor.mjs';
+
+export function formatArkOrderHtml(section, esc) {
+  if (!section || typeof section !== 'object' || section.notAScore !== true) return '';
+  const escape = typeof esc === 'function' ? esc : (v) => String(v);
+  const note = section.note ? `<p class="muted">${escape(section.note)}</p>` : '';
+  if (section.active !== true) {
+    return `
+  <section class="section card" data-advisory="arkOrder">
+    <h2>ArkOrder <span class="muted">(opt-in extra — not a score)</span></h2>
+    <p class="dim" style="margin:.15rem 0 .55rem;font-size:.88rem">
+      ${ARKORDER_ONE_BREATH}
+      Off until you turn it on — Layers stay the same.
+    </p>
+    ${note}
+  </section>`;
+  }
+  const residual = section.residual && typeof section.residual === 'object' ? section.residual : { count: 0, ruleIds: [] };
+  const ids = Array.isArray(residual.ruleIds) ? residual.ruleIds : [];
+  const residualHtml =
+    residual.count > 0
+      ? `<p><span class="tag warn">residual</span> ${ids
+          .map((id) => `<code>${escape(id)}</code>`)
+          .join(' · ')}${
+          residual.count > ids.length ? ` <span class="muted">(+${residual.count - ids.length} more)</span>` : ''
+        }</p>`
+      : '<p class="muted">Residual: none on this scan (not a score — green extras ≠ a frozen billing plan).</p>';
+  const teeth = section.extraMergeTeeth === true
+    ? '<span class="tag">extra merge teeth armed</span>'
+    : '<span class="tag warn">extra merge teeth not armed</span>';
+  const mergeSentence =
+    section.mergePlanes && typeof section.mergePlanes.failMergeWhen === 'string'
+      ? section.mergePlanes.failMergeWhen
+      : section.failMergeWhen;
+  const merge =
+    mergeSentence
+      ? `<p class="muted" style="margin:.35rem 0 .55rem;font-size:.86rem"><b>Merge planes:</b> ${escape(mergeSentence)}</p>`
+      : '';
+  const keys = Array.isArray(section.xiKeys) && section.xiKeys.length > 0
+    ? section.xiKeys.map((key) => `<code>${escape(key)}</code>`).join(' · ')
+    : '<span class="muted">(none named — field-write sensor silent)</span>';
+  return `
+  <section class="section card" data-advisory="arkOrder">
+    <h2>ArkOrder <span class="muted">(not a score)</span></h2>
+    <p class="dim" style="margin:.15rem 0 .55rem;font-size:.88rem">
+      <b>[ArkOrder]</b> ${ARKORDER_ONE_BREATH}
+      Separate from <b>[Layer]</b> imports, <b>[ArkRules]</b> shape, and <b>[ArkRun]</b> travel.
+    </p>
+    ${merge}
+    <div class="kpis" style="margin-bottom:.55rem">
+      <div class="kpi"><b>${escape(section.mode || '—')}</b><span>Mode</span></div>
+      <div class="kpi"><b>${Number(residual.count) || 0}</b><span>Residual ids</span></div>
+      <div class="kpi"><b>${Number(section.planeRoots) || 0}</b><span>Plane roots</span></div>
+      <div class="kpi"><b>${Number(section.managedLayers) || 0}</b><span>Managed layers</span></div>
+    </div>
+    <p>${teeth} · <code>notAScore</code></p>
+    <p class="dim" style="margin:.35rem 0 .55rem;font-size:.86rem">xiKeys: ${keys}</p>
+    ${residualHtml}
+    ${note}
+  </section>`;
+}

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

@@ -219,7 +219,7 @@ export function evaluateArkOrderSensors(input) {
             continue;
         if (!matchesArkOrderAppliesTo(write.file, extra.appliesTo))
             continue;
-        findings.push(finding(extra, 'arkorder-xi-field-write', write.file, write.line, `File writes slow key ${JSON.stringify(write.key)} through a persistence driver; route the field through ingest or a pattern change through proposeRelease.`, { fromLayer, target: write.key }, teethAllowed));
+        findings.push(finding(extra, 'arkorder-xi-field-write', write.file, write.line, `This file writes ${JSON.stringify(write.key)} the same way it would write a seat count. Take the event in, or change that choice through the valve (propose, then apply).`, { fromLayer, target: write.key }, teethAllowed));
     }
     findings.sort((left, right) => left.file.localeCompare(right.file) ||
         left.ruleId.localeCompare(right.ruleId) ||

package/bin/lib/diagnostic-catalog.mjs

@@ -68,10 +68,10 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('ARKRUN_TRANSPORT_BYPASS', 'arkrun', 'Homemade broker or emitter import', 'A managed layer imports a closed broker/queue/emitter specifier (EventEmitter, queue clients, …) instead of the ArkRun kernel transport.', 'Send through the ArkRun kernel transport instead of importing that broker or emitter, then preflight again. Never mechanical-safe — homemade buses stay judgment.'),
     entry('ARKORDER_MISSING_PLANE', 'arkorder', 'No createOrderPlane in plane roots', 'The ArkOrder extra is on but no createOrderPlane factory was found in arkOrder.planeRoots, so agents can skip the pattern plane while the write gate stays green.', 'Import createOrderPlane from arkgate/order and call it in a plane root listed in arkOrder.planeRoots, then preflight again. Never mechanical-safe — factory placement is a design decision.'),
     entry('ARKORDER_KERNEL_IN_DOMAIN', 'arkorder', 'Domain-role layer imports the order plane', 'A Domain-role layer imports arkgate/order. Domain stays plane-free; planeRoots own the factory.', 'Move the arkgate/order import out of the Domain-role layer into a plane root or adapter, then preflight again. Never mechanical-safe.'),
-    entry('ARKORDER_GENERIC_UPDATE', 'arkorder', 'Generic update of ξ', 'A call to update/patch/set on the order plane rewrites the slow pattern. Haken slaving forbids generic ξ mutation.', 'Use release() for the first freeze of ξ. Later pattern change is proposeRelease then apply(ProposeResult). Never update/patch/set. Never mechanical-safe.'),
+    entry('ARKORDER_GENERIC_UPDATE', 'arkorder', 'Generic update of a big product choice', 'A call to update/patch/set rewrites a named product choice (like billing plan) as if it were a seat count.', 'Don\'t use a generic update. First freeze with release(). Later, propose the change, then apply it.'),
     entry('ARKORDER_TOO_MANY_PARAMS', 'arkorder', 'Too many slow keys', 'ξ has more keys than arkOrder.maxXiKeys. Haken requires a few slow modes, not a dump of microstate.', 'Cut ξ to the slow keys that actually slave the rest, then preflight again. Never mechanical-safe.'),
     entry('ARKORDER_INGEST_WRITES_XI', 'arkorder', 'ingest assigned into ξ', 'An ingest() result is written into a Release or ξ store. ingest may absorb, escalate_up, or hold; it never mints a pattern.', 'Keep ingest results as absorb/escalate_up/hold only. Change ξ with proposeRelease then apply(ProposeResult). Never mechanical-safe.'),
-    entry('ARKORDER_XI_FIELD_WRITE', 'arkorder', 'Slow key written around the order plane', 'A managed-layer file imports a persistence driver and writes a declared arkOrder.xiKeys name. Field events absorb or escalate; they do not PATCH the slow pattern.', 'Keep invoices, seats, hours, and logs on ingest. Change the slow key with proposeRelease then apply(ProposeResult), then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_XI_FIELD_WRITE', 'arkorder', 'Big product choice written like a seat count', 'A use-case writes a named product choice (like billing plan) through a database update. Invoices and seats can flow. That choice cannot.', 'Keep invoices and seats as events. Change the choice through the valve (proposeRelease then apply), not a generic update.'),
     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.'),

package/bin/lib/doctor-advisories.mjs

@@ -21,6 +21,82 @@ import { detectGraphBlindSpots, printGraphBlindSection } from './graph-blind.mjs
 import { summarizeRulesUnderContract } from './rules-under-contract.mjs';
 import { collectStewardNudge } from './team-parliament-io.mjs';
 import { formatArkRunDoctorLines, summarizeArkRunSection } from './ark-run-doctor.mjs';
+import {
+  ARKORDER_ONE_BREATH,
+  formatArkOrderDoctorLines,
+  summarizeArkOrderSection,
+} from './ark-order-doctor.mjs';
+import { composeMergePlanesHonesty } from './extra-merge-teeth.mjs';
+
+export function attachExtraDoctorSections(rulesUnderContract, config, classification, findings) {
+  const arkRulesMerge = {
+    active: rulesUnderContract?.active === true,
+    structureEnforced: rulesUnderContract?.mergePlanes?.structureSensors?.enforced,
+    structureTotal: rulesUnderContract?.mergePlanes?.structureSensors?.total,
+    structureAdvisory: rulesUnderContract?.mergePlanes?.structureSensors?.advisory,
+    invariantEnforced: rulesUnderContract?.mergePlanes?.invariants?.enforced,
+    invariantTotal: rulesUnderContract?.mergePlanes?.invariants?.total,
+    invariantAdvisory: rulesUnderContract?.mergePlanes?.invariants?.advisory,
+    covered: rulesUnderContract?.mergePlanes?.invariants?.covered,
+    uncovered: rulesUnderContract?.mergePlanes?.invariants?.uncovered,
+  };
+  const arkRun = summarizeArkRunSection({
+    arkRun: config?.arkRun,
+    findings,
+    classification,
+    arkRules: arkRulesMerge,
+  });
+  const arkOrder = summarizeArkOrderSection({
+    arkOrder: config?.arkOrder,
+    findings,
+    classification,
+    arkRules: arkRulesMerge,
+    arkRun: {
+      present: arkRun.active === true,
+      mode: arkRun.mode,
+      residualCount: arkRun.residual?.count,
+    },
+  });
+  const mergePlanes = composeMergePlanesHonesty({
+    classification,
+    arkRules: arkRulesMerge,
+    arkRun: {
+      present: arkRun.active === true,
+      mode: arkRun.mode,
+      residualCount: arkRun.residual?.count,
+    },
+    arkOrder: {
+      present: arkOrder.active === true,
+      mode: arkOrder.mode,
+      residualCount: arkOrder.residual?.count,
+    },
+  });
+  if (rulesUnderContract?.mergePlanes) rulesUnderContract.mergePlanes = mergePlanes;
+  arkRun.mergePlanes = mergePlanes;
+  arkRun.failMergeWhen = mergePlanes.failMergeWhen;
+  arkOrder.mergePlanes = mergePlanes;
+  arkOrder.failMergeWhen = mergePlanes.failMergeWhen;
+  return { arkRun, arkOrder, mergePlanes };
+}
+
+export function printCompactExtraDoctorLines(advisories, io) {
+  const arkRun = advisories?.arkRun;
+  if (arkRun?.active === true && arkRun.notAScore === true) {
+    console.log('');
+    const residual = Number(arkRun.residual?.count) || 0;
+    io.line(residual > 0 ? io.warn : ' ', `ArkRun: ${arkRun.mode || 'on'} · residual=${residual} · not a score`);
+  }
+  const arkOrder = advisories?.arkOrder;
+  if (arkOrder?.active === true && arkOrder.notAScore === true) {
+    console.log('');
+    const residual = Number(arkOrder.residual?.count) || 0;
+    const keys =
+      Array.isArray(arkOrder.xiKeys) && arkOrder.xiKeys.length > 0 ? arkOrder.xiKeys.join(', ') : 'unnamed';
+    const mark = residual > 0 ? io.warn : ' ';
+    io.line(mark, ARKORDER_ONE_BREATH);
+    io.line(mark, `ArkOrder: ${arkOrder.mode || 'on'} · xiKeys=${keys} · residual=${residual} · not a score`);
+  }
+}
 
 function classificationFromCoverage(cov) {
   return {
@@ -55,25 +131,12 @@ export function computeDoctorAdvisories(root, config, cov, rules, files, ts, par
       : undefined);
   const classification = classificationFromCoverage(cov);
   const rulesUnderContract = summarizeRulesUnderContract(root, config, factPaths, classification);
-  const arkRun = summarizeArkRunSection({
-    arkRun: config?.arkRun,
-    findings: activeViolations,
+  const { arkRun, arkOrder } = attachExtraDoctorSections(
+    rulesUnderContract,
+    config,
     classification,
-    arkRules: {
-      active: rulesUnderContract?.active === true,
-      structureEnforced: rulesUnderContract?.mergePlanes?.structureSensors?.enforced,
-      structureTotal: rulesUnderContract?.mergePlanes?.structureSensors?.total,
-      structureAdvisory: rulesUnderContract?.mergePlanes?.structureSensors?.advisory,
-      invariantEnforced: rulesUnderContract?.mergePlanes?.invariants?.enforced,
-      invariantTotal: rulesUnderContract?.mergePlanes?.invariants?.total,
-      invariantAdvisory: rulesUnderContract?.mergePlanes?.invariants?.advisory,
-      covered: rulesUnderContract?.mergePlanes?.invariants?.covered,
-      uncovered: rulesUnderContract?.mergePlanes?.invariants?.uncovered,
-    },
-  });
-  if (rulesUnderContract?.mergePlanes) {
-    rulesUnderContract.mergePlanes = arkRun.mergePlanes;
-  }
+    activeViolations
+  );
   return {
     contractHealth: computeContractHealth(root, config, cov, rules),
     ambientState: computeAmbientState(ts, root, config, files),
@@ -86,6 +149,7 @@ export function computeDoctorAdvisories(root, config, cov, rules, files, ts, par
     stewardNudge: collectStewardNudge(root, config),
     rulesUnderContract,
     arkRun,
+    arkOrder,
   };
 }
 
@@ -116,4 +180,13 @@ export function printDoctorAdvisories(advisories, io) {
       io.line(mark, text);
     }
   }
+  const arkOrder = advisories.arkOrder;
+  if (arkOrder && arkOrder.notAScore === true) {
+    console.log('');
+    console.log(io.color.bold('ArkOrder (not a score)'));
+    const mark = arkOrder.active && arkOrder.residual?.count > 0 ? io.warn : ' ';
+    for (const text of formatArkOrderDoctorLines(arkOrder)) {
+      io.line(mark, text);
+    }
+  }
 }

package/bin/lib/doctor-human.mjs

@@ -7,7 +7,7 @@ import { arkCommand } from '../ark-shared.mjs';
 import { operatingModeTitle } from './product-copy.mjs';
 import { isDoctorHealthyNothingToDo } from './post-green-path.mjs';
 import { printParseHealthSection } from './parse-health.mjs';
-import { printDoctorAdvisories } from './doctor-advisories.mjs';
+import { printDoctorAdvisories, printCompactExtraDoctorLines } from './doctor-advisories.mjs';
 import { designDeltaDoctorLines } from './design-delta.mjs';
 import { enforcementDoctorLines } from './enforcement-state.mjs';
 import { analysisIncompleteStatement } from './analysis-completeness.mjs';
@@ -164,15 +164,7 @@ export function printDoctorCompactHuman(view) {
     line(warn, nudge.ask);
   }
 
-  const arkRun = doctorAdvisories.arkRun;
-  if (arkRun?.active === true && arkRun.notAScore === true) {
-    console.log('');
-    const residual = Number(arkRun.residual?.count) || 0;
-    line(
-      residual > 0 ? warn : ' ',
-      `ArkRun: ${arkRun.mode || 'on'} · residual=${residual} · not a score`
-    );
-  }
+  printCompactExtraDoctorLines(doctorAdvisories, { line, warn });
 
   if (violations.length === 0) {
     if (!analysisComplete) {

package/bin/lib/doctor-plan.mjs

@@ -658,11 +658,11 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
       pilotTarget: residualPilot?.pilotTarget ?? residualPilot?.pilot ?? null,
       arkRulesMergeHonesty: rulesUnderContract?.mergePlanes
         ? {
-            active: rulesUnderContract.active === true || arkRun?.active === true,
+            active: rulesUnderContract.active === true || arkRun?.active === true || doctorAdvisories.arkOrder?.active === true,
             ...rulesUnderContract.mergePlanes,
           }
-        : rulesUnderContract?.active === true || arkRun?.active === true
-          ? { active: true, extraMergeTeeth: arkRun?.extraMergeTeeth === true }
+        : rulesUnderContract?.active === true || arkRun?.active === true || doctorAdvisories.arkOrder?.active === true
+          ? { active: true, extraMergeTeeth: arkRun?.extraMergeTeeth === true || doctorAdvisories.arkOrder?.extraMergeTeeth === true }
           : null,
       primaryNextAction:
         adopted === 'not-adopted' ? NOT_ADOPTED_NEXT_ACTION : postGreenPath?.action ?? dualTruthNext,
@@ -757,6 +757,7 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
             ...doctorAdvisories,
             rulesUnderContract,
             arkRun,
+            arkOrder: doctorAdvisories.arkOrder,
             // P0-B — single anti-false-green honesty surface (never a score).
             productHonesty,
             governed: cov.governed,

package/bin/lib/extra-merge-teeth.mjs

@@ -80,7 +80,7 @@ export function demoteExtraPlaneTeethUnderClassificationFloor(violations, classi
     return violations;
 }
 /** Stamp for extra-plane honesty: never one architecture score. */
-export const MERGE_PLANES_DUAL_STAMP = 'Structure = heuristics; invariants = catalog+coverage evidence (not business runtime); ArkRun = kernel usage + declarations (not a score); ArkOrder = pattern slaving (not a score). Extra planes never merge into one architecture score. Advisory ArkRules ≠ merge teeth. Advisory ArkRun ≠ merge teeth. Advisory ArkOrder ≠ merge teeth.';
+export const MERGE_PLANES_DUAL_STAMP = 'Structure = heuristics; invariants = catalog+coverage evidence (not business runtime); ArkRun = kernel usage + declarations (not a score); ArkOrder = the few big product choices (not a score). Extra planes never merge into one architecture score. Advisory ArkRules ≠ merge teeth. Advisory ArkRun ≠ merge teeth. Advisory ArkOrder ≠ merge teeth.';
 function countOrZero(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
 }
@@ -112,7 +112,14 @@ export function composeMergePlanesHonesty(input = {}) {
     const arkRunResidual = countOrZero(input.arkRun?.residualCount);
     const arkRunHasEnforced = arkRunPresent && arkRunMode === 'enforced';
     const arkRunTeeth = arkRunHasEnforced && classificationAllowsTeeth;
-    const hasEnforcedTeeth = arkRulesHasEnforced || arkRunHasEnforced;
+    const arkOrderPresent = input.arkOrder?.present === true;
+    const arkOrderMode = input.arkOrder?.mode === 'enforced' || input.arkOrder?.mode === 'advisory'
+        ? input.arkOrder.mode
+        : null;
+    const arkOrderResidual = countOrZero(input.arkOrder?.residualCount);
+    const arkOrderHasEnforced = arkOrderPresent && arkOrderMode === 'enforced';
+    const arkOrderTeeth = arkOrderHasEnforced && classificationAllowsTeeth;
+    const hasEnforcedTeeth = arkRulesHasEnforced || arkRunHasEnforced || arkOrderHasEnforced;
     const extraMergeTeeth = hasEnforcedTeeth && classificationAllowsTeeth;
     const teethDeferredForClassification = hasEnforcedTeeth && classificationKnown && !classificationAllowsTeeth;
     let failMergeWhen;
@@ -122,12 +129,15 @@ export function composeMergePlanesHonesty(input = {}) {
             extras.push('enforced structure/invariant findings');
         if (arkRunHasEnforced)
             extras.push('enforced ArkRun skip findings');
+        if (arkOrderHasEnforced)
+            extras.push('enforced ArkOrder skip findings');
         failMergeWhen = `Layer graph failures plus ${extras.join(' and ')} (advisory extras never fail merge alone).`;
     }
     else if (teethDeferredForClassification) {
         const which = [
             arkRulesHasEnforced ? 'ArkRules structure/invariant' : null,
             arkRunHasEnforced ? 'ArkRun' : null,
+            arkOrderHasEnforced ? 'ArkOrder' : null,
         ]
             .filter((part) => Boolean(part))
             .join(' and ');
@@ -139,15 +149,21 @@ export function composeMergePlanesHonesty(input = {}) {
             : arkRunMode === 'advisory'
                 ? ' Advisory ArkRun never merge-blocks.'
                 : ' ArkRun extra is present but does not arm merge teeth.';
+        const arkOrderBit = !arkOrderPresent
+            ? ' Absence of arkOrder is silent.'
+            : arkOrderMode === 'advisory'
+                ? ' Advisory ArkOrder never merge-blocks.'
+                : ' ArkOrder extra is present but does not arm merge teeth.';
         failMergeWhen =
             'Layer graph only — no enforced ArkRules structure/invariant teeth on this tree. Advisory packs do not arm merge teeth.' +
-                arkRunBit;
+                arkRunBit +
+                arkOrderBit;
     }
     const out = {
         layers: {
             role: 'inter-layer-edges',
             alwaysOnGate: true,
-            note: 'Import/export layer graph — the default merge plane. Absent arkRules or arkRun changes nothing here.',
+            note: 'Import/export layer graph — the default merge plane. Absent extras change nothing here.',
         },
         structureSensors: {
             role: 'intra-layer-heuristics',
@@ -177,6 +193,18 @@ export function composeMergePlanesHonesty(input = {}) {
                     : 'Advisory ArkRun never adds merge teeth and never flips valid. Residual is a count, never a score.'
                 : 'Absence of arkRun is silent — Layers and ArkRules verdicts unchanged. The extra never becomes a score.',
         },
+        arkOrder: {
+            role: 'pattern-slaving',
+            present: arkOrderPresent,
+            mode: arkOrderMode,
+            residualCount: arkOrderResidual,
+            extraMergeTeeth: arkOrderTeeth,
+            note: arkOrderPresent
+                ? arkOrderMode === 'enforced'
+                    ? 'Enforced ArkOrder arms extra merge teeth only when the layer plane is classified. Residual is a count, never a score.'
+                    : 'Advisory ArkOrder never adds merge teeth and never flips valid. Residual is a count, never a score.'
+                : 'Absence of arkOrder is silent — Layers verdicts unchanged. The extra never becomes a score.',
+        },
         extraMergeTeeth,
         dualPlaneStamp: MERGE_PLANES_DUAL_STAMP,
         failMergeWhen,

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

@@ -11,6 +11,7 @@ import { effectiveCapabilityDeny } from './analysis-engine.mjs';
 import { graphBlindSpotsHtml } from './graph-blind.mjs';
 import { formatRulesUnderContractHtml } from './rules-under-contract.mjs';
 import { formatArkRunHtml } from './ark-run-report.mjs';
+import { formatArkOrderHtml } from './ark-order-report.mjs';
 import { primaryImprovementCompassNextAction } from './improvement-compass.mjs';
 
 // htmlEscape is injected by the caller (html-report.mjs) — importing it back
@@ -353,6 +354,7 @@ export function renderAdvisorySections(advisories, escape) {
     graphBlindSpotsHtml(advisories.graphBlindSpots, esc),
     rulesUnderContractHtml(advisories.rulesUnderContract),
     formatArkRunHtml(advisories.arkRun, esc),
+    formatArkOrderHtml(advisories.arkOrder, esc),
   ]
     .filter(Boolean)
     .join('\n');

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

@@ -19,7 +19,7 @@ import {
   buildProductHonesty,
 } from './enforcement-honesty.mjs';
 import { summarizeRulesUnderContract } from './rules-under-contract.mjs';
-import { summarizeArkRunSection } from './ark-run-doctor.mjs';
+import { attachExtraDoctorSections } from './doctor-advisories.mjs';
 import { readBaseline, baselineOccurrenceKeys } from './violations.mjs';
 import { describePackageVersionDualTruth } from './field-install.mjs';
 import { buildDoctorImprovementCompass } from './improvement-compass-doctor.mjs';
@@ -136,23 +136,12 @@ export function buildReportDepthPayload(
     classifiedFiles: coverage?.governed?.classifiedFiles ?? null,
   };
   const rulesUnderContract = summarizeRulesUnderContract(root, config, undefined, classification);
-  const arkRun = summarizeArkRunSection({
-    arkRun: config?.arkRun,
-    findings: activeViolations,
+  const { arkRun, arkOrder } = attachExtraDoctorSections(
+    rulesUnderContract,
+    config,
     classification,
-    arkRules: {
-      active: rulesUnderContract?.active === true,
-      structureEnforced: rulesUnderContract?.mergePlanes?.structureSensors?.enforced,
-      structureTotal: rulesUnderContract?.mergePlanes?.structureSensors?.total,
-      structureAdvisory: rulesUnderContract?.mergePlanes?.structureSensors?.advisory,
-      invariantEnforced: rulesUnderContract?.mergePlanes?.invariants?.enforced,
-      invariantTotal: rulesUnderContract?.mergePlanes?.invariants?.total,
-      invariantAdvisory: rulesUnderContract?.mergePlanes?.invariants?.advisory,
-      covered: rulesUnderContract?.mergePlanes?.invariants?.covered,
-      uncovered: rulesUnderContract?.mergePlanes?.invariants?.uncovered,
-    },
-  });
-  if (rulesUnderContract?.mergePlanes) rulesUnderContract.mergePlanes = arkRun.mergePlanes;
+    activeViolations
+  );
   // Single residual expression (parity with doctor): nextPilot || extractionCard.
   const residualPilot =
     pilotLoop?.nextPilot || pilotLoop?.extractionCard || null;
@@ -174,7 +163,7 @@ export function buildReportDepthPayload(
     residualPilots: Boolean(residualPilot) && designFitness.designWeak === true,
     pilotTarget: residualPilot?.pilotTarget ?? residualPilot?.pilot ?? null,
     arkRulesMergeHonesty: rulesUnderContract?.mergePlanes
-      ? { active: rulesUnderContract.active === true || arkRun?.active === true, ...rulesUnderContract.mergePlanes }
+      ? { active: rulesUnderContract.active === true || arkRun?.active === true || arkOrder?.active === true, ...rulesUnderContract.mergePlanes }
       : null,
     primaryNextAction: postGreenPath?.action ?? dualTruthNext,
     activeBlockingViolations: activeBlockingCount,
@@ -218,6 +207,7 @@ export function buildReportDepthPayload(
       productHonesty,
       mergePlanes: rulesUnderContract?.mergePlanes ?? null,
       arkRun,
+      arkOrder,
       improvementCompass,
       deepModuleCoach,
     },

package/bin/lib/html-report.mjs

@@ -152,6 +152,8 @@ export function buildReportSnapshot({
   improvementCompass = null,
   /** RN08 — thin status ArkRun slice (notAScore; residual count, never a score). */
   arkRun = null,
+  /** Thin status ArkOrder slice (notAScore; residual count, never a score). */
+  arkOrder = null,
 }) {
   const layers = Array.isArray(config?.layers) ? config.layers : [];
   const rules = Array.isArray(config?.rules) ? config.rules : [];
@@ -213,6 +215,20 @@ export function buildReportSnapshot({
             : null,
     };
   }
+  if (arkOrder && typeof arkOrder === 'object' && arkOrder.notAScore === true) {
+    snapshot.arkOrder = {
+      notAScore: true,
+      present: arkOrder.active === true || arkOrder.present === true,
+      mode: arkOrder.mode === 'enforced' || arkOrder.mode === 'advisory' ? arkOrder.mode : null,
+      extraMergeTeeth: arkOrder.extraMergeTeeth === true,
+      residual:
+        typeof arkOrder.residual === 'number'
+          ? arkOrder.residual
+          : typeof arkOrder.residual?.count === 'number'
+            ? arkOrder.residual.count
+            : null,
+    };
+  }
   return snapshot;
 }