arkgate 4.8.7 → 4.8.9

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

@@ -11,6 +11,102 @@
 import { extractArkOrderGenericUpdatesFromSource, extractArkOrderIngestWritesXiFromSource, extractArkOrderPlaneCallsFromSource, extractArkOrderReleaseKeyCountsFromSource, extractArkOrderXiFieldWritesFromSource, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
 import { extraMergeTeethAllowed, } from './extra-merge-teeth.mjs';
 import { deterministicNextAction } from './remediation.mjs';
+/**
+ * XIWRITE-001: same engine as `globToRegExp` in src/domain/layerMatch.ts.
+ * Inlined so generate:cli-pure emits a self-contained bin/lib/ark-order-sensors.mjs
+ * (layerMatch is derived to bin/ark-layer-match.mjs, not a bin/lib sibling).
+ */
+const appliesToRegexpCache = new Map();
+function escapeAppliesToLiteral(ch) {
+    return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+function normalizeAppliesToGlob(pattern) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const c = pattern[i];
+        if (c === '\\' && i + 1 < pattern.length) {
+            const next = pattern[i + 1];
+            if ('*?{}[],'.includes(next) || next === '\\') {
+                out += '\\' + next;
+                i += 1;
+                continue;
+            }
+            out += '/';
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+function appliesToBracesBalanced(glob) {
+    let depth = 0;
+    for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === '\\') {
+            i += 1;
+            continue;
+        }
+        if (c === '{')
+            depth += 1;
+        else if (c === '}') {
+            depth -= 1;
+            if (depth < 0)
+                return false;
+        }
+    }
+    return depth === 0;
+}
+function globToRegExp(pattern) {
+    const cached = appliesToRegexpCache.get(pattern);
+    if (cached)
+        return cached;
+    const glob = normalizeAppliesToGlob(pattern);
+    const useBraces = appliesToBracesBalanced(glob);
+    let out = '';
+    let braceDepth = 0;
+    for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === '\\' && i + 1 < glob.length) {
+            out += escapeAppliesToLiteral(glob[i + 1]);
+            i += 1;
+        }
+        else if (c === '*') {
+            if (glob[i + 1] === '*') {
+                if (glob[i + 2] === '/') {
+                    out += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    out += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                out += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            out += '[^/]';
+        }
+        else if (c === '{' && useBraces) {
+            out += '(?:';
+            braceDepth += 1;
+        }
+        else if (c === '}' && useBraces && braceDepth > 0) {
+            out += ')';
+            braceDepth -= 1;
+        }
+        else if (c === ',' && useBraces && braceDepth > 0) {
+            out += '|';
+        }
+        else {
+            out += escapeAppliesToLiteral(c);
+        }
+    }
+    const re = new RegExp(`^${out}$`);
+    appliesToRegexpCache.set(pattern, re);
+    return re;
+}
 export const ARKORDER_TIER1_SENSOR_IDS = [
     'arkorder-missing-plane',
     'arkorder-kernel-in-domain',
@@ -31,6 +127,11 @@ export const ARKORDER_RULE_IDS = {
     'arkorder-information-budget': 'ARKORDER_INFORMATION_BUDGET',
     'arkorder-xi-ttl': 'ARKORDER_XI_TTL',
 };
+function matchesArkOrderAppliesTo(file, appliesTo) {
+    if (!appliesTo || appliesTo.length === 0)
+        return true;
+    return appliesTo.some((pattern) => globToRegExp(pattern).test(file));
+}
 function isDomainRoleLayer(layer, intentPrefixes = []) {
     const name = layer.trim();
     if (/^domain(?:model)?$/i.test(name) || /^domain(?=[A-Z_\-\s])/i.test(name))
@@ -103,9 +204,6 @@ export function evaluateArkOrderSensors(input) {
         findings.push(finding(extra, 'arkorder-generic-update', update.file, update.line, `Generic ${update.method}() on the order plane rewrites ξ; Haken forbids it.`, { target: update.method }, teethAllowed));
     }
     const xiKeys = extra.xiKeys ?? [];
-    if (xiKeys.length > extra.maxXiKeys) {
-        findings.push(finding(extra, 'arkorder-too-many-params', 'ark.config.json', 1, `arkOrder.xiKeys has ${xiKeys.length} keys; maxXiKeys is ${extra.maxXiKeys} (few slow modes).`, { target: String(xiKeys.length) }, teethAllowed));
-    }
     for (const release of input.releaseKeyCounts ?? []) {
         if (release.keyCount <= extra.maxXiKeys)
             continue;
@@ -119,6 +217,8 @@ export function evaluateArkOrderSensors(input) {
         const fromLayer = input.layerForFile(write.file);
         if (!fromLayer || !managed.has(fromLayer))
             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.sort((left, right) => left.file.localeCompare(right.file) ||

package/bin/lib/config-extras.mjs

@@ -42,6 +42,7 @@ export const ARK_ORDER_SCHEMA_DEF = {
         managedLayers: { ...stringArraySchema, default: [] },
         maxXiKeys: { type: 'integer', minimum: 1, default: 7 },
         xiKeys: { ...stringArraySchema, default: [] },
+        appliesTo: { ...stringArraySchema, default: [] },
     },
 };
 function isObject(value) {

package/bin/lib/contract-smells.mjs

@@ -41,7 +41,7 @@ export const CONTRACT_SMELL_OUTCOMES = Object.freeze({
   'contract-lateral-adapter-allow':
     'One adapter layer may import another adapter family directly — shared mappers/aliases will pile up in the wrong place. Move shared shapes into Domain (or a shared kernel) instead of adapter-to-adapter reach.',
   'contract-dead-rule':
-    'A rule enforces nothing: it points at a layer that matches no files or does not exist, or both sides are the same layer. Fix the layer patterns or delete the rule.',
+    'A rule enforces nothing: it points at a layer that matches no files or does not exist, or is a same-layer allow (classic same-layer deny is also a no-op). A same-layer peerIsolation deny is a live wall, not a dead rule.',
 });
 
 export const CONTRACT_SMELL_ACKS_PATH = '.ark/contract-smell-acks.json';
@@ -277,14 +277,20 @@ export function analyzeContractSmells(
     }
   }
 
-  // 4) Dead rules: self edges (the gate ignores same-layer rules), unknown layers,
-  //    or — when coverage is known — layers matching zero files (optional layers exempt).
+  // 4) Dead rules: self-allow and classic same-layer deny (the gate ignores
+  //    those), unknown layers, or — when coverage is known — layers matching
+  //    zero files (optional layers exempt). `peerIsolation: true` + `allowed:
+  //    false` is a live self-edge wall, not a dead rule.
   for (const r of rules) {
     const edge = `${r.from}->${r.to}`;
     const ackEdge = ackMatchable(r.from, r.to) ? edge : null;
     if (r.from === r.to) {
-      add('contract-dead-rule', ackEdge, `rule:${edge} (self edge has no effect)`);
-      continue;
+      const livePeerIsolationWall = r.peerIsolation === true && r.allowed === false;
+      if (!livePeerIsolationWall) {
+        add('contract-dead-rule', ackEdge, `rule:${edge} (self edge has no effect)`);
+        continue;
+      }
+      // Live slice wall on a self-edge — still check unknown/empty layers.
     }
     for (const side of [r.from, r.to]) {
       if (side.length === 0) continue;
@@ -409,7 +415,7 @@ function fixFor(id) {
     case 'contract-lateral-adapter-allow':
       return `Move shared shapes into Domain/shared kernel and drop the lateral allow (/ark-adopt), or acknowledge with a reason in ${CONTRACT_SMELL_ACKS_PATH}.`;
     case 'contract-dead-rule':
-      return 'Fix the layer patterns so the layer matches real files, or delete the stale/self rule via /ark-adopt.';
+      return 'Fix the layer patterns so the layer matches real files, or delete a stale self-allow / classic self-deny via /ark-adopt. Never delete a live peerIsolation wall (`peerIsolation: true` with `allowed: false`).';
     default:
       return 'Review the contract edge via /ark-adopt; never weaken the gate to silence a smell.';
   }

package/bin/lib/doctor-human.mjs

@@ -13,6 +13,23 @@ import { enforcementDoctorLines } from './enforcement-state.mjs';
 import { analysisIncompleteStatement } from './analysis-completeness.mjs';
 import { skillGapsForActiveHost, detectCodexHomeGap, codexConcernIsActive } from './agent-gates.mjs';
 import { agentHomeConcernIsActive } from './agent-homes.mjs';
+import { REQUIRED_GATE_WORKFLOW } from './gate-files.mjs';
+
+function displayedMissingGates(gatesMissing, view) {
+  const list = Array.isArray(gatesMissing) ? gatesMissing : [];
+  const hideGlob = Boolean(
+    view?.ciNotFailClosed?.workflowFile ||
+      view?.ciNotFailClosed?.error === 'ci-not-fail-closed' ||
+      view?.ciMergeBoundary?.ci?.workflowPresent
+  );
+  return hideGlob ? list.filter((item) => item !== REQUIRED_GATE_WORKFLOW) : list;
+}
+
+function ciNotFailClosedNotice(view) {
+  const file = view?.ciNotFailClosed?.workflowFile;
+  if (!file) return null;
+  return `CI not fail-closed: ${file} — remove the skippable if:, or write .ark/adoption-stance.json with stance: advisory-only`;
+}
 
 function lineWith(ok, warn, bad, color) {
   return (mark, text) => console.log(`  ${mark} ${text}`);
@@ -52,6 +69,8 @@ export function printDoctorCompactHuman(view) {
     gatesMissing,
     violations,
   } = view;
+  const listedMissing = displayedMissingGates(gatesMissing, view);
+  const skippableCi = ciNotFailClosedNotice(view);
 
   console.log(color.bold(`Ark doctor — ${path.basename(path.resolve(root)) || '.'}`));
   if (!analysisComplete) line(warn, analysisIncompleteStatement(completeness));
@@ -123,15 +142,17 @@ export function printDoctorCompactHuman(view) {
   }
 
   const hostRed =
-    gatesMissing.length > 0 ||
+    listedMissing.length > 0 ||
     Boolean(writePath.gap) ||
-    writePathHonesty?.softWriteHost === true;
+    writePathHonesty?.softWriteHost === true ||
+    Boolean(skippableCi);
   if (hostRed) {
     console.log('');
     console.log(color.bold('Host / CI'));
     if (writePath.activeHost) line(' ', `Active host: ${writePath.activeHost}`);
-    if (gatesMissing.length > 0) line(bad, `Missing gates: ${gatesMissing.join(', ')}`);
-    else if (writePath.gap || writePathHonesty?.softWriteHost) {
+    if (listedMissing.length > 0) line(bad, `Missing gates: ${listedMissing.join(', ')}`);
+    if (skippableCi) line(warn, skippableCi);
+    else if (listedMissing.length === 0 && (writePath.gap || writePathHonesty?.softWriteHost)) {
       line(warn, 'Local writes are advisory; required CI is the merge boundary.');
     }
   }
@@ -212,6 +233,8 @@ export function printDoctorDetailsHuman(view) {
     staleRunners,
     adoption,
   } = view;
+  const listedMissing = displayedMissingGates(gatesMissing, view);
+  const skippableCi = ciNotFailClosedNotice(view);
   const modeTitle = operatingModeTitle(operatingMode, designFitness.designWeak, stewardUnfinished);
 
   console.log('');
@@ -385,9 +408,11 @@ export function printDoctorDetailsHuman(view) {
 
   console.log('');
   console.log(color.bold('Gates & skills'));
-  if (gatesMissing.length === 0) line(ok, 'Shared gate artifacts found on disk (AGENTS.md, .mcp.json, CI); runtime activation is reported separately');
-  else {
-    line(bad, `Missing gates: ${gatesMissing.join(', ')}`);
+  if (listedMissing.length === 0 && !skippableCi) {
+    line(ok, 'Shared gate artifacts found on disk (AGENTS.md, .mcp.json, CI); runtime activation is reported separately');
+  } else {
+    if (listedMissing.length > 0) line(bad, `Missing gates: ${listedMissing.join(', ')}`);
+    if (skippableCi) line(warn, skippableCi);
   }
   const humanSkillGaps = skillGapsForActiveHost(skillGaps);
   const legacyCodex = humanSkillGaps.some((g) => g.tool === 'codex' && g.legacyPromptsOnly);

package/bin/lib/doctor-next-actions.mjs

@@ -7,10 +7,20 @@ import { skillGapsForActiveHost } from './agent-gates.mjs';
 import { agentHomeConcernIsActive, agentHomeRefreshCommand } from './agent-homes.mjs';
 import { mergePostGreenTopActions } from './post-green-path.mjs';
 import { ADOPTED_NOT, NOT_ADOPTED_NEXT_ACTION } from './adoption-stance.mjs';
+import { REQUIRED_GATE_WORKFLOW } from './gate-files.mjs';
+
+function missingGateFiles(ctx) {
+  const list = Array.isArray(ctx.gatesMissing) ? ctx.gatesMissing : [];
+  if (ctx.ciNotFailClosed) {
+    return list.filter((item) => item !== REQUIRED_GATE_WORKFLOW);
+  }
+  return list;
+}
 
 export function collectDoctorNextActions(ctx) {
   const actions = [];
-  const gatesInstalled = Array.isArray(ctx.gatesMissing) && ctx.gatesMissing.length === 0;
+  const missingFiles = missingGateFiles(ctx);
+  const gatesInstalled = missingFiles.length === 0;
   const planAEmpty = !ctx.activeCount;
   const notAdopted = ctx.adopted !== 'required-merge' && ctx.adopted !== 'advisory-only-acked';
   if (notAdopted || ctx.adopted === ADOPTED_NOT || ctx.adopted == null) {
@@ -55,9 +65,18 @@ export function collectDoctorNextActions(ctx) {
     );
   }
   if (ctx.writePath?.gap?.fix && !gatesInstalled) actions.push(ctx.writePath.gap.fix);
-  if (!gatesInstalled && ctx.gatesMissing.length > 0) {
+  if (!gatesInstalled && missingFiles.length > 0) {
     actions.push(`install gates (${arkCommand(ctx.root, 'ark-check', '--install-agent-gates')})`);
   }
+  if (ctx.ciNotFailClosed) {
+    const file = ctx.ciNotFailClosed.workflowFile;
+    actions.push(
+      ctx.ciNotFailClosed.nextAction ||
+        (file
+          ? `Remove the skippable if: in ${file}, or write .ark/adoption-stance.json with stance: advisory-only`
+          : 'Remove the skippable if:, or write .ark/adoption-stance.json with stance: advisory-only')
+    );
+  }
   const humanSkillGaps = skillGapsForActiveHost(ctx.skillGaps);
   const legacyCodex = humanSkillGaps.some((g) => g.tool === 'codex' && g.legacyPromptsOnly);
   const remainingGaps = humanSkillGaps.filter(

package/bin/lib/gate-files.mjs

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { codexProjectMcpIsValid } from './codex-home.mjs';
-import { enforcingArkRunText } from './github-enforcement.mjs';
+import { enforcingArkRunText, runsArkCheck } from './github-enforcement.mjs';
 
 export const __packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 export const __arkCheckCli = path.join(__packageRoot, 'bin', 'ark-check.mjs');
@@ -120,7 +120,8 @@ export const REQUIRED_GATE_FILES = [
   'AGENTS.md',
   '.mcp.json',
 ];
-const REQUIRED_GATE_WORKFLOW = '.github/workflows/*.yml running ark-check';
+export const REQUIRED_GATE_WORKFLOW = '.github/workflows/*.yml running ark-check';
+export const CI_NOT_FAIL_CLOSED_ERROR = 'ci-not-fail-closed';
 const COMPACT_ROUTER = /<!--\s*arkgate:compact-router host=([a-z]+)\s*-->/;
 const FAIL_CLOSED_ARK_FLAG = /(?:^|\s)--(?:strict|strict-merge|require-gates)(?=\s|$)/;
 
@@ -584,27 +585,112 @@ function withVerifiedDependencyJobs(content) {
   return lines.join('\n');
 }
 
-export function hasArkWorkflow(root) {
+function isGuaranteedJobCondition(value) {
+  const text = unquoteYamlScalar(value);
+  return (
+    /^(?:\$\{\{\s*)?always\(\)(?:\s*\}\})?$/i.test(text) ||
+    /^(?:true|\$\{\{\s*true\s*\}\})$/i.test(text)
+  );
+}
+
+function neutralizeSkippableJobControls(content) {
+  const { lines, jobs } = workflowJobSections(content);
+  for (const job of jobs) {
+    const condition = jobProperty(lines, job, 'if');
+    if (condition && !isGuaranteedJobCondition(condition.value)) {
+      lines[condition.index] = lines[condition.index].replace(
+        /^(\s*(?:"if"|'if'|if):\s*).*$/i,
+        '$1true'
+      );
+    }
+    const continuation = jobProperty(lines, job, 'continue-on-error');
+    if (continuation && !/^['"]?false['"]?$/i.test(unquoteYamlScalar(continuation.value))) {
+      lines[continuation.index] = lines[continuation.index].replace(
+        /^(\s*(?:"continue-on-error"|'continue-on-error'|continue-on-error):\s*).*$/i,
+        '$1false'
+      );
+    }
+  }
+  return lines.join('\n');
+}
+
+function workflowMentionsArkAction(content) {
+  return /^\s*(?:-\s+)?uses:\s*['"]?pedroknigge\/arkgate@/im.test(String(content));
+}
+
+function listWorkflowYamlFiles(root) {
   const workflowsDir = path.join(root, '.github', 'workflows');
-  if (!fs.existsSync(workflowsDir)) return false;
+  if (!fs.existsSync(workflowsDir)) return [];
+  try {
+    return fs.readdirSync(workflowsDir).filter((file) => /\.ya?ml$/i.test(file));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Presence vs fail-closed. A skippable `if:` still means the YAML exists.
+ * `failClosed` matches `hasArkWorkflow` (merge line). `present` is any
+ * ark-check / arkgate action workflow, including draft-skip jobs.
+ */
+export function inspectArkCiGate(root) {
+  const failClosedFiles = [];
+  const presentFiles = [];
   const declaredScript = architectureScript(root);
-  const script = isFailClosedArchitectureScript(declaredScript) ? declaredScript : '';
-  return fs
-    .readdirSync(workflowsDir)
-    .filter((file) => /\.ya?ml$/i.test(file))
-    .some((file) => {
-      try {
-        const content = fs.readFileSync(path.join(workflowsDir, file), 'utf8');
-        return FAIL_CLOSED_ARK_FLAG.test(
-          enforcingArkRunText(
-            withVerifiedDependencyJobs(withFailClosedArkActions(content)),
-            script
-          )
-        );
-      } catch {
-        return false;
-      }
-    });
+  const failClosedScript = isFailClosedArchitectureScript(declaredScript)
+    ? declaredScript
+    : '';
+  const workflowsDir = path.join(root, '.github', 'workflows');
+  for (const file of listWorkflowYamlFiles(root)) {
+    let content = '';
+    try {
+      content = fs.readFileSync(path.join(workflowsDir, file), 'utf8');
+    } catch {
+      continue;
+    }
+    const prepared = withVerifiedDependencyJobs(withFailClosedArkActions(content));
+    const failClosed = FAIL_CLOSED_ARK_FLAG.test(
+      enforcingArkRunText(prepared, failClosedScript)
+    );
+    const visible = withVerifiedDependencyJobs(
+      neutralizeSkippableJobControls(withFailClosedArkActions(content))
+    );
+    const present =
+      failClosed ||
+      runsArkCheck(visible, declaredScript) ||
+      workflowMentionsArkAction(content);
+    const relativePath = `.github/workflows/${file}`;
+    if (failClosed) failClosedFiles.push(relativePath);
+    if (present) presentFiles.push(relativePath);
+  }
+  return {
+    failClosed: failClosedFiles.length > 0,
+    present: presentFiles.length > 0,
+    failClosedFiles,
+    presentFiles,
+    workflowFile:
+      presentFiles.find((file) => !failClosedFiles.includes(file)) ??
+      presentFiles[0] ??
+      null,
+  };
+}
+
+export function hasArkWorkflow(root) {
+  return inspectArkCiGate(root).failClosed;
+}
+
+export function ciNotFailClosed(root) {
+  const ci = inspectArkCiGate(root);
+  if (!ci.present || ci.failClosed) return null;
+  const workflowFile = ci.workflowFile;
+  const named = workflowFile || REQUIRED_GATE_WORKFLOW;
+  return {
+    error: CI_NOT_FAIL_CLOSED_ERROR,
+    workflowFile,
+    workflowFiles: ci.presentFiles,
+    nextAction: `Remove the skippable if: in ${named}, or write .ark/adoption-stance.json with stance: advisory-only`,
+    message: `CI is not fail-closed. Workflow ${named} runs ark-check but a skippable if: is not a merge line.`,
+  };
 }
 
 export function missingGates(root) {
@@ -615,7 +701,7 @@ export function missingGates(root) {
   if (compactHost && !hasCompactHostRegistration(root, compactHost)) {
     missing.push(`compact host registration (${compactHost})`);
   }
-  if (!hasArkWorkflow(root)) missing.push(REQUIRED_GATE_WORKFLOW);
+  if (!inspectArkCiGate(root).present) missing.push(REQUIRED_GATE_WORKFLOW);
   return missing;
 }
 

package/bin/lib/managed-upgrade.mjs

@@ -494,8 +494,12 @@ export function planManagedUpgrade(root, options = {}) {
       action: canApply ? (currentScoped == null ? 'create' : 'update') : 'none',
       willApply: canApply,
       blocked,
+      // Raw scoped bytes. state/willApply use identity, not these hashes.
       beforeHash: hash(currentScoped == null ? null : Buffer.from(currentScoped)),
       afterHash: hash(Buffer.from(desiredScoped)),
+      beforeIdentity:
+        currentScoped == null ? null : managedContentIdentity(currentScoped, catalogAsset.kind),
+      afterIdentity: managedContentIdentity(desiredScoped, catalogAsset.kind),
       containerBeforeHash: hash(currentFile),
       [AFTER_CONTENT]: desiredFile,
     };
@@ -531,6 +535,8 @@ export function planManagedUpgrade(root, options = {}) {
       blocked: false,
       beforeHash: recorded.baseHash,
       afterHash: null,
+      beforeIdentity: recorded.contentIdentity ?? null,
+      afterIdentity: null,
       containerBeforeHash: null,
     });
   }
@@ -834,7 +840,9 @@ function assertAssetUnchanged(root, asset) {
 export function applyManagedUpgrade(root, plan, expectedPlanDigest) {
   const resolvedRoot = path.resolve(root);
   if (resolvedRoot !== plan.root) throw new Error('managed upgrade plan root mismatch');
-  if (plan.summary.blocked > 0) return publicPlan(plan, { blocked: true });
+  if (plan.summary.blocked > 0) {
+    return publicPlan(plan, { blocked: true, reasonCode: 'managed-consent-required' });
+  }
   const wouldWrite = plan.summary.wouldWrite ?? 0;
   // Content already matches: unbound --apply is a no-op (exit success), not a digest error.
   if (!expectedPlanDigest || expectedPlanDigest !== plan.planDigest) {

package/bin/lib/upgrade-command.mjs

@@ -603,10 +603,23 @@ export function runUpgradeCommand(args, dependencies) {
     return 2;
   }
   if (applied.blocked) {
-    if (args.json) console.log(JSON.stringify(applied, null, 2));
-    else renderManagedUpgrade(applied, {
-      next: 'Preview again with --accept-conflicts, then use that preview\'s exact next command.',
-    });
+    const command = buildUpgradeNextCommand(
+      { ...args, acceptConflicts: true },
+      applied.planDigest
+    );
+    if (args.json) {
+      console.log(
+        managedUpgradeJson(applied, {
+          blocked: true,
+          reasonCode: applied.reasonCode ?? 'managed-consent-required',
+          nextCommand: command,
+        })
+      );
+    } else {
+      renderManagedUpgrade(applied, {
+        next: 'Preview again with --accept-conflicts, then use that preview\'s exact next command.',
+      });
+    }
     return 1;
   }
   if (applied.nothingToApply && !applied.applied) {

package/dist/{configTypes-0eHpocR3.d.ts → configTypes-j7so8B4O.d.ts}

@@ -105,12 +105,24 @@ type ArkConfigArkOrder = {
     mode: ArkConfigArkOrderMode;
     planeRoots: string[];
     managedLayers: string[];
+    /**
+     * Haken cap on one `release()` / `assertXiKeyCap` (default 7).
+     * Not a cap on the `xiKeys` watchlist length.
+     */
     maxXiKeys: number;
     /**
      * Slow product keys the team can already name (plan, cost code, protocol).
      * Optional. Empty → `ARKORDER_XI_FIELD_WRITE` stays silent.
+     * Repo-wide watchlist — not compared to `maxXiKeys`.
      */
     xiKeys: string[];
+    /**
+     * Optional globs that narrow ξ field-write observation inside `managedLayers`.
+     * Same glob engine as `layers[].patterns`. Absence or empty → every file in
+     * those layers. Non-empty → emit only when the layer is managed AND the file
+     * matches at least one glob.
+     */
+    appliesTo?: string[];
 };
 type ArkConfig = {
     $schema: string;

package/dist/{diagnosticCatalog-wDAH08gH.d.ts → diagnosticCatalog-BrkOiwCk.d.ts}

@@ -1,5 +1,5 @@
-import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-BK47clMl.js';
-import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-0eHpocR3.js';
+import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-Djbs3KjE.js';
+import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-j7so8B4O.js';
 
 /** Versioned public result contract shared by every ArkGate enforcement adapter. */
 /**
@@ -409,7 +409,7 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
 };
 
 /** ArkGate library version — single source of truth. */
-declare const version = "4.8.7";
+declare const version = "4.8.9";
 
 /**
  * AI Code Gate (basic).