arkgate 2.9.2 → 2.11.0

package/bin/ark.mjs

@@ -32,22 +32,33 @@ function parseArgs(argv) {
     strict: true,
     install: true,
     help: false,
+    version: false,
+  };
+
+  const requireValue = (flag, index) => {
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith('-')) {
+      throw new Error(`Missing value for ${flag}. Run ark --help for usage.`);
+    }
+    return value;
   };
 
   // Scan from the first user token (index 2) so a leading flag like `ark --help` is
   // recognized: the command is the first NON-dash argument, not blindly argv[2].
   for (let i = 2; i < argv.length; i += 1) {
     const arg = argv[i];
-    if (arg === '--root') args.root = path.resolve(argv[++i]);
+    if (arg === '--root') args.root = path.resolve(requireValue(arg, i++));
     else if (arg === '--yes' || arg === '-y') args.yes = true;
     else if (arg === '--force') args.force = true;
     else if (arg === '--no-strict') args.strict = false;
     else if (arg === '--no-install') args.install = false;
-    else if (arg === '--preset') args.preset = argv[++i];
-    else if (arg === '--archetype') args.archetype = argv[++i];
-    else if (arg === '--tools') args.tools = argv[++i];
+    else if (arg === '--preset') args.preset = requireValue(arg, i++);
+    else if (arg === '--archetype') args.archetype = requireValue(arg, i++);
+    else if (arg === '--tools') args.tools = requireValue(arg, i++);
     else if (arg === '--help' || arg === '-h' || arg === 'help') args.help = true;
+    else if (arg === '--version' || arg === '-V') args.version = true;
     else if (!arg.startsWith('-') && args.command === undefined) args.command = arg;
+    else throw new Error(`Unknown argument: ${arg}. Run ark --help for usage.`);
   }
 
   return args;
@@ -88,6 +99,15 @@ Non-interactive (no TTY): uses the same defaults as --yes — never calls readli
 `;
 }
 
+function cliVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8'));
+    return typeof pkg.version === 'string' ? pkg.version : 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
 // The package-manager command that adds arkgate as a dev dependency.
 // Prefer an explicit version/range when pin already chose one (avoid pin=^2.9.0 then
 // `npm i arkgate@latest` rewriting package.json to a different range).
@@ -627,7 +647,17 @@ async function start(args) {
 }
 
 async function main() {
-  const args = parseArgs(process.argv);
+  let args;
+  try {
+    args = parseArgs(process.argv);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (args.version) {
+    console.log(cliVersion());
+    return 0;
+  }
   if (args.help || !args.command) {
     console.log(usage());
     return 0;

package/bin/lib/agent-gates.mjs

@@ -22,7 +22,7 @@ import {
   createElevenLayerConfig,
   applyFrameworkLayoutOverlays,
 } from '../ark-shared.mjs';
-import { CORE_LAYER_NAMES } from './core-ratchet.mjs';
+import { CORE_LAYER_NAMES } from './core-layers.mjs';
 import { falseGreenAdoptionGap } from './field-install.mjs';
 import {
   assessCodexHomeMcp,
@@ -184,7 +184,11 @@ export function hasArkWorkflow(root) {
     .some((file) => {
       try {
         const content = fs.readFileSync(path.join(workflowsDir, file), 'utf8');
-        return /\bark-check\b/.test(content) || /\bcheck:architecture\b/.test(content);
+        return (
+          /\bark-check\b/.test(content) ||
+          /\bcheck:architecture\b/.test(content) ||
+          /\buses\s*:\s*['"]?[^'"\s#]+\/arkgate@/i.test(content)
+        );
       } catch {
         return false;
       }
@@ -362,8 +366,8 @@ export function checkArgsForRoot(root, { requireGates = false } = {}) {
   const baselineFlag = fs.existsSync(path.join(root, '.ark-baseline.json'))
     ? ' --baseline .ark-baseline.json'
     : '';
-  const gatesFlag = requireGates ? ' --require-gates' : '';
-  return `--root . --config ark.config.json --strict-config${baselineFlag}${gatesFlag}`;
+  const profile = requireGates ? '--strict' : '--strict-config';
+  return `--root . --config ark.config.json ${profile}${baselineFlag}`;
 }
 
 // Field-install helpers live in field-install.mjs (keep agent-gates scannable).
@@ -702,7 +706,9 @@ export function claudeSettings(root) {
           hooks: [
             {
               type: 'command',
-              command: `${runner} ${PREFERRED_MCP_BIN} --hook --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`,
+              // W4: --hook-repair emits ARK_REPAIR_JSON / ARK_AUTOPATCH_JSON on deny
+              // (still exit 2 — never silent write). Omit --hook-repair for reject-only prose.
+              command: `${runner} ${PREFERRED_MCP_BIN} --hook --hook-repair --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`,
             },
           ],
         },
@@ -758,7 +764,8 @@ export function grokHooks(root) {
             {
               type: 'command',
               timeout: 30,
-              command: `${runner} ${PREFERRED_MCP_BIN} --hook --root "${grokRoot}" --config ark.config.json`,
+              // W4: --hook-repair → structured autoPatch on deny (hard block still).
+              command: `${runner} ${PREFERRED_MCP_BIN} --hook --hook-repair --root "${grokRoot}" --config ark.config.json`,
             },
           ],
         },
@@ -1284,15 +1291,160 @@ function collectCiWorkflowTexts(root) {
   return texts;
 }
 
+/**
+ * W5 — Write-path capability surface for doctor (stable additive JSON).
+ *
+ * Detects whether installed agent gates expose:
+ *   - MCP prepare-write / validate_code (autoPatch) tools
+ *   - PreToolUse hook in reject-only vs repair mode (--hook-repair / ARK_HOOK_REPAIR)
+ *
+ * Never claims silent apply; "repair" means host can re-inject a patch after hard deny.
+ *
+ * @returns {{
+ *   mode: 'repair' | 'reject-only' | 'mcp-only' | 'none',
+ *   prepareWrite: boolean,
+ *   autoPatch: boolean,
+ *   hookPresent: boolean,
+ *   hookRepair: boolean,
+ *   mcpPresent: boolean,
+ *   evidence: string[],
+ *   gap: null | { id: string, severity: string, message: string, fix: string },
+ * }}
+ */
+export function detectWritePathCapabilities(root) {
+  const evidence = [];
+  let hookPresent = false;
+  let hookRepair = false;
+
+  const hookFiles = [
+    '.claude/settings.json',
+    '.grok/hooks/ark-write-gate.json',
+  ];
+  for (const rel of hookFiles) {
+    const abs = path.join(root, rel);
+    if (!fs.existsSync(abs)) continue;
+    let text = '';
+    try {
+      text = fs.readFileSync(abs, 'utf8');
+    } catch {
+      continue;
+    }
+    // PreToolUse / write-gate command referencing ark(-gate)?-mcp --hook
+    if (
+      /--hook\b/.test(text) ||
+      /\b(ark|arkgate)-mcp\b[\s\S]{0,80}--hook\b/.test(text) ||
+      /\b--hook\b[\s\S]{0,80}\b(ark|arkgate)-mcp\b/.test(text)
+    ) {
+      hookPresent = true;
+      evidence.push(rel);
+    }
+    if (
+      /--hook-repair\b/.test(text) ||
+      /ARK_HOOK_REPAIR\s*=\s*['"]?(1|true|yes|on)/i.test(text)
+    ) {
+      hookRepair = true;
+      if (!evidence.includes(rel)) evidence.push(rel);
+    }
+  }
+
+  let mcpPresent = false;
+  const mcpFiles = ['.mcp.json', '.cursor/mcp.json', '.grok/config.toml'];
+  for (const rel of mcpFiles) {
+    const abs = path.join(root, rel);
+    if (!fs.existsSync(abs)) continue;
+    let text = '';
+    try {
+      text = fs.readFileSync(abs, 'utf8');
+    } catch {
+      continue;
+    }
+    if (
+      /\b(ark|arkgate)-mcp\b/.test(text) ||
+      /mcp_servers\.ark\b/.test(text) ||
+      /"ark"\s*:\s*\{/.test(text) ||
+      /mcpServers[\s\S]*\bark\b/.test(text)
+    ) {
+      mcpPresent = true;
+      evidence.push(rel);
+    }
+  }
+
+  // Package tools when MCP is wired: ark_prepare_write + validate_code(autoPatch).
+  // Hook repair emits machine-readable autoPatch without silent write.
+  const prepareWrite = mcpPresent;
+  const autoPatch = mcpPresent || hookRepair;
+
+  /** @type {'repair' | 'reject-only' | 'mcp-only' | 'none'} */
+  let mode = 'none';
+  if (hookPresent && hookRepair) mode = 'repair';
+  else if (hookPresent && !hookRepair) mode = 'reject-only';
+  else if (mcpPresent) mode = 'mcp-only';
+
+  let gap = null;
+  if (mode === 'none') {
+    gap = {
+      id: 'write-path-none',
+      severity: 'warn',
+      message:
+        'Write path is not installed — no PreToolUse hook and no Ark MCP. Agents write without architecture gate or prepare-write.',
+      fix: arkCommand(root, 'ark-check', '--install-agent-gates'),
+    };
+  } else if (mode === 'reject-only') {
+    gap = {
+      id: 'write-path-reject-only',
+      severity: 'info',
+      message: mcpPresent
+        ? 'PreToolUse hook is reject-only (hard block, no ARK_REPAIR_JSON). MCP still exposes prepare-write/autoPatch — enable --hook-repair so the write boundary itself can re-inject patches.'
+        : 'Write path is reject-only (hard block with prose; no repair payload). Enable --hook-repair or ARK_HOOK_REPAIR=1 so hosts can re-inject patches without full re-draft.',
+      fix: arkCommand(
+        root,
+        'ark-check',
+        '--install-agent-gates --tools claude,grok --force'
+      ),
+    };
+  } else if (mode === 'mcp-only') {
+    gap = {
+      id: 'write-path-mcp-only',
+      severity: 'info',
+      message:
+        'MCP exposes prepare-write / autoPatch tools, but no PreToolUse write hook is installed — enforcement is advisory unless the agent calls tools.',
+      fix: arkCommand(root, 'ark-check', '--install-agent-gates --tools claude,grok'),
+    };
+  }
+
+  return {
+    mode,
+    prepareWrite,
+    autoPatch,
+    hookPresent,
+    hookRepair,
+    mcpPresent,
+    evidence: [...new Set(evidence)],
+    gap,
+  };
+}
+
 /**
  * Adoption completeness (separate from 0–100 fitness). Pure-ish: filesystem + config.
- * @returns {{ gaps: object[], hosts: object[], mcp: object, codexHome: object|null, coreOptional: object[], originReport: object, baseline: object, layerBalance: object|null, deployPath: object|null }}
+ * @returns {{ gaps: object[], hosts: object[], mcp: object, codexHome: object|null, coreOptional: object[], originReport: object, baseline: object, layerBalance: object|null, deployPath: object|null, writePath: object }}
  */
 export function collectAdoptionGaps(root, config, coverage) {
   const gaps = [];
   const adopted = fs.existsSync(path.join(root, 'AGENTS.md'));
   const isProducer = fs.existsSync(path.join(root, 'templates', 'skills'));
 
+  // --- Write path: prepare-write / autoPatch / reject-only (W5) ---
+  const writePath = detectWritePathCapabilities(root);
+  // Only surface write-path gaps when the project has adopted gates (or has partial install).
+  // Producer package tree always has templates — still report capability for dogfood honesty.
+  if (writePath.gap && (adopted || writePath.hookPresent || writePath.mcpPresent || isProducer)) {
+    // Producer may be repair-capable via own templates; still useful. Skip "none" on pure
+    // consumer repos with zero Ark files? missingGates already covers that.
+    if (!(writePath.mode === 'none' && !adopted && !isProducer)) {
+      gaps.push(writePath.gap);
+    }
+  }
+
   // --- Repo MCP dual-bin ---
   const dualMcp = brokenMcpGateFiles(root);
   const mcp = {
@@ -1609,6 +1761,7 @@ export function collectAdoptionGaps(root, config, coverage) {
     layerBalance,
     deployPath,
     contractFalseGreen,
+    writePath,
   };
 }
 
@@ -1973,4 +2126,4 @@ export function runInstallAgentGates(args) {
     }
   }
   warnLockfileConflict(root);
-}
+}

package/bin/lib/architecture-scan.mjs

@@ -25,6 +25,7 @@ import {
   textOfModuleSpecifier,
   typeOnlyExportNames,
 } from './ast-scan.mjs';
+import { provePortProofInject } from './port-proof.mjs';
 import {
   intentLayersFromManifest,
   layerForIntent,
@@ -33,6 +34,7 @@ import {
 } from './config-warnings.mjs';
 import { detectCycles } from './graph-cycles.mjs';
 import { normalize } from './scan-files.mjs';
+import { collectSafetyDiagnostics } from './safety-diagnostics.mjs';
 import {
   createCompilerOptionsLookup,
   createModuleResolutionHost,
@@ -186,6 +188,8 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
 
   const violations = [];
   const warnings = collectConfigWarnings(root, config, files, rules, manifest);
+  const safety = collectSafetyDiagnostics(ts, root, config, files);
+  warnings.push(...safety.warnings);
   const cacheKey = args.noCache ? undefined : scanCacheKey(root, args);
   const cachedFiles = cacheKey ? loadScanCache(root, cacheKey) : undefined;
   const nextCacheFiles = {};
@@ -264,6 +268,23 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           !targetCached?.hasTopLevelSideEffects &&
           named.every((n) => targetTypeNames.has(n));
         const peerIsolation = Boolean(rule.peerIsolation);
+        // W6: port-proof eligibility (value import only; fail-closed static proof).
+        let portProofEligible = false;
+        if (
+          !edge.typeOnly &&
+          !peerIsolation &&
+          edge.kind === 'import' &&
+          !targetTypeOnlyExports &&
+          !namedBindingsTypeOnly
+        ) {
+          try {
+            const srcText = fs.readFileSync(file, 'utf8');
+            const proof = provePortProofInject(ts, srcText, { filePath: file });
+            portProofEligible = Boolean(proof.eligible);
+          } catch {
+            portProofEligible = false;
+          }
+        }
         violations.push({
           ruleId: 'LAYER_IMPORT_VIOLATION',
           file: relFile,
@@ -275,6 +296,7 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           ...(targetTypeOnlyExports ? { targetTypeOnlyExports: true } : {}),
           ...(sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
           ...(namedBindingsTypeOnly ? { namedBindingsTypeOnly: true } : {}),
+          ...(portProofEligible ? { portProofEligible: true } : {}),
           ...(edge.kind ? { edgeKind: edge.kind } : {}),
           ...(peerIsolation ? { peerIsolation: true } : {}),
           message:
@@ -307,5 +329,5 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
     }
   }
 
-  return { violations, warnings };
+  return { violations, warnings, safety: safety.report };
 }

package/bin/lib/auto-patch.mjs

@@ -0,0 +1,264 @@
+/**
+ * W1 — Write-boundary autoPatch for mechanical-safe kinds that can be fixed
+ * by rewriting only the file being written (import type conversions).
+ *
+ * Multi-file kinds (type-only-import-move, pure-type-file-relocate) are classified
+ * but do not emit a single-file autoPatch — they need agent judgment / multi-file moves.
+ *
+ * Trust: post-patch revalidation must be green or the patch is discarded.
+ * Never invents new mechanical-safe kinds beyond classifyRemediation.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  isTypeOnlyModuleReference,
+  namedModuleBindings,
+  sourceFileExportsOnlyTypes,
+  sourceFileHasTopLevelSideEffects,
+  typeOnlyExportNames,
+} from './ast-scan.mjs';
+import { classifyRemediation } from './remediation.mjs';
+
+const EXT_CANDIDATES = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', ''];
+
+/**
+ * True when abs stays under root (no path.relative escape).
+ * Empty relative path (abs === root) counts as inside.
+ * @param {string} root
+ * @param {string} abs
+ */
+function isUnderRoot(root, abs) {
+  if (!root || !abs) return false;
+  const rel = path.relative(path.resolve(root), path.resolve(abs));
+  return !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+export function resolveImportFileAbs(root, fromFilePath, specifier) {
+  if (typeof specifier !== 'string' || !specifier) return null;
+  if (!specifier.startsWith('./') && !specifier.startsWith('../')) return null;
+  if (!fromFilePath || !root) return null;
+  const rootAbs = path.resolve(root);
+  const fromAbs = path.isAbsolute(fromFilePath)
+    ? path.resolve(fromFilePath)
+    : path.resolve(rootAbs, fromFilePath);
+  // Refuse resolution when the importer itself is outside the project root.
+  if (!isUnderRoot(rootAbs, fromAbs)) return null;
+  const base = path.resolve(path.dirname(fromAbs), specifier);
+  const tryFile = (candidate) => {
+    try {
+      if (!isUnderRoot(rootAbs, candidate)) return null;
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+    } catch {
+      /* continue */
+    }
+    return null;
+  };
+  for (const ext of EXT_CANDIDATES) {
+    const hit = tryFile(base + ext);
+    if (hit) return hit;
+  }
+  for (const ext of EXT_CANDIDATES) {
+    if (!ext) continue;
+    const hit = tryFile(path.join(base, `index${ext}`));
+    if (hit) return hit;
+  }
+  return null;
+}
+
+/**
+ * Classify a target module for import-type conversion eligibility.
+ * @returns {{ pureTypeModule: boolean, typeOnlyNames: Set<string>, hasTopLevelSideEffects: boolean } | null}
+ */
+export function inspectTargetModule(ts, targetSource) {
+  if (!ts || typeof targetSource !== 'string') return null;
+  const sf = ts.createSourceFile('target.ts', targetSource, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const pureTypeModule = sourceFileExportsOnlyTypes(ts, sf);
+  const typeOnlyNames = new Set(typeOnlyExportNames(ts, sf));
+  const hasTopLevelSideEffects = sourceFileHasTopLevelSideEffects(ts, sf);
+  return { pureTypeModule, typeOnlyNames, hasTopLevelSideEffects };
+}
+
+/**
+ * Decide remediation kind for converting a non-type-only import of `specifier`
+ * with named bindings `bindingNames` (or null for non-named).
+ * @returns {{ kind: string, confidence: number } | null}
+ */
+export function classifyImportTypeConversion(inspect, bindingNames) {
+  if (!inspect) return null;
+  if (inspect.pureTypeModule) {
+    return {
+      kind: 'import-type-from-pure-type-module',
+      confidence: 0.85,
+    };
+  }
+  // R6 parity with architecture-scan: refuse import-type convert when target has
+  // top-level side effects (would skip runtime init after import type).
+  if (inspect.hasTopLevelSideEffects) return null;
+  if (Array.isArray(bindingNames) && bindingNames.length > 0) {
+    if (bindingNames.every((n) => inspect.typeOnlyNames.has(n))) {
+      return {
+        kind: 'import-type-of-type-exports',
+        confidence: 0.86,
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ * Rewrite eligible static imports/exports to type-only form.
+ * @returns {{ source: string, remediationKind: string, confidence: number } | null}
+ */
+export function applyImportTypeAutoPatch(ts, source, opts = {}) {
+  if (!ts || typeof source !== 'string') return null;
+  const { root, filePath, resolveTargetAbs = resolveImportFileAbs } = opts;
+  const sf = ts.createSourceFile(
+    filePath || 'file.ts',
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  /** @type {Array<{ start: number, end: number, text: string }>} */
+  const replacements = [];
+  let bestKind = null;
+  let bestConfidence = 0;
+
+  for (const stmt of sf.statements) {
+    if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt)) continue;
+    if (isTypeOnlyModuleReference(ts, stmt)) continue;
+    const specNode = stmt.moduleSpecifier;
+    if (!specNode || !ts.isStringLiteralLike(specNode)) continue;
+    const specifier = specNode.text;
+    const abs = resolveTargetAbs(root, filePath, specifier);
+    if (!abs) continue;
+    let targetText;
+    try {
+      targetText = fs.readFileSync(abs, 'utf8');
+    } catch {
+      continue;
+    }
+    const inspect = inspectTargetModule(ts, targetText);
+    const bindings = namedModuleBindings(ts, stmt);
+    // Named imports/re-exports only. Default, namespace, and side-effect imports stay
+    // judgment (never auto-convert to import type).
+    const conversion = classifyImportTypeConversion(inspect, bindings);
+    if (ts.isImportDeclaration(stmt)) {
+      const clause = stmt.importClause;
+      if (!clause) continue; // side-effect
+      if (clause.name) continue; // default import — judgment
+      if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) continue;
+    }
+    if (!conversion) continue;
+
+    const full = source.slice(stmt.getStart(sf), stmt.getEnd());
+    let next = full;
+    if (ts.isImportDeclaration(stmt)) {
+      // `import { A } from 'x'` → `import type { A } from 'x'`
+      // `import { type A, B }` partial already type-only per binding — only full convert
+      if (/^\s*import\s+type\b/.test(full)) continue;
+      next = full.replace(/^(\s*import)(\s+)/, '$1 type$2');
+    } else if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+      if (/^\s*export\s+type\b/.test(full)) continue;
+      next = full.replace(/^(\s*export)(\s+)/, '$1 type$2');
+    }
+    if (next === full) continue;
+    replacements.push({ start: stmt.getStart(sf), end: stmt.getEnd(), text: next });
+    if (conversion.confidence >= bestConfidence) {
+      bestConfidence = conversion.confidence;
+      bestKind = conversion.kind;
+    }
+  }
+
+  if (replacements.length === 0 || !bestKind) return null;
+  // Apply from end so offsets stay valid
+  replacements.sort((a, b) => b.start - a.start);
+  let out = source;
+  for (const r of replacements) {
+    out = out.slice(0, r.start) + r.text + out.slice(r.end);
+  }
+  if (out === source) return null;
+  return {
+    source: out,
+    remediationKind: bestKind,
+    confidence: bestConfidence,
+  };
+}
+
+/**
+ * Run gate validation, try mechanical-safe single-file autoPatch, re-validate.
+ *
+ * @param {{
+ *   source: string,
+ *   filePath?: string,
+ *   root: string,
+ *   ts: object,
+ *   validate: (source: string) => { valid: boolean, violations?: any[] },
+ *   resolveTargetAbs?: Function,
+ * }} opts
+ */
+export function validateWithAutoPatch(opts) {
+  const { source, filePath, root, ts, validate, resolveTargetAbs } = opts;
+  const result = validate(source);
+  const base = {
+    valid: Boolean(result.valid),
+    violations: Array.isArray(result.violations) ? result.violations : [],
+  };
+
+  // Attach remediation classification for LAYER_IMPORT violations when flags known
+  const violations = base.violations.map((v) => {
+    const verdict = classifyRemediation({
+      ruleId: v.ruleId || v.code,
+      typeOnly: v.typeOnly,
+      sourcePureTypeModule: v.sourcePureTypeModule,
+      targetTypeOnlyExports: v.targetTypeOnlyExports,
+      namedBindingsTypeOnly: v.namedBindingsTypeOnly,
+      portProofEligible: v.portProofEligible ?? v.details?.portProofEligible,
+      peerIsolation: v.peerIsolation ?? v.details?.peerIsolation,
+      edgeKind: v.edgeKind ?? v.details?.importKind,
+      fromLayer: v.fromLayer,
+      toLayer: v.toLayer,
+      target: v.target,
+    });
+    return {
+      ...v,
+      remediationClass: verdict.class,
+      remediationKind: verdict.remediationKind,
+      remediationConfidence: verdict.confidence,
+    };
+  });
+
+  if (base.valid) {
+    return { valid: true, violations: [], autoPatch: null };
+  }
+
+  // Write-path autoPatch: import-type mechanical-safe only (W1).
+  // W6 port-proof inject is judgment (signature change) — never re-inject on write path.
+  const attempt = applyImportTypeAutoPatch(ts, source, {
+    root,
+    filePath,
+    resolveTargetAbs: resolveTargetAbs || resolveImportFileAbs,
+  });
+
+  if (!attempt) {
+    return { valid: false, violations, autoPatch: null };
+  }
+
+  const after = validate(attempt.source);
+  if (!after.valid) {
+    // Discard — never return an unvalidated patch
+    return { valid: false, violations, autoPatch: null };
+  }
+
+  return {
+    valid: false,
+    violations,
+    autoPatch: {
+      source: attempt.source,
+      remediationKind: attempt.remediationKind,
+      confidence: attempt.confidence,
+      valid: true,
+    },
+  };
+}

package/bin/lib/baseline-key.mjs

@@ -21,3 +21,20 @@ export function baselineKey(violation) {
         violation.target ?? '',
     ].join('|');
 }
+/**
+ * Stable per-occurrence keys for a list of violations.
+ *
+ * The first occurrence keeps the historical v1 key so existing baselines remain
+ * compatible. Repeated violations with the same identity gain a `#N` suffix;
+ * adding a second identical violation is therefore new debt instead of being
+ * silently suppressed by the first occurrence's key.
+ */
+export function baselineOccurrenceKeys(violations) {
+    const counts = new Map();
+    return violations.map((violation) => {
+        const base = baselineKey(violation);
+        const occurrence = (counts.get(base) ?? 0) + 1;
+        counts.set(base, occurrence);
+        return occurrence === 1 ? base : `${base}#${occurrence}`;
+    });
+}

package/bin/lib/config-warnings.mjs

@@ -55,6 +55,28 @@ export function configWarning(ruleId, message, extra = {}) {
 
 export function collectConfigWarnings(root, config, files, rules, manifest) {
   const warnings = [];
+  if (
+    config.dynamicImportAllowlist !== undefined &&
+    (!Array.isArray(config.dynamicImportAllowlist) ||
+      config.dynamicImportAllowlist.some((entry) => typeof entry !== 'string'))
+  ) {
+    warnings.push(
+      configWarning(
+        'CONFIG_INVALID_DYNAMIC_IMPORT_ALLOWLIST',
+        'dynamicImportAllowlist must be an array of file globs.'
+      )
+    );
+  }
+  if (config.safety !== undefined && (config.safety === null || typeof config.safety !== 'object' || Array.isArray(config.safety))) {
+    warnings.push(configWarning('CONFIG_INVALID_SAFETY', 'safety must be an object.'));
+  } else if (config.safety) {
+    for (const key of ['maxTsSuppressions', 'maxAnyCasts']) {
+      const value = config.safety[key];
+      if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        warnings.push(configWarning('CONFIG_INVALID_SAFETY_THRESHOLD', `safety.${key} must be a non-negative integer.`));
+      }
+    }
+  }
   const layers = Array.isArray(config.layers) ? config.layers : [];
   const manifestLayers = Array.isArray(manifest?.architecture?.layers)
     ? manifest.architecture.layers

package/bin/lib/core-layers.mjs

@@ -0,0 +1,7 @@
+/** Core layers whose optionality matters once they match files. */
+export const CORE_LAYER_NAMES = new Set([
+  'DomainModel',
+  'ApplicationOrchestration',
+  'PresentationAdapters',
+  'PersistenceAdapters',
+]);