@ontrails/warden 1.0.0-beta.18 → 1.0.0-beta.19

package/src/cli.ts

@@ -5,9 +5,11 @@
  * and returns a structured report.
  */
 
-import { resolve } from 'node:path';
+import { isAbsolute, relative, resolve } from 'node:path';
 
 import type { Topo } from '@ontrails/core';
+import { deriveTopoGraph } from '@ontrails/topographer';
+import type { TopoGraph } from '@ontrails/topographer';
 import { getContourReferences } from '@ontrails/core';
 
 import type {
@@ -19,8 +21,10 @@ import type {
   WardenFormat,
   WardenLockMode,
 } from './config.js';
+import { runWardenAdapterChecks } from './adapter-check.js';
 import { resolveWardenConfig } from './config.js';
 import { isDraftMarkedFile } from './draft.js';
+import { applySafeFixesToSource, hasSafeFixEdits } from './fix.js';
 import type { DriftResult } from './drift.js';
 import { checkDrift } from './drift.js';
 import {
@@ -32,7 +36,7 @@ import {
   collectContourDefinitionIds,
   collectContourReferenceTargetsByName,
   collectCrudTableIds as collectCrudTableIdsFromAst,
-  collectCrossTargetTrailIds,
+  collectComposeTargetTrailIds,
   collectOnTargetSignalIds as collectOnTargetSignalIdsFromAst,
   collectReconcileTableIds as collectReconcileTableIdsFromAst,
   collectResourceDefinitionIds,
@@ -44,6 +48,10 @@ import {
 import { collectFileCrudCoverage } from './rules/incomplete-crud.js';
 import { wardenRules, wardenTopoRules } from './rules/index.js';
 import { getWardenRuleMetadata } from './rules/metadata.js';
+import {
+  isWardenDevPermitTestScanTarget,
+  isWardenSourceScanTarget,
+} from './rules/scan.js';
 import type {
   ProjectAwareWardenRule,
   ProjectContext,
@@ -59,6 +67,8 @@ import type { WardenImportResolution } from './resolve.js';
  * Resolved topo input for Warden runs that govern multiple apps.
  */
 export interface WardenTopoTarget {
+  /** Optional precomputed topo graph, including graph-only audit annotations. */
+  readonly graph?: TopoGraph | undefined;
   /** Stable app/topo label used to tag topo-aware diagnostics. */
   readonly name?: string | undefined;
   /** Resolved topo module to inspect. */
@@ -75,12 +85,21 @@ export interface WardenRunOptions {
   readonly config?: WardenConfigInput | undefined;
   /** CLI/config-layer app names carried through shared resolution. */
   readonly apps?: readonly string[] | undefined;
+  /** Include shared adapter authoring checks as Warden diagnostics. */
+  readonly adapterCheck?: boolean | undefined;
   /** Cumulative analysis depth for the final M1 surfaces. */
   readonly depth?: WardenDepth | undefined;
   /** Draft-state handling mode for final M1 surfaces. */
   readonly drafts?: EffectiveWardenConfig['drafts'] | undefined;
   /** Failure threshold used to compute `report.passed`. */
   readonly failOn?: WardenFailOn | undefined;
+  /**
+   * Apply safe source fixes among the run's diagnostics, writing changed files.
+   *
+   * Only `safety: 'safe'` fixes with concrete edits are applied; review-required,
+   * edit-less, and topo diagnostics stay reported but unapplied.
+   */
+  readonly fix?: boolean | undefined;
   /** Output format requested by the caller. */
   readonly format?: WardenFormat | undefined;
   /** Lockfile mode requested by the caller. */
@@ -125,11 +144,35 @@ export interface WardenRunOptions {
    * when `topo` is also supplied (see `topo` remarks).
    */
   readonly extraTopoRules?: readonly TopoAwareWardenRule[] | undefined;
+  /**
+   * Extra source rules to run in addition to the built-in registry.
+   *
+   * Primarily a test hook — production callers should register durable rules
+   * via `wardenRules` in `rules/index.ts`.
+   */
+  readonly extraSourceRules?: readonly WardenRule[] | undefined;
 }
 
 /** Backwards-compatible name for older consumers. */
 export type WardenOptions = WardenRunOptions;
 
+/**
+ * Aggregate outcome of a `--fix` pass over a run's diagnostics.
+ */
+export interface WardenFixSummary {
+  /** Diagnostics whose safe fix was applied to source. */
+  readonly applied: number;
+  /** Source files rewritten with patched content. */
+  readonly filesChanged: number;
+  /** Diagnostics carrying fix metadata left unapplied (review or edit-less). */
+  readonly skipped: number;
+}
+
+export interface WardenFixApplication extends WardenFixSummary {
+  /** Diagnostics removed from the final report because their safe fix applied. */
+  readonly appliedDiagnostics: readonly WardenDiagnostic[];
+}
+
 /**
  * Result of a warden run.
  */
@@ -148,30 +191,14 @@ export interface WardenReport {
   readonly effectiveConfig?: EffectiveWardenConfig | undefined;
   /** Resolved topo/app labels governed by this run. */
   readonly topoNames?: readonly string[] | undefined;
+  /** Safe-fix application summary, present only when a `--fix` pass ran. */
+  readonly fixes?: WardenFixSummary | undefined;
 }
 
 /**
  * Collect Warden scan targets under a directory, excluding generated and test
  * surfaces that should not contribute most committed-source diagnostics.
  */
-const isInfrastructureScanTarget = (match: string): boolean =>
-  match.endsWith('.d.ts') ||
-  match.startsWith('node_modules/') ||
-  match.startsWith('dist/') ||
-  match.startsWith('.git/');
-
-const isTestScanTarget = (match: string): boolean =>
-  match.includes('__tests__/') ||
-  match.includes('__test__/') ||
-  match.endsWith('.test.ts') ||
-  match.endsWith('.spec.ts');
-
-const isAllowedScanTarget = (match: string): boolean =>
-  !isInfrastructureScanTarget(match) && !isTestScanTarget(match);
-
-const isDevPermitTestScanTarget = (match: string): boolean =>
-  !isInfrastructureScanTarget(match) && isTestScanTarget(match);
-
 const collectFilesMatching = (
   dir: string,
   pattern: string,
@@ -187,7 +214,7 @@ const collectFilesMatching = (
 
   const files: string[] = [];
   for (const match of matches) {
-    if (isAllowedScanTarget(match)) {
+    if (isWardenSourceScanTarget(match)) {
       files.push(`${dir}/${match}`);
     }
   }
@@ -232,7 +259,7 @@ const collectDevPermitTestFiles = (dir: string): readonly string[] => {
 
   const files: string[] = [];
   for (const match of matches) {
-    if (isDevPermitTestScanTarget(match)) {
+    if (isWardenDevPermitTestScanTarget(match)) {
       files.push(`${dir}/${match}`);
     }
   }
@@ -275,7 +302,7 @@ const collectDocumentationFiles = (dir: string): readonly string[] => {
 
   const files: string[] = [];
   for (const match of matches) {
-    if (isAllowedScanTarget(match) && isDocumentationScanTarget(match)) {
+    if (isWardenSourceScanTarget(match) && isDocumentationScanTarget(match)) {
       files.push(`${dir}/${match}`);
     }
   }
@@ -291,7 +318,7 @@ interface SourceFile {
 interface MutableProjectContext {
   contourReferencesByName: Map<string, Set<string>>;
   crudTableIds: Set<string>;
-  crossTargetTrailIds: Set<string>;
+  composeTargetTrailIds: Set<string>;
   crudCoverageByEntity: Map<string, Set<string>>;
   knownContourIds: Set<string>;
   knownResourceIds: Set<string>;
@@ -309,8 +336,8 @@ interface MutableProjectContext {
 }
 
 const createMutableProjectContext = (): MutableProjectContext => ({
+  composeTargetTrailIds: new Set<string>(),
   contourReferencesByName: new Map<string, Set<string>>(),
-  crossTargetTrailIds: new Set<string>(),
   crudCoverageByEntity: new Map<string, Set<string>>(),
   crudTableIds: new Set<string>(),
   documentedImportResolutionsByFile: new Map<
@@ -369,7 +396,7 @@ const toProjectContext = (context: MutableProjectContext): ProjectContext => ({
         ),
       }
     : {}),
-  crossTargetTrailIds: context.crossTargetTrailIds,
+  composeTargetTrailIds: context.composeTargetTrailIds,
   knownContourIds: context.knownContourIds,
   knownResourceIds: context.knownResourceIds,
   knownSignalIds: context.knownSignalIds,
@@ -423,17 +450,17 @@ const collectKnownTrailIds = (
   }
 };
 
-const collectCrossedTrailIds = (
+const collectComposedTrailIds = (
   sourceCode: string,
   filePath: string,
-  crossTargetTrailIds: Set<string>
+  composeTargetTrailIds: Set<string>
 ): void => {
   const ast = parse(filePath, sourceCode);
   if (!ast) {
     return;
   }
-  for (const id of collectCrossTargetTrailIds(ast, sourceCode)) {
-    crossTargetTrailIds.add(id);
+  for (const id of collectComposeTargetTrailIds(ast, sourceCode)) {
+    composeTargetTrailIds.add(id);
   }
 };
 
@@ -619,14 +646,14 @@ const collectTopoKnownIds = (
   }
 };
 
-const collectTopoCrossesAndIntents = (
+const collectTopoComposesAndIntents = (
   appTopo: Topo,
   context: MutableProjectContext
 ): void => {
   for (const trail of appTopo.trails.values()) {
     context.trailIntentsById.set(trail.id, trail.intent);
-    for (const crossedTrailId of trail.crosses) {
-      context.crossTargetTrailIds.add(crossedTrailId);
+    for (const composedTrailId of trail.composes) {
+      context.composeTargetTrailIds.add(composedTrailId);
     }
   }
 };
@@ -649,7 +676,7 @@ const collectTopoTrailContext = (
   context: MutableProjectContext
 ): void => {
   collectTopoKnownIds(appTopo, context);
-  collectTopoCrossesAndIntents(appTopo, context);
+  collectTopoComposesAndIntents(appTopo, context);
   collectTopoContourReferences(appTopo, context);
 };
 
@@ -683,10 +710,10 @@ const collectFileTrailRelationships = (
   sourceFile: SourceFile,
   context: MutableProjectContext
 ): void => {
-  collectCrossedTrailIds(
+  collectComposedTrailIds(
     sourceFile.sourceCode,
     sourceFile.filePath,
-    context.crossTargetTrailIds
+    context.composeTargetTrailIds
   );
   collectTrailIntents(
     sourceFile.sourceCode,
@@ -952,6 +979,7 @@ const topoRuleFailureDiagnostic = (
  */
 const lintTopo = async (
   appTopo: Topo,
+  graph: TopoGraph | undefined,
   extraTopoRules: readonly TopoAwareWardenRule[],
   selector: WardenRuleSelector
 ): Promise<readonly WardenDiagnostic[]> => {
@@ -960,9 +988,21 @@ const lintTopo = async (
     ...wardenTopoRules.values(),
     ...extraTopoRules,
   ].filter((rule) => isSelectedTopoRule(rule, selector));
+  let contextGraph: TopoGraph;
+  try {
+    contextGraph = graph ?? deriveTopoGraph(appTopo);
+  } catch (error) {
+    for (const rule of rules) {
+      diagnostics.push(topoRuleFailureDiagnostic(rule, error));
+    }
+    return diagnostics;
+  }
+
   for (const rule of rules) {
     try {
-      diagnostics.push(...(await rule.checkTopo(appTopo)));
+      diagnostics.push(
+        ...(await rule.checkTopo(appTopo, { graph: contextGraph }))
+      );
     } catch (error) {
       diagnostics.push(topoRuleFailureDiagnostic(rule, error));
     }
@@ -973,11 +1013,13 @@ const lintTopo = async (
 const lintSourceFiles = (
   sourceFiles: readonly SourceFile[],
   context: ProjectContext,
+  extraSourceRules: readonly WardenRule[],
   selector: WardenRuleSelector
 ): readonly WardenDiagnostic[] => {
   const diagnostics: WardenDiagnostic[] = [];
+  const rules = [...wardenRules.values(), ...extraSourceRules];
   for (const sourceFile of sourceFiles) {
-    for (const rule of wardenRules.values()) {
+    for (const rule of rules) {
       if (
         sourceFile.kind === 'text' &&
         rule.name !== 'no-dev-permit-in-source' &&
@@ -1032,6 +1074,7 @@ const lintTopoTargets = async (
   for (const target of topoTargets) {
     const topoDiagnostics = await lintTopo(
       target.topo,
+      target.graph,
       extraTopoRules,
       selector
     );
@@ -1059,17 +1102,26 @@ const selectorIncludesTopoRules = (selector: WardenRuleSelector): boolean => {
 /**
  * Lint all files against all warden rules.
  */
+interface WardenLintResult {
+  readonly diagnostics: readonly WardenDiagnostic[];
+  readonly sourceFiles: readonly SourceFile[];
+}
+
 const lintFiles = async (
   rootDir: string,
   drafts: EffectiveWardenConfig['drafts'],
   topoTargets: readonly WardenTopoTarget[],
   extraTopoRules: readonly TopoAwareWardenRule[],
+  extraSourceRules: readonly WardenRule[],
   selector: WardenRuleSelector
-): Promise<WardenDiagnostic[]> => {
+): Promise<WardenLintResult> => {
   if (selector.tier === 'topo-aware') {
-    return [
-      ...(await lintTopoTargets(topoTargets, extraTopoRules, selector, true)),
-    ];
+    return {
+      diagnostics: [
+        ...(await lintTopoTargets(topoTargets, extraTopoRules, selector, true)),
+      ],
+      sourceFiles: [],
+    };
   }
 
   const sourceFiles = filterSourceFilesByDraftMode(
@@ -1082,7 +1134,7 @@ const lintFiles = async (
     topoTargets.map((target) => target.topo)
   );
   const allDiagnostics: WardenDiagnostic[] = [
-    ...lintSourceFiles(sourceFiles, context, selector),
+    ...lintSourceFiles(sourceFiles, context, extraSourceRules, selector),
   ];
 
   if (
@@ -1100,7 +1152,7 @@ const lintFiles = async (
     );
   }
 
-  return allDiagnostics;
+  return { diagnostics: allDiagnostics, sourceFiles };
 };
 
 const topoTargetsFromOptions = (
@@ -1205,6 +1257,12 @@ const checkDriftForTopoTargets = async (
 const shouldRunLint = (options: WardenRunOptions): boolean =>
   options.tier ? options.tier !== 'drift' : !options.driftOnly;
 
+const adapterDiagnosticsForRun = (
+  rootDir: string,
+  options: WardenRunOptions
+): readonly WardenDiagnostic[] =>
+  options.adapterCheck ? runWardenAdapterChecks(rootDir) : [];
+
 const shouldRunDrift = (
   options: WardenRunOptions,
   effectiveConfig: EffectiveWardenConfig
@@ -1252,6 +1310,101 @@ const buildCliConfigLayer = (options: WardenRunOptions): WardenConfigLayer => ({
     : { noLockMutation: options.noLockMutation }),
 });
 
+const fixSummary = (application: WardenFixApplication): WardenFixSummary => ({
+  applied: application.applied,
+  filesChanged: application.filesChanged,
+  skipped: application.skipped,
+});
+
+const filterAppliedFixDiagnostics = (
+  diagnostics: readonly WardenDiagnostic[],
+  appliedDiagnostics: readonly WardenDiagnostic[]
+): readonly WardenDiagnostic[] => {
+  if (appliedDiagnostics.length === 0) {
+    return diagnostics;
+  }
+  const applied = new Set(appliedDiagnostics);
+  return diagnostics.filter((diagnostic) => !applied.has(diagnostic));
+};
+
+const blockedDriftAfterSourceFixes = (): DriftResult => ({
+  blockedReason:
+    'Source fixes were applied; rerun Warden to refresh drift evidence.',
+  committedHash: null,
+  currentHash: 'blocked',
+  stale: true,
+});
+
+/**
+ * Apply every safe source fix among a run's diagnostics, writing patched files.
+ *
+ * Diagnostics with a safe, edit-bearing fix are grouped by file; each file is
+ * re-read so the rule's recorded offsets stay valid, patched via
+ * {@link applySafeFixesToSource}, and written back only when its source
+ * actually changed. Diagnostics that carry fix metadata but are not safe with
+ * edits (review-required or edit-less) are counted as skipped and left reported
+ * for a human or downstream regrade to resolve. Diagnostics without fix
+ * metadata — including topo diagnostics, which carry no source span — are
+ * neither applied nor counted in `skipped`.
+ */
+export const applySafeFixesToFiles = async (
+  diagnostics: readonly WardenDiagnostic[],
+  options: {
+    readonly allowedFilePaths?: ReadonlySet<string> | readonly string[];
+    readonly rootDir: string;
+  }
+): Promise<WardenFixApplication> => {
+  const rootDir = resolve(options.rootDir);
+  const allowedFilePaths =
+    options.allowedFilePaths === undefined
+      ? undefined
+      : new Set(
+          [...options.allowedFilePaths].map((filePath) => resolve(filePath))
+        );
+  const fixableByFile = new Map<string, WardenDiagnostic[]>();
+  let skipped = 0;
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.fix === undefined) {
+      continue;
+    }
+    if (hasSafeFixEdits(diagnostic)) {
+      const filePath = resolve(diagnostic.filePath);
+      const rootRelativePath = relative(rootDir, filePath);
+      const insideRoot =
+        rootRelativePath.length === 0 ||
+        (!rootRelativePath.startsWith('..') && !isAbsolute(rootRelativePath));
+      if (
+        !insideRoot ||
+        (allowedFilePaths !== undefined && !allowedFilePaths.has(filePath))
+      ) {
+        skipped += 1;
+        continue;
+      }
+      const bucket = fixableByFile.get(filePath) ?? [];
+      bucket.push(diagnostic);
+      fixableByFile.set(filePath, bucket);
+    } else {
+      skipped += 1;
+    }
+  }
+
+  let applied = 0;
+  const appliedDiagnostics: WardenDiagnostic[] = [];
+  let filesChanged = 0;
+  for (const [filePath, group] of fixableByFile) {
+    const source = await Bun.file(filePath).text();
+    const result = applySafeFixesToSource(source, group);
+    applied += result.applied.length;
+    appliedDiagnostics.push(...result.applied);
+    if (result.changed) {
+      await Bun.write(filePath, result.patched);
+      filesChanged += 1;
+    }
+  }
+
+  return { applied, appliedDiagnostics, filesChanged, skipped };
+};
+
 /**
  * Run all warden checks and return a structured report.
  */
@@ -1280,39 +1433,64 @@ export const runWarden = async (
   } satisfies WardenRuleSelector;
   const runLint = shouldRunLint(options);
   const runDrift = shouldRunDrift(options, effectiveConfig);
+  const lintResult = runLint
+    ? await lintFiles(
+        rootDir,
+        effectiveConfig.drafts,
+        topoTargets,
+        options.extraTopoRules ?? [],
+        options.extraSourceRules ?? [],
+        selector
+      )
+    : { diagnostics: [], sourceFiles: [] };
+  const adapterDiagnostics = adapterDiagnosticsForRun(rootDir, options);
 
   const rawDiagnostics = [
     ...configDiagnostics,
     ...optionDiagnostics,
-    ...(runLint
-      ? await lintFiles(
-          rootDir,
-          effectiveConfig.drafts,
-          topoTargets,
-          options.extraTopoRules ?? [],
-          selector
-        )
-      : []),
+    ...lintResult.diagnostics,
+    ...adapterDiagnostics,
   ];
   const allDiagnostics = rawDiagnostics.map(withDiagnosticGuidance);
-  const drift = runDrift
-    ? await checkDriftForTopoTargets(rootDir, topoTargets)
-    : null;
+  const fixApplication = options.fix
+    ? await applySafeFixesToFiles(allDiagnostics, {
+        allowedFilePaths: lintResult.sourceFiles.map(
+          (sourceFile) => sourceFile.filePath
+        ),
+        rootDir,
+      })
+    : undefined;
+  const reportDiagnostics = filterAppliedFixDiagnostics(
+    allDiagnostics,
+    fixApplication?.appliedDiagnostics ?? []
+  );
+  let drift: DriftResult | null = null;
+  if (runDrift) {
+    drift =
+      fixApplication !== undefined && fixApplication.filesChanged > 0
+        ? blockedDriftAfterSourceFixes()
+        : await checkDriftForTopoTargets(rootDir, topoTargets);
+  }
 
-  const errorCount = allDiagnostics.filter(
+  const errorCount = reportDiagnostics.filter(
     (d) => d.severity === 'error'
   ).length;
-  const warnCount = allDiagnostics.filter((d) => d.severity === 'warn').length;
+  const warnCount = reportDiagnostics.filter(
+    (d) => d.severity === 'warn'
+  ).length;
   const topoNames =
     topoTargets.length > 0
       ? topoTargets.map((target) => target.name ?? target.topo.name)
       : undefined;
 
   return {
-    diagnostics: allDiagnostics,
+    diagnostics: reportDiagnostics,
     drift,
     effectiveConfig,
     errorCount,
+    ...(fixApplication === undefined
+      ? {}
+      : { fixes: fixSummary(fixApplication) }),
     passed: reportPassed({
       drift,
       errorCount,
@@ -1384,7 +1562,7 @@ const formatDriftSection = (drift: DriftResult | null): string[] => {
     return [`Drift: blocked (${drift.blockedReason})`, ''];
   }
   const label = drift.stale
-    ? 'Drift: trails.lock is stale (regenerate with `trails topo compile`)'
+    ? 'Drift: trails.lock is stale (regenerate with `trails compile`)'
     : 'Drift: clean';
   return [label, ''];
 };

package/src/command.ts

@@ -128,18 +128,22 @@ const readEnumValue = <T extends string>({
 };
 
 export interface ParsedWardenCommand {
+  readonly adapterCheck: boolean;
   readonly ci: boolean;
   readonly cli: WardenConfigLayer;
   readonly configPath?: string | undefined;
   readonly diagnostics: readonly WardenDiagnostic[];
+  readonly fix: boolean;
   readonly prePush: boolean;
   readonly rootDir?: string | undefined;
 }
 
 const createEmptyParsedCommand = (message: string): ParsedWardenCommand => ({
+  adapterCheck: false,
   ci: false,
   cli: {},
   diagnostics: [diagnostic({ message })],
+  fix: false,
   prePush: false,
 });
 
@@ -149,10 +153,12 @@ const tokenValue = (token: {
   typeof token.value === 'string' ? token.value : undefined;
 
 interface CommandParserState {
+  adapterCheck?: boolean | undefined;
   readonly apps: string[];
   readonly diagnostics: WardenDiagnostic[];
   readonly cli: MutableWardenConfigLayer;
   configPath?: string | undefined;
+  fix?: boolean | undefined;
   rootDir?: string | undefined;
 }
 
@@ -232,12 +238,14 @@ const parseTokens = (
       allowPositionals: false,
       args: [...args],
       options: {
+        'adapter-check': { type: 'boolean' },
         apps: { multiple: true, short: 'a', type: 'string' },
         ci: { type: 'boolean' },
         'config-path': { type: 'string' },
         depth: { type: 'string' },
         drafts: { type: 'string' },
         'fail-on': { type: 'string' },
+        fix: { type: 'boolean' },
         format: { type: 'string' },
         lock: { type: 'string' },
         'no-lock-mutation': { type: 'boolean' },
@@ -384,10 +392,18 @@ const applyCommandOption = (
     state.apps.push(...splitApps(value));
     return;
   }
+  if (token.name === 'adapter-check') {
+    state.adapterCheck = true;
+    return;
+  }
   if (token.name === 'config-path') {
     state.configPath = value;
     return;
   }
+  if (token.name === 'fix') {
+    state.fix = true;
+    return;
+  }
   if (token.name === 'no-lock-mutation') {
     state.cli.noLockMutation = true;
     return;
@@ -437,12 +453,14 @@ export const parseWardenCommandArgs = (
   }
 
   return {
+    adapterCheck: state.adapterCheck ?? false,
     ci,
     cli: cleanUndefined(
       state.cli as Record<string, unknown>
     ) as WardenConfigLayer,
     configPath: state.configPath,
     diagnostics: state.diagnostics,
+    fix: state.fix ?? false,
     prePush,
     rootDir: state.rootDir,
   };
@@ -788,24 +806,30 @@ const effectiveConfigNeedsTopo = (depth: WardenDepth): boolean =>
   depth === 'topo' || depth === 'all';
 
 const buildRunOptions = ({
+  adapterCheck,
   cli,
   config,
   env,
+  fix,
   rootDir,
   topos,
 }: {
+  readonly adapterCheck: boolean;
   readonly cli: WardenConfigLayer;
   readonly config?: WardenConfigInput | undefined;
   readonly env: EnvRecord;
+  readonly fix: boolean;
   readonly rootDir: string;
   readonly topos: readonly WardenTopoTarget[];
 }): WardenRunOptions => ({
   ...cleanUndefined({
+    adapterCheck,
     apps: cli.apps,
     config,
     depth: cli.depth,
     drafts: cli.drafts,
     failOn: cli.failOn,
+    fix,
     format: cli.format,
     lock: cli.lock,
     noLockMutation: cli.noLockMutation,
@@ -904,9 +928,11 @@ export const runWardenCommand = async ({
     : { diagnostics: [], topos: [] };
   const report = await runWarden(
     buildRunOptions({
+      adapterCheck: parsed.adapterCheck,
       cli: parsed.cli,
       config: loadedConfig.config,
       env,
+      fix: parsed.fix,
       rootDir,
       topos: topoResolution.topos,
     })

package/src/drift.ts

@@ -95,7 +95,7 @@ export const checkDrift = async (
       ) ?? null;
     if (lockManifest !== null && topoArtifact === null) {
       return blockedDrift(
-        'trails.lock does not contain a topo.lock artifact. Regenerate with `trails topo compile`.'
+        'trails.lock does not contain a topo.lock artifact. Regenerate with `trails compile`.'
       );
     }
     const readStoredHash = (): string | undefined => {