arkgate 2.8.2 → 2.9.0

package/CHANGELOG.md

@@ -4,6 +4,79 @@ 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,
+host-token scrub, arkgate.online homepage. **No intentional CLI flag or JSON shape breaks.**
+
+### Added
+
+- **`--ratchet-cores`:** when architecture is green (0 active violations, governed ≥ 50%),
+  set `optional: false` on **populated** core layers only so doctor can report **ENFORCE**
+  honestly. Empty cores stay optional (no false-ENFORCE theatre). Doctor core-optional gaps
+  point at this command; `/ark-autopilot` documents the step after goal.met.
+- **Typecheck bootstrap:** `ark start` / `--install-agent-gates` add `"typecheck": "tsc --noEmit"`
+  when `tsconfig.json`/`jsconfig.json` exists and no typecheck-like script is present; generated
+  CI includes the typecheck step. Existing scripts are never overwritten.
+
+### Changed
+
+- **Official website:** product homepage is [arkgate.online](https://www.arkgate.online/)
+  (`package.json` `homepage`, README badges/footer, ROADMAP identity). npm package page
+  and GitHub remain source + distribution links.
+- **Repo hygiene:** scrub named field-probe host identities from docs, comments, tests, and
+  historical changelog wording; fixtures stay framework-generic (Nest/Next only).
+- **Maintainability:** `--ratchet-cores` lives in `bin/lib/core-ratchet.mjs` (not the ark-check
+  entry); typecheck detection uses shared `packageScriptsHaveTypecheck` (not full deploy-path
+  scan); typecheck bootstrap is skipped under `--skills-only`.
+
+
 ## 2.8.2 — 2026-07-09
 
 Field-honesty patch (Next/UI host probe): no Nest false positives, no false ENFORCE on
@@ -112,7 +185,7 @@ shape breaks** for the gate/co-pilot path.
 
 ## 2.6.1 — 2026-07-09
 
-Field-test release: Next/monorepo honesty (deer-flow-style hosts), simplified **one-flow** UX for
+Field-test release: Next/monorepo honesty (frontend monorepo hosts), simplified **one-flow** UX for
 humans and autonomous agents, and skills that require real source remediation—not CLI paraphrase.
 
 ### Fixed — false greens & strict CI noise (Next / monorepo)
@@ -160,7 +233,7 @@ Templates under `templates/skills/` (and project `.grok/skills` copies) for at l
 
 ### Tests
 
-- Fixture-style unit tests drive real `bin/ark-check.mjs`: Next core governance; deer-flow-like
+- Fixture-style unit tests drive real `bin/ark-check.mjs`: Next core governance; frontend monorepo-like
   monorepo (`frontend` + `core/**/types.ts` not Domain); strict-config with dead globs;
   empty baseline removal.
 

package/README.md

@@ -7,6 +7,7 @@
 Your AI writes most of the code. ArkGate keeps that code inside an architecture you can trust —
 and makes sure a “green” check means something real.
 
+[![Website](https://img.shields.io/badge/website-arkgate.online-0a0a0a)](https://www.arkgate.online/)
 [![CI](https://github.com/pedroknigge/arkgate/actions/workflows/ci.yml/badge.svg)](https://github.com/pedroknigge/arkgate/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/arkgate?color=cb3837&label=npm)](https://www.npmjs.com/package/arkgate)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
@@ -152,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` |
@@ -172,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/`.
@@ -267,10 +269,12 @@ npm run typecheck
 npm run check:architecture   # Ark gates itself
 ```
 
+**Website:** [arkgate.online](https://www.arkgate.online/)  
 **npm:** [`arkgate`](https://www.npmjs.com/package/arkgate) · formerly `ark-runtime-kernel`  
 **Product:** **ArkGate** — architecture co-pilot / gate for AI TypeScript (not a runtime kernel).  
 CLI: `arkgate` · `arkgate-check` · `arkgate-mcp` (aliases `ark` / `ark-check` / `ark-mcp` still work for one major).  
-MCP registry: `io.github.pedroknigge/arkgate`.
+MCP registry: `io.github.pedroknigge/arkgate`.  
+**Source:** [github.com/pedroknigge/arkgate](https://github.com/pedroknigge/arkgate)
 
 Node ≥ 18 · **MIT**.
 

package/bin/ark-check.mjs

@@ -60,6 +60,7 @@ import {
   runPlan,
   runDoctor,
 } from './lib/doctor-plan.mjs';
+import { runRatchetCores } from './lib/core-ratchet.mjs';
 import {
   baselineKey,
   readBaseline,
@@ -153,6 +154,7 @@ function parseArgs(argv) {
     else if (arg === '--apply-policy-pack') args.applyPolicyPack = argv[++i];
     else if (arg === '--suggest-include') args.suggestInclude = true;
     else if (arg === '--adopt-contract') args.adoptContract = true;
+    else if (arg === '--ratchet-cores') args.ratchetCores = true;
     else if (arg === '--write') args.write = true;
     else if (arg === '--watch') args.watch = true;
     else if (arg === '--beginner') args.beginner = true;
@@ -199,14 +201,15 @@ 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)',
+    '       ark-check --ratchet-cores              when raw graph is green (0 violations; baseline ignored), set optional:false on populated cores only (writes ark.config.json)',
     '       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',
@@ -1046,6 +1049,11 @@ async function main() {
     return;
   }
 
+  if (args.ratchetCores) {
+    runRatchetCores(root, config, files, rules, violations, args, { displayPathFromRoot });
+    return;
+  }
+
   if (args.updateBaseline) {
     const summary = summarizeViolations(violations);
     // Bloquear y avisar: a lopsided freeze buries a likely contract bug as "debt". Refuse it

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([
@@ -1053,7 +1058,7 @@ export function collectRepoShapeSignals(root) {
   const pkg = readPackageJson(root);
   const workspaceDirs = detectWorkspaces(root);
   const workspaces = workspaceDirs.length > 0;
-  // Include frontend/web/client — common Next monorepo app folders (deer-flow-style).
+  // Include frontend/web/client — common Next monorepo app folders.
   const candidateScanDirs = [
     'src',
     'lib',
@@ -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.
 
@@ -498,6 +499,11 @@ async function start(args) {
     console.log('     → origin report, adoption, plan, safe fixes, leave gates on.');
     console.log(`  2. Status anytime: ${arkCommand(root, 'ark-check', '--doctor')}`);
     console.log(`  3. After edits:    ${arkCommand(root, 'ark-check', '--root . --config ark.config.json --strict-config')}`);
+    if (mode === 'adapt' && planOk) {
+      console.log(
+        `  4. When green but cores still optional: ${arkCommand(root, 'ark-check', '--ratchet-cores')} → honest ENFORCE`
+      );
+    }
     console.log('');
     console.log('Optional later: --plan · --coverage · /ark-fix · /ark-place · ark upgrade');