arkgate 4.6.4 → 4.6.6

package/bin/lib/graph-blind.mjs

@@ -16,8 +16,16 @@ import { normalize } from './scan-files.mjs';
 
 const MAX_LIST = 8;
 const MAX_FILE_BYTES = 256 * 1024;
-/** Full AST scan stays off huge trees so doctor resident warm keeps the 500 ms UX ceiling. */
-const MAX_FULL_SCAN_FILES = 2500;
+/** Floor for tiny trees. Large included Next.js trees must still scan. */
+const GRAPH_SCAN_FLOOR = 2500;
+/** Hard cap so a 10k fixture cannot blow the doctor resident warm UX ceiling. */
+const GRAPH_SCAN_HARD_CAP = 8000;
+
+/** Threshold scales with the included tree — never a hard 2500 that defers a 3300-file app. */
+export function graphScanLimit(includedCount) {
+  const count = Number(includedCount) || 0;
+  return Math.min(GRAPH_SCAN_HARD_CAP, Math.max(GRAPH_SCAN_FLOOR, count));
+}
 const LEXICAL_GATE = /\b(?:import|require)\s*\(|\bimport\s+\w+\s*=\s*require\s*\(/;
 
 /**
@@ -123,9 +131,9 @@ export function detectGraphBlindSpots(ts, root, files = []) {
     };
   }
 
-  // Large-tree deferral: re-reading every path for an advisory sensor would blow the
-  // doctorResidentWarm 500 ms absolute UX ceiling at the 10k perf fixture.
-  if (files.length > MAX_FULL_SCAN_FILES) {
+  // Large-tree deferral: only above the proportional cap (included count, floor 2500, cap 8000).
+  const scanLimit = graphScanLimit(files.length);
+  if (files.length > scanLimit) {
     return {
       available: true,
       advisory: true,
@@ -136,7 +144,7 @@ export function detectGraphBlindSpots(ts, root, files = []) {
       otherNonLiteralCount: 0,
       truncated: 0,
       edges: [],
-      note: `Graph-blind full scan deferred (${files.length} files > ${MAX_FULL_SCAN_FILES}). Non-literal dynamic import/require remain unresolvable in architecture analysis; advisory incomplete-graph honesty is not enumerated at this scale.`,
+      note: `Graph-blind full scan deferred (${files.length} files > proportional limit ${scanLimit}). Non-literal dynamic import/require remain unresolvable in architecture analysis; advisory incomplete-graph honesty is not enumerated at this scale.`,
     };
   }
 
@@ -177,6 +185,7 @@ export function detectGraphBlindSpots(ts, root, files = []) {
     available: true,
     advisory: true,
     blockerGrade: false,
+    deferred: false,
     count: edges.length,
     templateInterpolationCount,
     otherNonLiteralCount,

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

@@ -313,17 +313,25 @@ function deepModuleCoachHtml(coach) {
 
 function stewardNudgeHtml(nudge) {
   if (!nudge || nudge.notAScore !== true) return '';
+  const unfinished = Boolean(
+    nudge.emptyStewardsPastGrace || (nudge.needsStewards && (nudge.stewardCount ?? 0) === 0)
+  );
   const ask =
-    (nudge.needsStewards || nudge.drift) && typeof nudge.ask === 'string' && nudge.ask
+    (nudge.needsStewards || nudge.drift || nudge.emptyStewardsPastGrace) &&
+    typeof nudge.ask === 'string' &&
+    nudge.ask
       ? `<p>${esc(nudge.ask)}</p>`
       : '<p class="muted">No steward list gap (advisory).</p>';
   const next =
     typeof nudge.nextAction === 'string' && nudge.nextAction
       ? `<p class="muted">Next: ${esc(nudge.nextAction)}</p>`
       : '';
+  const qualifier = unfinished
+    ? '(unfinished residual — changes finished, not check valid)'
+    : '(advisory — never changes the check valid bit)';
   return `
   <section class="section card" data-advisory="stewardNudge">
-    <h2>Stewards <span class="muted">(advisory — never changes the verdict)</span></h2>
+    <h2>Stewards <span class="muted">${qualifier}</span></h2>
     ${ask}
     ${next}
     <p class="muted">GitHub handle or email. Never invent names. Always <code>notAScore</code>.</p>

package/bin/lib/html-report.mjs

@@ -110,7 +110,7 @@ export function baselineSignalHint(signal) {
 export function modeBadgeHint(mode) {
   switch (String(mode || '').toLowerCase()) {
     case 'enforce':
-      return 'Contract matches the tree: cores are required where populated, coverage is honest, gates can hold the line.';
+      return 'Contract matches the tree on checked import edges. Required GitHub status (or an advisory-only ack) is what adopts the merge boundary.';
     case 'adapt':
       return 'Contract is live but still aligning (optional cores with files, empty cores, or presentation-bag false green).';
     case 'suggest':
@@ -255,7 +255,7 @@ export function computeReportFitness({ coverage, violations, ok, enforcement, co
   const modeBlurb = {
     suggest: 'Starter shape — expand layers as the codebase grows.',
     adapt: 'Contract is live; raise governed coverage or match real folders.',
-    enforce: 'Contract governs the tree. Gates can honestly hold the line.',
+    enforce: 'Contract matches the tree on checked import edges. Merge is adopted only with a required GitHub status or an advisory-only ack.',
   }[mode];
   const scoreCoverage = governedPercent == null ? 50 : governedPercent;
   const scoreClean =

package/bin/lib/install-migrate.mjs

@@ -635,6 +635,16 @@ export function runInstallAgentGates(args) {
       homeResults.push({ relativePath: dir, status: 'failed' });
     }
     if (homeResults.length === 0) {
+      const skillName = (skill) =>
+        Array.isArray(skill) ? skill[0] : skill?.name || skill;
+      const projectHasCatalog = skills.some((skill) =>
+        fs.existsSync(path.join(root, '.agents', 'skills', skillName(skill), 'SKILL.md'))
+      );
+      if (projectHasCatalog) {
+        console.log(
+          '  Project .agents/skills already has this catalog; home write is optional. Prefer the project copy.'
+        );
+      }
       for (const result of installSkillCatalog({
         directory: dir,
         skills,

package/bin/lib/invariant-coverage.mjs

@@ -79,11 +79,14 @@ export function evaluateInvariantCoverage(input) {
         if (!covered || partial) {
             // Enforced + proven uncovered → failsStrict; partial always advisory (never fake green).
             const failsStrict = inv.mode === 'enforced' && !partial;
+            const kind = testGlobsMissing || testFiles.length === 0 ? 'never-had-tests' : 'tests-disappeared';
             violations.push({
                 ruleId: 'INVARIANT_UNCOVERED',
                 message: partial
-                    ? `Invariant ${inv.id} coverage cannot be proven (test globs missing or empty); reporting partial, not covered.`
-                    : `Invariant ${inv.id} is not covered by a test title or declared symbol.`,
+                    ? `Invariant ${inv.id} coverage cannot be proven (test globs missing or empty); reporting partial, not covered (never-had-tests).`
+                    : kind === 'tests-disappeared'
+                        ? `Invariant ${inv.id} is not covered by a test title or declared symbol (tests-disappeared — suite exists).`
+                        : `Invariant ${inv.id} is not covered by a test title or declared symbol (never-had-tests).`,
                 file: inv.provenance.sourceFile,
                 line: 1,
                 arkruleId: inv.id,
@@ -91,6 +94,7 @@ export function evaluateInvariantCoverage(input) {
                 fromLayer: inv.provenance.layer,
                 severity: failsStrict ? 'error' : 'warning',
                 failsStrict,
+                kind,
             });
         }
     }

package/bin/lib/managed-upgrade.mjs

@@ -134,7 +134,7 @@ const HOST_SIGNALS = {
   ],
   codex: ['.codex/hooks.json', '.codex/config.toml', '.agents/skills/ark-upgrade/SKILL.md'],
   grok: ['.grok/config.toml', '.grok/hooks/ark-write-gate.json', '.grok/skills/ark-upgrade/SKILL.md'],
-  antigravity: ['.agents/hooks.json', '.agents/skills/ark-upgrade/SKILL.md'],
+  antigravity: ['.agents/hooks.json'],
   opencode: ['opencode.json', '.opencode/skills/ark-upgrade/SKILL.md'],
   windsurf: ['.windsurf/rules/ark.md', '.windsurf/workflows/ark-upgrade.md'],
   cline: ['.clinerules/ark.md', '.clinerules/workflows/ark-upgrade.md'],
@@ -307,8 +307,13 @@ function resolveSelection(root, options, manifest) {
   const explicit = normalizeToolsList(options.tools);
   const compactHost = compactRouterHost(root);
   let hosts;
-  if (explicit.length > 0) hosts = normalizeHosts(explicit);
-  else if (manifest) hosts = normalizeHosts(manifest.hosts);
+  if (explicit.length > 0) {
+    const kept = manifest
+      ? normalizeHosts(manifest.hosts)
+      : detectedManagedHosts(root);
+    // Preview/apply default is hosts-keep: --tools unions, never retires other hosts.
+    hosts = normalizeHosts([...kept, ...explicit]);
+  } else if (manifest) hosts = normalizeHosts(manifest.hosts);
   else if (compactHost !== null) hosts = compactHost === 'none' ? [] : normalizeHosts([compactHost]);
   else {
     hosts = detectedManagedHosts(root);

package/bin/lib/mcp-adoption.mjs

@@ -17,6 +17,11 @@ import { detectActiveAgentHost, skillTemplateNames } from './skill-install.mjs';
 import { detectDeployPathQuality } from './deploy-path.mjs';
 import { collectWeakestLinkGaps } from './weakest-link.mjs';
 import { codexRuntimeActivation, withCiProviderEvidence } from './enforcement-state.mjs';
+import {
+  classifyAdopted,
+  readAdoptionStance,
+  NOT_ADOPTED_NEXT_ACTION,
+} from './adoption-stance.mjs';
 
 export { detectDeployPathQuality };
 
@@ -528,6 +533,20 @@ export function collectAdoptionGaps(root, config, coverage) {
     gaps.push(g);
   }
 
+  const adoptedKind = classifyAdopted({
+    stance: readAdoptionStance(root),
+    github: weakest.github,
+  });
+  if (adoptedKind === 'not-adopted') {
+    gaps.push({
+      id: 'adoption-stance-missing',
+      severity: 'warn',
+      message:
+        'Merge boundary not adopted: require a GitHub status on arkgate-check --strict-merge, or write .ark/adoption-stance.json with stance: "advisory-only".',
+      fix: NOT_ADOPTED_NEXT_ACTION,
+    });
+  }
+
   return {
     gaps,
     hosts,

package/bin/lib/policy-delta-io.mjs

@@ -42,7 +42,7 @@ function repositoryRoot(root) {
   return result.status === 0 ? result.stdout.trim() : null;
 }
 
-function discoverLocalBaseRef(root) {
+export function discoverLocalBaseRef(root) {
   const top = repositoryRoot(root);
   if (!top) return null;
   const remoteHead = runGit(top, ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD']);

package/bin/lib/post-green-path.mjs

@@ -92,10 +92,14 @@ export function mergePostGreenTopActions(actions, postGreen) {
 
 /**
  * Whether doctor may print “Healthy — nothing to do”.
+ * Empty actions + !designWeak is not Healthy unless the merge boundary is
+ * required-merge (advisory-only ack is adopted but not this Healthy string).
  * @param {{ designWeak?: boolean } | null | undefined} designFitness
  * @param {string[]} topActions
+ * @param {string | null | undefined} adopted
  */
-export function isDoctorHealthyNothingToDo(designFitness, topActions = []) {
+export function isDoctorHealthyNothingToDo(designFitness, topActions = [], adopted = null) {
   if (designFitness?.designWeak) return false;
+  if (adopted !== 'required-merge') return false;
   return !topActions.some(Boolean);
 }

package/bin/lib/presets.mjs

@@ -179,6 +179,28 @@ export const PERSISTENCE_PATH_PATTERNS = Object.freeze([
  * Application orchestration under lib without the whole-src-lib vacuum.
  * Never use lone `src/**` or bare `src/lib/**` as Application on Next/event trees.
  */
+/** Types and constants — SharedKernel, not Application vacuum. */
+export const SHARED_KERNEL_PATH_PATTERNS = Object.freeze([
+  'src/shared/**',
+  'src/types/**',
+  'src/**/types.ts',
+  'src/**/constants.ts',
+  'src/**/types/**',
+  'src/**/constants/**',
+  '**/shared/kernel/**',
+  'src/shared/kernel/**',
+]);
+
+/** Wiring / DI / bootstrap — CompositionRoot, not Domain. */
+export const COMPOSITION_ROOT_PATH_PATTERNS = Object.freeze([
+  'src/**/composition/**',
+  'src/**/factories/**',
+  'src/**/container.ts',
+  'src/**/bootstrap.ts',
+  '**/composition/**',
+  '**/factories/**',
+]);
+
 export const APPLICATION_LIB_ORCHESTRATION_PATTERNS = Object.freeze([
   'src/lib/actions/**',
   'src/lib/services/**',

package/bin/lib/product-copy.mjs

@@ -13,17 +13,20 @@ export const LEFTOVER_DESIGN_LABEL = 'leftover design work';
  * Operating-mode title for humans (and doctor JSON `designFitness.label` prefix).
  * @param {string|null|undefined} mode suggest|adapt|enforce
  * @param {boolean} leftoverDesign
+ * @param {boolean} [stewardsUnset]
  */
-export function operatingModeTitle(mode, leftoverDesign) {
+export function operatingModeTitle(mode, leftoverDesign, stewardsUnset) {
   const light = String(mode || 'enforce').toUpperCase();
-  return leftoverDesign ? `${light} · ${LEFTOVER_DESIGN_LABEL}` : light;
+  if (leftoverDesign) return `${light} · ${LEFTOVER_DESIGN_LABEL}`;
+  if (stewardsUnset) return `${light} · stewards unset`;
+  return light;
 }
 
 /** Short HTML/doctor badge text. */
 export const LEFTOVER_DESIGN_BADGE = LEFTOVER_DESIGN_LABEL;
 
 export const POST_GREEN_HUMAN =
-  'Imports check out, but the design is still messy. Map leftover work with /ark-explore shape-focus, then apply one small refactor via /ark-autopilot. A clean import check is not done; pattern bets are never auto-applied.';
+  'Imports check out, but the design is still messy. Next: /ark-explore, then one small refactor with /ark-autopilot and your OK.';
 
 export const POST_GREEN_LEDE =
   'Import rules are clean, but leftover design work remains. That does not fail the check — it only means “done” is still wrong until you tidy shape.';

package/bin/lib/remediation.mjs

@@ -41,17 +41,57 @@ export const KNOWN_FIX_CLASSES = [
     'break-cycle',
     'review-contract',
 ];
+const PURE_SHARED_RE = /(^|\/)(constants|types|enums|shared-types|shared\/(?:types|constants)|test-projects)(\/|\.|$)|(?:^|\/)[^/]*(?:constants|types)(?:\.[cm]?[jt]sx?)?$/i;
+const KERNEL_EMIT_RE = /(^|\/)(?:kernel(?:\/|$)|events?(?:\/|\.|$)|bootstrap(?:\.[cm]?[jt]sx?)?$|emitter(?:\.[cm]?[jt]sx?)?$)|(?:^|\/)(?:intents?|publish)(?:\/|\.|$)/i;
+const USE_CASE_RE = /(use-?cases?|usecases?|application|orchestrat|services?|handlers?)(\/|\.|$)/i;
+export function classifyLayerImportKind(target, extra) {
+    const value = String(target ?? '')
+        .replace(/\\/g, '/')
+        .trim();
+    const from = String(extra?.fromLayer ?? '');
+    const to = String(extra?.toLayer ?? '');
+    if (PURE_SHARED_RE.test(value))
+        return 'pure-shared';
+    if (from === 'PersistenceAdapters' &&
+        (KERNEL_EMIT_RE.test(value) || /events?|intents?|kernel|bootstrap/i.test(`${to} ${value}`))) {
+        return 'kernel-emit';
+    }
+    if (USE_CASE_RE.test(value) ||
+        ((from === 'DomainModel' || from === 'ApplicationOrchestration') &&
+            to === 'PersistenceAdapters')) {
+        return 'use-case';
+    }
+    if (!value)
+        return 'unknown';
+    return 'unknown';
+}
+export function layerImportNextAction(violation) {
+    if (violation.typeOnly || violation.targetTypeOnlyExports || violation.namedBindingsTypeOnly) {
+        return 'Move the referenced type to a mutually allowed layer, use `import type`, then preflight again.';
+    }
+    if (violation.peerIsolation) {
+        return 'Extract the shared dependency to a shared layer, test at the public interface, then preflight again.';
+    }
+    const kind = classifyLayerImportKind(typeof violation.target === 'string' ? violation.target : '', {
+        fromLayer: typeof violation.fromLayer === 'string' ? violation.fromLayer : undefined,
+        toLayer: typeof violation.toLayer === 'string' ? violation.toLayer : undefined,
+    });
+    if (kind === 'pure-shared') {
+        return 'Adopt the imported constants/types/pure module into DomainModel or SharedKernel (do not inject a port). Then preflight again.';
+    }
+    if (kind === 'kernel-emit') {
+        return 'Persistence must not emit. Inject a port or move the event map to SharedTypes; do not import kernel/events/bootstrap from a repository. Then preflight again.';
+    }
+    if (kind === 'use-case' || violation.portProofEligible) {
+        return `Define a port in ${violation.fromLayer ?? 'the source layer'}, inject the ${violation.toLayer ?? 'outer-layer'} implementation, test at the public interface, then preflight again.`;
+    }
+    return 'Classify the import: if it is constants/types/pure, adopt into DomainModel or SharedKernel; define a port only if the target is a real use-case. Then preflight again.';
+}
 /** One deterministic re-entry action shared by human and machine denial surfaces. */
 export function deterministicNextAction(violation) {
     switch (violation.ruleId) {
         case 'LAYER_IMPORT_VIOLATION':
-            if (violation.typeOnly || violation.targetTypeOnlyExports || violation.namedBindingsTypeOnly) {
-                return 'Move the referenced type to a mutually allowed layer, use `import type`, then preflight again.';
-            }
-            if (violation.peerIsolation) {
-                return 'Extract the shared dependency to a shared layer, test at the public interface, then preflight again.';
-            }
-            return `Define a port in ${violation.fromLayer ?? 'the source layer'}, inject the ${violation.toLayer ?? 'outer-layer'} implementation, test at the public interface, then preflight again.`;
+            return layerImportNextAction(violation);
         case 'FORBIDDEN_GLOBAL':
             return `Inject ${violation.target ?? 'the capability'} through a port, test at the public interface, then preflight again.`;
         case 'CAPABILITY_VIOLATION':
@@ -222,9 +262,33 @@ export function enrichViolationWithFixClass(violation) {
                     'Cross-slice import blocked (peerIsolation). Do not import another feature/context directly — extract shared code to a shared layer, or coordinate via events/ports. Moving code across slices is a judgment call, not a mechanical auto-fix.';
             }
             else {
-                enriched.fixClass = 'port-inversion';
-                enriched.effort = 'medium';
-                enriched.enthusiastHint = `${violation.fromLayer ?? 'This layer'} must not import ${violation.toLayer ?? 'that layer'} directly. Define an interface (port) where you need the capability and inject the implementation from the outer layer.`;
+                const kind = classifyLayerImportKind(typeof violation.target === 'string' ? violation.target : '', {
+                    fromLayer: typeof violation.fromLayer === 'string' ? violation.fromLayer : undefined,
+                    toLayer: typeof violation.toLayer === 'string' ? violation.toLayer : undefined,
+                });
+                if (kind === 'pure-shared') {
+                    enriched.fixClass = 'file-move';
+                    enriched.effort = 'small';
+                    enriched.enthusiastHint =
+                        'This import is constants/types/pure — adopt it into DomainModel or SharedKernel. Do not inject a port.';
+                }
+                else if (kind === 'kernel-emit') {
+                    enriched.fixClass = 'port-inversion';
+                    enriched.effort = 'medium';
+                    enriched.enthusiastHint =
+                        'A repository must not import kernel/events/bootstrap. Persistence does not emit — inject a port or move the map to SharedTypes.';
+                }
+                else if (kind === 'use-case' || violation.portProofEligible) {
+                    enriched.fixClass = 'port-inversion';
+                    enriched.effort = 'medium';
+                    enriched.enthusiastHint = `${violation.fromLayer ?? 'This layer'} must not import ${violation.toLayer ?? 'that layer'} directly. Define an interface (port) where you need the capability and inject the implementation from the outer layer.`;
+                }
+                else {
+                    enriched.fixClass = 'review-contract';
+                    enriched.effort = 'medium';
+                    enriched.enthusiastHint =
+                        'Do not assume a port. If the target is constants/types/pure, adopt it into Domain or SharedKernel; define a port only for a real use-case.';
+                }
             }
             break;
         case 'FORBIDDEN_GLOBAL':

package/bin/lib/skill-install.mjs

@@ -688,7 +688,9 @@ export function assessCodexSkillParity(root) {
 
   const repoNeedsAttention =
     repoInPlay && (repo.missing > 0 || repo.stale > 0 || repo.legacyPromptsOnly);
+  const repoCatalogComplete = repoInPlay && repo.missing === 0 && !repo.legacyPromptsOnly;
   const homeNeedsAttention =
+    !repoCatalogComplete &&
     newerHomeCatalog === null &&
     homeInPlay &&
     (home.missing > 0 ||

package/bin/lib/snippet-analysis.mjs

@@ -1,6 +1,26 @@
 /** Fail-closed completeness evidence for one proposed source snippet. */
 import { ANALYSIS_COMPLETENESS } from './analysis-completeness.mjs';
 
+export function flattenTsParseDiagnostics(ts, diagnostics, sourceFile) {
+  if (!Array.isArray(diagnostics) || !ts) return [];
+  return diagnostics.map((diagnostic) => {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    let line = 1;
+    let column = 1;
+    if (typeof diagnostic.start === 'number' && sourceFile?.getLineAndCharacterOfPosition) {
+      const pos = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+      line = (pos.line ?? 0) + 1;
+      column = (pos.character ?? 0) + 1;
+    }
+    return {
+      line,
+      column,
+      message: String(message || '').trim() || 'parse error',
+      code: diagnostic.code,
+    };
+  });
+}
+
 function finding(ruleId, message, file, nextAction) {
   return {
     ruleId,
@@ -54,6 +74,11 @@ export function validateSnippetAnalysis({ gate, ts, source, context = {} }) {
     if (!Array.isArray(parsed.parseDiagnostics)) throw new Error('parse diagnostics unavailable');
     const diagnosticCount = parsed.parseDiagnostics.length;
     if (diagnosticCount > 0) {
+      const tsDiagnostics = flattenTsParseDiagnostics(ts, parsed.parseDiagnostics, parsed);
+      const first = tsDiagnostics[0];
+      const detail = first
+        ? `line ${first.line}: ${first.message}`
+        : `${diagnosticCount} parse diagnostic(s)`;
       return {
         mode: 'lexical-compatibility',
         valid: false,
@@ -62,18 +87,25 @@ export function validateSnippetAnalysis({ gate, ts, source, context = {} }) {
         completenessReasons: [
           {
             code: 'ANALYSIS_PARSE_INCOMPLETE',
-            message: `The proposed source has ${diagnosticCount} parse diagnostic(s).`,
+            message: `The proposed source has ${diagnosticCount} parse diagnostic(s). ${detail}`,
             ...(file ? { file } : {}),
+            line: first?.line,
+            tsDiagnostics,
           },
         ],
         violations: [
           ...base.violations,
-          finding(
-            'ANALYSIS_PARSE_INCOMPLETE',
-            `Analysis partial: proposed source has ${diagnosticCount} parse diagnostic(s).`,
-            file,
-            'Fix the syntax until the TypeScript parser reports zero diagnostics, then validate again.'
-          ),
+          {
+            ...finding(
+              'ANALYSIS_PARSE_INCOMPLETE',
+              `Analysis partial: ${detail}`,
+              file,
+              'Incremental mid-edit parse errors are normal. Finish the source, then re-run `npx arkgate-check` (or the write hook). Do not call ark_prepare_change from a hook deny.'
+            ),
+            line: first?.line ?? 1,
+            column: first?.column ?? 1,
+            evidence: { tsDiagnostics, diagnosticCount },
+          },
         ],
       };
     }
@@ -87,7 +119,7 @@ export function validateSnippetAnalysis({ gate, ts, source, context = {} }) {
         {
           code: 'LEXICAL_EVIDENCE_INCOMPLETE',
           message:
-            'Single-file validation cannot prove project module resolution or complete candidate evidence; use ark_prepare_change for a parity-capable verdict.',
+            'Single-file validation cannot prove project module resolution. The write hook is already the verdict, or re-run `npx arkgate-check --root . --config ark.config.json`. Do not call ark_prepare_change from a hook deny.',
           ...(file ? { file } : {}),
         },
       ],

package/bin/lib/start-preview.mjs

@@ -151,7 +151,7 @@ export function renderStartPreview(preview, options = {}) {
     console.log('Apply this plan with: arkgate start --apply');
   }
   if (preview.analysis) {
-    console.log(`Your project looks like: ${preview.analysis.label} (${preview.analysis.archetype}, confidence ${preview.analysis.confidence}).`);
+    console.log(`Your project looks like: ${preview.analysis.label}.`);
   }
   console.log(applying ? 'Files create/edit/delete:' : 'Files to create/edit/delete:');
   if (preview.changes.length === 0) console.log('  (none)');
@@ -159,34 +159,24 @@ export function renderStartPreview(preview, options = {}) {
     console.log(`  ${change.action.padEnd(6)} ${change.path}`);
   }
   if (!applying) {
-    console.log('Commands in the approved setup plan:');
-    for (const command of preview.commands) console.log(`  ${command}`);
+    console.log('Setup: install package + host gates (see --json).');
+    console.log('Preview does not write. Apply installs CI.');
   }
-  console.log('Host guarantees:');
-  for (const guarantee of preview.hostGuarantees) console.log(`  ${guarantee}`);
   if (preview.runtimeActivation) {
-    console.log('Codex MCP CONFIGURED — RUNTIME NOT VERIFIED.');
-    console.log(`  Runtime activation: ${JSON.stringify(preview.runtimeActivation)}`);
-    console.log(`  Restart Codex, then call ark_identity with expectedRoot "${preview.root}".`);
-    console.log('  Do not trust MCP verdicts before the project identity matches.');
+    console.log('Host: Codex is configured but not verified yet. Restart the host, then confirm this project.');
   }
   if (preview.unresolvedDecisions.length > 0) {
     console.log('Unresolved decisions:');
     for (const decision of preview.unresolvedDecisions) console.log(`  ${decision}`);
   }
-  console.log('Details (optional):');
-  console.log(`Projected governed coverage: ${preview.projectedCoverage.percent ?? 'unknown'}% (${preview.projectedCoverage.classifiedFiles}/${preview.projectedCoverage.totalFiles} files)`);
-  const budget = preview.setupBudget;
-  const arkrulesNote =
-    budget.arkrulesFiles > 0 ? ` (+${budget.arkrulesFiles} arkrules)` : '';
-  const gateCount = budget.gateFiles ?? budget.files;
-  console.log(
-    `Compact setup budget: ${gateCount}/${budget.maxFiles} gate files${arkrulesNote}, ${budget.bytes}/${budget.maxBytes} bytes${budget.ok ? '' : ' (exceeded)'}.`
-  );
-  for (const change of preview.changes) {
-    console.log(`  ${change.action.padEnd(6)} ${change.path}  ${change.afterHash ?? '(deleted)'}`);
-  }
-  if (!applying) {
+  if (applying) {
+    const percent = preview.projectedCoverage?.percent;
+    if (percent != null) console.log(`Projected governed coverage: ${percent}%`);
+    const verified = (preview.hostGuarantees || []).find((line) =>
+      String(line).startsWith('Hard-write hook verified')
+    );
+    if (verified) console.log(verified);
+  } else {
     console.log('Review complete file contents with --json.');
   }
 }

package/bin/lib/status-command.mjs

@@ -26,6 +26,7 @@ import { readBaseline } from './violations.mjs';
 import { reportsDir, readJsonSafe } from './html-report.mjs';
 import { summarizeRulesUnderContract } from './rules-under-contract.mjs';
 import { collectVsBaseFacts, discoverTeamBaseRef } from './team-parliament-io.mjs';
+import { classifyAdopted, readAdoptionStance } from './adoption-stance.mjs';
 
 function sha256Hex(value) {
   return createHash('sha256').update(value, 'utf8').digest('hex');
@@ -387,6 +388,21 @@ export function collectStatusFacts(options = {}) {
       latest?.leftoverDesignWork === true ||
       latest?.designFitness?.designWeak === true ||
       latest?.doctor?.designFitness?.designWeak === true,
+    adopted:
+      options.adopted ??
+      classifyAdopted({
+        stance: readAdoptionStance(resolvedRoot),
+        github: {
+          requiredStatusConfigured: writePath?.enforcementState?.ciMerge?.required === true,
+          arkCheckRequired: writePath?.enforcementState?.ciMerge?.required === true,
+        },
+        ci: {
+          state:
+            writePath?.enforcementState?.ciMerge?.required === true
+              ? 'required'
+              : undefined,
+        },
+      }),
     improvementCompass,
     vsBase: (() => {
       const vsRef = typeof options.vs === 'string' ? options.vs.trim() : '';

package/bin/lib/status-manifest.mjs

@@ -242,9 +242,15 @@ export function resolveStatusNextAction(facts, binding, activation, lastCheck, r
             summary: 'ArkRules residual remains frozen — review inventory debt without claiming a score.',
         };
     }
+    if (facts.adopted === 'required-merge' || facts.adopted === 'advisory-only-acked') {
+        return {
+            id: 'stay-enforced',
+            summary: 'Contract looks enforceable for this session — keep writing through the gate and re-check after structural edits.',
+        };
+    }
     return {
-        id: 'stay-enforced',
-        summary: 'Contract looks enforceable for this session — keep writing through the gate and re-check after structural edits.',
+        id: 'require-ci-merge-status',
+        summary: 'Make arkgate-check --strict-merge a required GitHub status, or write .ark/adoption-stance.json with stance: "advisory-only".',
     };
 }
 export function buildStatusManifest(facts) {