arkgate 2.8.3 → 2.9.0

package/CHANGELOG.md

@@ -4,6 +4,52 @@ All notable changes to ArkGate (`arkgate`; formerly `ark-runtime-kernel`) are do
 
 ## Unreleased
 
+## 2.9.0 — 2026-07-09
+
+Track P: slice isolation, vertical-slice + DDD presets, skill surface, and adoption depth.
+**No intentional CLI flag or JSON shape breaks** for existing presets; new rules/presets are opt-in.
+
+### Added
+
+- **`peerIsolation` edge rules (P0):** opt-in cross-slice bans
+  (e.g. `features/auth` ↛ `features/payments`). Optional `sliceFolders`.
+  Wired in `ark-check`, ESLint, write-gate, remediation (`cross-slice-boundary`, judgment).
+- **`vertical-slice` preset (P2):** Features / Shared / Lib / App with peerIsolation on
+  Features. `ark init --preset vertical-slice`. CLI help and fit scoring include all
+  public presets (`ui-surface` documented).
+- **P3 vertical-slice adoption surface:** playbook archetype `vertical-slice-product`,
+  signal `verticalSliceLayout`, policy pack `enthusiast-vertical-slice`, gallery
+  `examples/vertical-slice-starter/` (strict-config green).
+- **P4 `ddd-bounded-contexts` preset:** contexts/*/domain|application|presentation|infra +
+  SharedKernel; peerIsolation matrix blocks **any** cross-context import (same or
+  cross technical layer). Archetype, pack, gallery starter.
+- **Skills (S1/S3):** architect/place/fix/adopt/autopilot know vertical-slice + DDD;
+  new host-only `/ark-think` skill (no package LLM). Refresh installs with
+  `ark-check --install-agent-gates --skills-only --force`.
+- **Eval corpus (S5):** `eval/cases/vertical-slice-cross-feature` labeled peerIsolation case
+  (`cross-slice-boundary` fixClass, judgment).
+- **S2 recommend/doctor:** JSON/human output includes `galleryStarter` + `policyPack`; wizard
+  choices for vertical-slice and DDD; doctor new-here lines for Nest modular and monorepo tooling.
+- **P5 monorepo depth:** default include falls back to `packages`/`apps`/`libs`; detect
+  `turbo.json` / `nx.json`; playbook boosts multi-app-workspace on monorepo tooling.
+- **P6 FSD patterns:** feature-sliced accepts `src/<layer>/**` and root `<layer>/**` (app/pages).
+- **P7 aliases:** `clean-architecture` and `onion-architecture` → hexagonal factory.
+- **P8 Nest guidance:** agent-guide + doctor tip (hexagonal vs ddd-bounded-contexts).
+
+### Changed
+
+- **Same-layer deny semantics (locked):** classic `{ allowed: false }` without
+  `peerIsolation` never blocks same-layer edges (historical short-circuit restored /
+  confirmed). Only `peerIsolation: true` may deny, and only when slice ids differ.
+- **`peerIsolation` applies cross-layer too:** when set, deny only if slices differ
+  (enables honest DDD inter-context isolation for e.g. application→domain across contexts).
+- **`FRAMEWORK_INTERNAL_EXCLUDE`:** `src/kernel/**` + `**/src/kernel/**` only — no longer
+  `**/kernel/**` (which carved out `src/shared/kernel/**`).
+- **Write-gate import resolve:** single `resolveImportTarget` primitive in
+  `bin/lib/import-resolve.mjs`; `ark-mcp` entry stays under 1000 LOC.
+- **Gallery starters:** `npm run check:gallery-starters` fails on factory drift;
+  `generate:gallery-starters` rewrites configs from presets.
+
 ## 2.8.3 — 2026-07-09
 
 Field residuals + official site: core ratchet to honest ENFORCE, typecheck bootstrap,

package/README.md

@@ -153,6 +153,7 @@ Install once: `npx arkgate-check --install-agent-gates`
 | Deep brownfield / manifest mining alone | `/ark-adopt` |
 | New file placement | `/ark-place` |
 | Gate violation on a change | `/ark-fix` |
+| Design trade-offs within the contract (no package LLM) | `/ark-think` |
 | Edit `ark.config.json` safely | `/ark-contract` |
 | Plain-language tour of the report | `/ark-explain` |
 | Deep “what am I not using?” audit | `/ark-coverage` |
@@ -173,7 +174,7 @@ ark.config.json
       └─► Runtime kernel (opt-in)   — only if you call it
 ```
 
-- **Presets:** hexagonal, layered, feature-sliced, monorepo (layers start optional; doctor suggests tightening populated cores).
+- **Presets:** hexagonal, layered, feature-sliced, monorepo, ui-surface, vertical-slice, ddd-bounded-contexts (+ aliases clean-architecture / onion-architecture). Layers start optional; doctor suggests tightening populated cores. Cross-slice / cross-context bans use optional `peerIsolation` rules.
 - **Frameworks:** Nest / Next / express / library layouts get sensible globs on init so day-one coverage is real.
 - **Brownfield:** baseline ratchet, refuse to freeze a wrong contract, `/ark-adopt` for mature trees.
 - **Agents:** skills install into Claude / Cursor / Codex / Grok; `ark start` freezes an origin report under `.ark/reports/`.

package/bin/ark-check.mjs

@@ -201,7 +201,7 @@ function usage() {
     '       ark-check --coverage [--json]          per-layer file counts + full unclassified list (report only, exit 0)',
     '       ark-check --plan [--json]              classified remediation plan (mechanical-safe / judgment / deferred) + goal; report only',
     '       ark-check --recommend [--json] [--write-plan]  application-shape plan; --write-plan emits ark-adoption-plan.json',
-    '       ark-check --list-policy-packs            enthusiast preset configs (hexagonal, layered, feature-sliced, monorepo, ui-surface)',
+    '       ark-check --list-policy-packs            enthusiast packs (hexagonal, layered, feature-sliced, monorepo, ui-surface, vertical-slice, ddd-bounded-contexts)',
     '       ark-check --apply-policy-pack <id> [--force]  write ark.config.json from templates/policy-packs/ (uses preset factory)',
     '       ark-check --suggest-include [--json]   propose include roots (TS packages / workspaces)',
     '       ark-check --adopt-contract [--write]   expand include + UI patterns from ungoverned dirs (contract adopt)',
@@ -209,7 +209,7 @@ function usage() {
     '       ark-check --watch                      re-run the check when governed files change (debounced)',
     '       ark-check --report [file.html] [--beginner] [--reset-origin] [--no-archive]',
     '           HTML report + snapshots under .ark/reports/ (origin once, latest each run, history JSON)',
-    '       ark-check --init [--preset hexagonal|layered|feature-sliced|monorepo] [--force]',
+    '       ark-check --init [--preset hexagonal|layered|feature-sliced|monorepo|ui-surface|vertical-slice|ddd-bounded-contexts|clean-architecture|onion-architecture] [--force]',
     '       ark-check --install-agent-gates [--tools claude,cursor,codex,grok] [--skills-only] [--codex-home] [--force]',
     '       ark-check --update-baseline [file]     freeze current violations (default .ark-baseline.json)',
     '       ark-check --print-config eleven-layer',

package/bin/ark-layer-match.mjs

@@ -135,11 +135,94 @@ export function layerForRelativePath(relPath, layers) {
     }
     return bestName;
 }
-export function isEdgeDenied(rules, from, to) {
-    if (from === to)
-        return false;
-    const hit = (rules ?? []).find((r) => r.from === from && r.to === to);
-    return hit?.allowed === false;
+/**
+ * Extract the slice id under a known folder name.
+ * Includes the parent folder so `features/auth` ≠ `modules/auth`.
+ * `src/features/auth/api.ts` + folders `["features"]` → `"features/auth"`.
+ */
+export function sliceIdForPath(relPath, sliceFolders) {
+    if (!sliceFolders?.length)
+        return undefined;
+    const parts = String(relPath)
+        .split(/[/\\]/)
+        .filter(Boolean);
+    const folders = new Set(sliceFolders.map((s) => String(s).toLowerCase()));
+    for (let i = 0; i < parts.length - 1; i += 1) {
+        if (folders.has(parts[i].toLowerCase())) {
+            return `${parts[i]}/${parts[i + 1]}`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Infer slice parent folders from layer globs: the path segment immediately
+ * before a `*` or `**` wildcard (e.g. `src/features/**` → `features`).
+ */
+export function inferSliceFoldersFromPatterns(patterns) {
+    const out = new Set();
+    for (const pattern of patterns ?? []) {
+        const glob = normalizeGlobSeparators(String(pattern));
+        const parts = glob.split('/').filter(Boolean);
+        for (let i = 0; i < parts.length; i += 1) {
+            const part = parts[i];
+            if ((part === '**' || part === '*') && i > 0) {
+                const prev = parts[i - 1];
+                if (prev && !prev.includes('*') && !prev.includes('{') && !prev.includes('}')) {
+                    out.add(prev);
+                }
+            }
+        }
+    }
+    return [...out];
+}
+function resolveSliceFolders(rule, layerName, layers) {
+    if (Array.isArray(rule.sliceFolders) && rule.sliceFolders.length > 0) {
+        return rule.sliceFolders.filter((s) => typeof s === 'string' && s.length > 0);
+    }
+    const layer = (layers ?? []).find((l) => l.name === layerName);
+    return inferSliceFoldersFromPatterns(layer?.patterns);
+}
+/**
+ * Find the first denying rule for a layer edge.
+ *
+ * Semantics (locked):
+ * - Classic (`allowed: false`, no peerIsolation): deny cross-layer edges only.
+ *   Same-layer is always allowed (historical short-circuit).
+ * - `peerIsolation: true` + `allowed: false`: deny only when importer and importee
+ *   resolve to **different** slice ids (same or cross layer). Same-slice → allow.
+ *   Missing paths or unclassifiable slices → fail-open (do not deny).
+ */
+export function findDeniedEdgeRule(rules, from, to, options) {
+    for (const rule of rules ?? []) {
+        if (rule.from !== from || rule.to !== to)
+            continue;
+        if (rule.allowed !== false)
+            continue;
+        if (rule.peerIsolation) {
+            const fromPath = options?.fromPath;
+            const toPath = options?.toPath;
+            if (!fromPath || !toPath)
+                continue;
+            const folders = resolveSliceFolders(rule, from, options?.layers);
+            if (folders.length === 0)
+                continue;
+            const fromSlice = sliceIdForPath(fromPath, folders);
+            const toSlice = sliceIdForPath(toPath, folders);
+            if (!fromSlice || !toSlice)
+                continue;
+            if (fromSlice !== toSlice)
+                return rule;
+            continue; // same slice: this peerIsolation rule does not deny
+        }
+        // Classic deny — same-layer always allowed without peerIsolation
+        if (from === to)
+            continue;
+        return rule;
+    }
+    return undefined;
+}
+export function isEdgeDenied(rules, from, to, options) {
+    return findDeniedEdgeRule(rules, from, to, options) !== undefined;
 }
 /** Codegen globs skipped by default scan (emitted into the CLI derived matcher). */
 export const DEFAULT_GENERATED_FILE_GLOBS = [

package/bin/ark-mcp.mjs

@@ -45,6 +45,7 @@ import {
   detectTsPackageRoots,
   resolveIncludeRoots,
 } from './ark-shared.mjs';
+import { createImportTargetResolver } from './lib/import-resolve.mjs';
 
 const arkCheckBin = fileURLToPath(new URL('./ark-check.mjs', import.meta.url));
 
@@ -97,73 +98,6 @@ function inferLayer(filePath, config, root) {
   return layerForFile(root, filePath, config.layers);
 }
 
-// Read tsconfig path aliases via the TypeScript config parser (so JSONC + `extends` work).
-// Returns { baseUrl (absolute), aliases: [{ from, to }] } — `from` a prefix like "@/", `to`
-// its base like "./src/". Empty when typescript/tsconfig is unavailable; callers then resolve
-// only relative imports (aliased ones fall through to the infra heuristic — no worse than before).
-function readTsconfigAliases(ts, root) {
-  if (!ts) return { baseUrl: root, aliases: [] };
-  try {
-    const configPath = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
-    if (!configPath) return { baseUrl: root, aliases: [] };
-    const read = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (read.error) return { baseUrl: root, aliases: [] };
-    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(configPath));
-    const opts = parsed.options || {};
-    const baseUrl = opts.baseUrl || path.dirname(configPath);
-    const aliases = [];
-    for (const [pattern, targets] of Object.entries(opts.paths || {})) {
-      if (!Array.isArray(targets) || targets.length === 0) continue;
-      aliases.push({ from: pattern.replace(/\*$/, ''), to: String(targets[0]).replace(/\*$/, '') });
-    }
-    aliases.sort((a, b) => b.from.length - a.from.length); // longest prefix wins
-    return { baseUrl, aliases };
-  } catch {
-    return { baseUrl: root, aliases: [] };
-  }
-}
-
-// Resolve an import specifier to a repo-relative target path (directory-level — enough to
-// classify the layer). Relative and tsconfig-aliased imports resolve; bare packages return
-// undefined (ungoverned → the gate's infra heuristic decides those).
-function resolveSpecifierToRel(specifier, fromFilePath, root, tsAliases) {
-  let abs;
-  if (specifier.startsWith('./') || specifier.startsWith('../')) {
-    if (!fromFilePath) return undefined;
-    abs = path.resolve(path.dirname(path.resolve(root, fromFilePath)), specifier);
-  } else {
-    const alias = tsAliases.aliases.find((a) => specifier.startsWith(a.from));
-    if (!alias) return undefined; // bare package specifier
-    abs = path.resolve(tsAliases.baseUrl, `${alias.to}${specifier.slice(alias.from.length)}`);
-  }
-  const rel = path.relative(root, abs).split(path.sep).join('/');
-  return rel.startsWith('..') ? undefined : rel; // outside the project root
-}
-
-// Build the resolveImportLayer callback for the AI write gate: specifier → target layer, so
-// the gate lets ark.config.json layer RULES govern a resolvable edge instead of the infra
-// path-heuristic. A barrel/dir import (`@/lib/db`) is classified like a file under it.
-function createImportLayerResolver(ts, root, config) {
-  const layers = config.layers ?? [];
-  if (layers.length === 0) return undefined;
-  const tsAliases = readTsconfigAliases(ts, root);
-  return (specifier, fromFilePath) => {
-    const rel = resolveSpecifierToRel(specifier, fromFilePath, root, tsAliases);
-    if (!rel) return undefined;
-    // When the target is a real directory (a barrel import like `@/lib/db`), classify a file
-    // INSIDE it so it resolves to the `src/lib/db/**` layer, not a broader `src/lib/**` that
-    // the bare path would also match. Falls back to the same probe when the target isn't on
-    // disk (e.g. a file referenced without its extension).
-    let probe = rel;
-    try {
-      if (fs.statSync(path.join(root, rel)).isDirectory()) probe = `${rel}/index.ts`;
-    } catch {
-      /* not on disk — classify the path as-is, with the dir-style fallback below */
-    }
-    return layerForFile(root, probe, layers) || layerForFile(root, `${rel}/index.ts`, layers);
-  };
-}
-
 async function loadArk() {
   const url = new URL('../dist/index.js', import.meta.url);
   if (!fs.existsSync(url)) {
@@ -501,9 +435,12 @@ async function main() {
     typescript: ts,
     forbiddenGlobals,
     infrastructureLayers,
-    // Contract-first: a resolvable import edge is judged by the config's layer rules, not the
-    // infra path-heuristic — so the write gate agrees with ark-check (ark.config.json wins).
-    resolveImportLayer: createImportLayerResolver(ts, args.root, config),
+    // Contract-first: one resolve step yields layer + relPath for rules + peerIsolation.
+    resolveImportTarget: createImportTargetResolver(ts, args.root, config),
+    architectureLayers: configLayers.map((layer) => ({
+      name: layer.name,
+      patterns: layer.patterns,
+    })),
   });
 
   if (args.hook) {

package/bin/ark-shared.mjs

@@ -446,6 +446,9 @@ export {
   layerForFile,
   layerForRelativePath,
   isEdgeDenied,
+  findDeniedEdgeRule,
+  sliceIdForPath,
+  inferSliceFoldersFromPatterns,
   DEFAULT_GENERATED_FILE_GLOBS,
   scanExcludePatterns,
   isScanExcludedRelative,
@@ -666,6 +669,8 @@ export const ARCHETYPE_IDS = [
   'integration-bridge',
   'multi-app-workspace',
   'prototype-spike',
+  'vertical-slice-product',
+  'ddd-bounded-contexts',
 ];
 
 const UI_DIR_NAMES = new Set([
@@ -1142,6 +1147,18 @@ export function collectRepoShapeSignals(root) {
     ['app', 'pages', 'features', 'entities', 'shared'].some((name) =>
       fs.existsSync(path.join(root, 'src', name))
     );
+  // Vertical slice: features/* co-located slices + shared/lib escape, without full FSD ladder
+  // (entities/widgets). Distinct from featureSlicedLayout which matches any FSD folder.
+  const verticalSliceLayout =
+    fs.existsSync(path.join(root, 'src', 'features')) &&
+    (fs.existsSync(path.join(root, 'src', 'shared')) ||
+      fs.existsSync(path.join(root, 'src', 'lib'))) &&
+    !fs.existsSync(path.join(root, 'src', 'entities')) &&
+    !fs.existsSync(path.join(root, 'src', 'widgets'));
+  // DDD multi-context tree (contexts/*/domain|application|infrastructure).
+  const dddBoundedContextsLayout =
+    fs.existsSync(path.join(root, 'src', 'contexts')) ||
+    fs.existsSync(path.join(root, 'src', 'bounded-contexts'));
 
   const hasBin = Boolean(pkg?.bin);
   const hasExports = Boolean(pkg?.exports);
@@ -1180,6 +1197,22 @@ export function collectRepoShapeSignals(root) {
   }
   if (nextFramework && !toolHints.includes('next')) toolHints.push('next');
 
+  // Turborepo / Nx markers (monorepo tooling — maps to monorepo preset, not separate engines).
+  const monorepoTooling = [];
+  if (fs.existsSync(path.join(root, 'turbo.json'))) monorepoTooling.push('turborepo');
+  if (
+    fs.existsSync(path.join(root, 'nx.json')) ||
+    fs.existsSync(path.join(root, 'workspace.json'))
+  ) {
+    monorepoTooling.push('nx');
+  }
+  if (monorepoTooling.includes('turborepo') && !toolHints.includes('turborepo')) {
+    toolHints.push('turborepo');
+  }
+  if (monorepoTooling.includes('nx') && !toolHints.includes('nx')) {
+    toolHints.push('nx');
+  }
+
   return {
     workspaces,
     workspaceDirs,
@@ -1203,6 +1236,10 @@ export function collectRepoShapeSignals(root) {
     domainHeavy,
     uiOnly,
     featureSlicedLayout,
+    verticalSliceLayout,
+    dddBoundedContextsLayout,
+    // null when absent so scoreArchetypes `if (signals.x)` is false for empty tooling
+    monorepoTooling: monorepoTooling.length > 0 ? monorepoTooling : null,
     fullStackProduct,
     persistenceFromDeps,
     nestFramework,
@@ -1229,6 +1266,14 @@ const SIGNAL_WHY = {
   library: () => 'publishable package shape (exports/main, no CLI bin)',
   libraryOnly: () => 'library package without a CLI entry',
   featureSlicedLayout: () => 'feature-sliced directory layout under src/',
+  verticalSliceLayout: () =>
+    'vertical-slice layout (src/features + shared/lib, without FSD entities/widgets)',
+  dddBoundedContextsLayout: () =>
+    'DDD bounded contexts under src/contexts or src/bounded-contexts',
+  monorepoTooling: (signals) =>
+    signals.monorepoTooling?.length
+      ? `monorepo tooling detected (${signals.monorepoTooling.join(', ')})`
+      : 'monorepo tooling markers present',
   domain: () => 'domain directory present',
   application: () => 'application or services directory present',
   domainHeavy: () => 'both domain and application directories present',
@@ -1418,6 +1463,9 @@ export function buildArchitectureRecommendation(root, options = {}) {
     phase3: result.phases?.['3'] ?? [],
   };
 
+  const galleryStarter = GALLERY_STARTER_BY_ARCHETYPE[result.archetype] ?? null;
+  const policyPackId = policyPackIdForPreset(result.preset);
+
   return {
     ok: true,
     playbookVersion: playbook.version,
@@ -1435,6 +1483,8 @@ export function buildArchitectureRecommendation(root, options = {}) {
     matchedSignals: result.matched,
     runnerUp: result.runnerUp,
     toolHints: signals.toolHints,
+    galleryStarter,
+    policyPack: policyPackId,
     signals: {
       sourceFileCount: signals.sourceFileCount,
       workspaces: signals.workspaces,
@@ -1452,6 +1502,9 @@ export function buildArchitectureRecommendation(root, options = {}) {
       nestFramework: signals.nestFramework,
       nextFramework: signals.nextFramework,
       expressLike: signals.expressLike,
+      verticalSliceLayout: signals.verticalSliceLayout,
+      dddBoundedContextsLayout: signals.dddBoundedContextsLayout,
+      monorepoTooling: signals.monorepoTooling,
     },
     // A repo past this size is not greenfield: `ark init` would scaffold a starter that governs
     // a thin slice and can mis-flag framework internals, so steer these to the adoption flow.
@@ -1473,7 +1526,9 @@ export const INIT_WIZARD_CHOICES = [
   { key: '5', archetype: 'worker-pipeline', label: 'Background jobs or workers' },
   { key: '6', archetype: 'multi-app-workspace', label: 'Several apps in one repository' },
   { key: '7', archetype: 'prototype-spike', label: 'A quick experiment or learning project' },
-  { key: '8', archetype: 'auto', label: 'Analyze my repo and suggest (recommended if unsure)' },
+  { key: '8', archetype: 'vertical-slice-product', label: 'Feature-first slices (vertical slice)' },
+  { key: '9', archetype: 'ddd-bounded-contexts', label: 'Multiple business domains (bounded contexts)' },
+  { key: 'a', archetype: 'auto', label: 'Analyze my repo and suggest (recommended if unsure)' },
 ];
 
 export function isValidArchetypeId(id) {
@@ -1528,6 +1583,12 @@ export function formatArchitectureRecommendationHuman(recommendation) {
   lines.push('');
   lines.push(`Archetype: ${recommendation.archetype} — ${recommendation.label}`);
   lines.push(`Preset: ${recommendation.preset} (confidence ${recommendation.confidence})`);
+  if (recommendation.galleryStarter) {
+    lines.push(`Gallery starter: ${recommendation.galleryStarter}`);
+  }
+  if (recommendation.policyPack) {
+    lines.push(`Policy pack: ark-check --apply-policy-pack ${recommendation.policyPack}`);
+  }
   if (recommendation.thinTsSurface) {
     lines.push('');
     lines.push(
@@ -1591,18 +1652,37 @@ const GALLERY_STARTER_BY_ARCHETYPE = {
   'api-backend': 'examples/api-backend-starter/',
   'worker-pipeline': 'examples/worker-pipeline-starter/',
   'multi-app-workspace': 'examples/multi-app-workspace-starter/',
+  'vertical-slice-product': 'examples/vertical-slice-starter/',
+  'ddd-bounded-contexts': 'examples/ddd-context-starter/',
 };
 
-/** Machine-readable adoption record for optional commit (Phase E). */
-export function buildAdoptionPlanDocument(recommendation) {
-  const preset = recommendation.preset;
-  const policyPackId =
+/** Enthusiast pack id for a named preset, or null when none ships. */
+export function policyPackIdForPreset(preset) {
+  if (
     preset === 'hexagonal' ||
     preset === 'layered' ||
     preset === 'feature-sliced' ||
-    preset === 'monorepo'
-      ? `enthusiast-${preset}`
-      : null;
+    preset === 'monorepo' ||
+    preset === 'vertical-slice' ||
+    preset === 'ddd-bounded-contexts' ||
+    preset === 'ui-surface' ||
+    preset === 'clean-architecture' ||
+    preset === 'onion-architecture'
+  ) {
+    // clean/onion alias packs → hexagonal enthusiast pack
+    const packPreset =
+      preset === 'clean-architecture' || preset === 'onion-architecture'
+        ? 'hexagonal'
+        : preset;
+    return `enthusiast-${packPreset}`;
+  }
+  return null;
+}
+
+/** Machine-readable adoption record for optional commit (Phase E). */
+export function buildAdoptionPlanDocument(recommendation) {
+  const preset = recommendation.preset;
+  const policyPackId = recommendation.policyPack ?? policyPackIdForPreset(preset);
 
   return {
     version: '1',

package/bin/ark.mjs

@@ -55,7 +55,7 @@ function parseArgs(argv) {
 function usage() {
   return `Usage:
   ark start   [--root <project>] [--yes]
-  ark init    [--root <project>] [--preset hexagonal|layered|feature-sliced|monorepo]
+  ark init    [--root <project>] [--preset hexagonal|layered|feature-sliced|monorepo|ui-surface|vertical-slice|ddd-bounded-contexts|clean-architecture|onion-architecture]
               [--archetype <playbook-id>] [--tools <list>] [--yes] [--force] [--no-strict]
   ark upgrade [--root <project>] [--no-install] [--no-strict]
 
@@ -76,7 +76,8 @@ Options:
   --preset     Start from a named architecture preset instead of detection.
   --archetype  Application shape from templates/architecture-playbook.json (maps to the matching preset).
                Valid ids: crud-product, api-backend, frontend-surface, library-sdk, cli-utility,
-               worker-pipeline, event-coordinator, integration-bridge, multi-app-workspace, prototype-spike.
+               worker-pipeline, event-coordinator, integration-bridge, multi-app-workspace, prototype-spike,
+               vertical-slice-product, ddd-bounded-contexts.
   --tools      Comma-separated agents to gate (claude,cursor,codex,windsurf,cline,copilot,kiro,roo,continue,gemini).
                Omit to auto-detect from each tool's config dir, falling back to claude+cursor+codex.
 

package/bin/lib/architecture-scan.mjs

@@ -237,10 +237,16 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           importGraph.get(relFile).add(relTarget);
         }
       }
-      const rule = targetLayer ? isBlocked(rules, sourceLayer, targetLayer) : undefined;
+      const relTarget = target ? normalize(path.relative(root, target)) : undefined;
+      const rule = targetLayer
+        ? isBlocked(rules, sourceLayer, targetLayer, {
+            fromPath: relFile,
+            toPath: relTarget,
+            layers: config.layers,
+          })
+        : undefined;
       if (rule) {
-        const relTarget = normalize(path.relative(root, target));
-        const targetCached = nextCacheFiles[relTarget];
+        const targetCached = relTarget ? nextCacheFiles[relTarget] : undefined;
         const staticEdge = edge.kind === 'import' || edge.kind === 'export';
         const targetTypeOnlyExports =
           staticEdge && Boolean(targetCached?.exportsOnlyTypes) && !edge.typeOnly;
@@ -257,6 +263,7 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           targetTypeNames.size > 0 &&
           !targetCached?.hasTopLevelSideEffects &&
           named.every((n) => targetTypeNames.has(n));
+        const peerIsolation = Boolean(rule.peerIsolation);
         violations.push({
           ruleId: 'LAYER_IMPORT_VIOLATION',
           file: relFile,
@@ -269,7 +276,12 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           ...(sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
           ...(namedBindingsTypeOnly ? { namedBindingsTypeOnly: true } : {}),
           ...(edge.kind ? { edgeKind: edge.kind } : {}),
-          message: rule.message ?? `${sourceLayer} must not ${edge.kind} ${targetLayer}.`,
+          ...(peerIsolation ? { peerIsolation: true } : {}),
+          message:
+            rule.message ??
+            (peerIsolation
+              ? `${sourceLayer} must not ${edge.kind} another slice of ${targetLayer} (${relFile} → ${relTarget}). Extract shared code or use events/ports across slices.`
+              : `${sourceLayer} must not ${edge.kind} ${targetLayer}.`),
         });
       }
     }

package/bin/lib/config-warnings.mjs

@@ -10,6 +10,7 @@ import {
   patternSpecificity,
   resolveIntentLayer,
 } from '../ark-shared.mjs';
+import { findDeniedEdgeRule } from '../ark-layer-match.mjs';
 import { normalize } from './scan-files.mjs';
 
 export function intentLayersFromManifest(manifest) {
@@ -36,8 +37,16 @@ export function layerForIntent(intent, layers, manifestIntentLayers) {
   return resolveIntentLayer(intent, source);
 }
 
-export function isBlocked(rules, from, to) {
-  return rules.find((rule) => !rule.allowed && rule.from === from && rule.to === to);
+/**
+ * First denying edge rule for from→to, or undefined.
+ * Path-aware when options.fromPath / options.toPath are set (peerIsolation).
+ * @param {object[]} rules
+ * @param {string} from
+ * @param {string} to
+ * @param {{ fromPath?: string, toPath?: string, layers?: object[] }} [options]
+ */
+export function isBlocked(rules, from, to, options) {
+  return findDeniedEdgeRule(rules, from, to, options);
 }
 
 export function configWarning(ruleId, message, extra = {}) {

package/bin/lib/doctor-plan.mjs

@@ -330,6 +330,8 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
                   archetype: recommendation?.archetype,
                   label: recommendation?.label,
                   preset: recommendation?.preset,
+                  galleryStarter: recommendation?.galleryStarter,
+                  policyPack: recommendation?.policyPack,
                   recommendCommand: arkCommand(root, 'ark-check', '--recommend'),
                   initCommand: recommendation?.archetype
                     ? arkCommand(root, 'ark', `init --archetype ${recommendation.archetype} --yes`)
@@ -409,6 +411,24 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
     console.log(color.bold('New here?'));
     if (recommendation) {
       line(warn, `Suggested application shape: ${recommendation.archetype} — ${recommendation.label} (preset ${recommendation.preset})`);
+      if (recommendation.galleryStarter) {
+        line(ok, `Gallery starter: ${recommendation.galleryStarter}`);
+      }
+      if (recommendation.policyPack) {
+        line(ok, `Policy pack: ${arkCommand(root, 'ark-check', `--apply-policy-pack ${recommendation.policyPack}`)}`);
+      }
+      if (recommendation.signals?.nestFramework) {
+        line(
+          ok,
+          'Nest modular monolith → prefer hexagonal (or ddd-bounded-contexts if you have src/contexts/*)'
+        );
+      }
+      if (recommendation.signals?.monorepoTooling?.length) {
+        line(
+          ok,
+          `Monorepo tooling (${recommendation.signals.monorepoTooling.join(', ')}) → preset monorepo (apps/packages/libs)`
+        );
+      }
     } else {
       line(warn, 'Low governed coverage or fresh config — pick an application shape before adding code.');
     }