arkgate 2.8.3 → 2.9.1

package/CHANGELOG.md

@@ -4,6 +4,86 @@ All notable changes to ArkGate (`arkgate`; formerly `ark-runtime-kernel`) are do
 
 ## Unreleased
 
+## 2.9.1 — 2026-07-09
+
+Field-install honesty: non-TTY start, baseline→CI sync, pin, false-green soft block, Grok defaults.
+**No intentional CLI flag or JSON shape breaks.**
+
+### Fixed
+
+- **Non-TTY `ark start` / `ark init`:** when stdin/stdout are not a TTY and `--yes` was
+  omitted, guided setup no longer throws on a null readline interface. Non-interactive
+  sessions use the same defaults as `--yes` (agents never hang on prompts).
+- **Baseline → CI/scripts sync:** after a successful `--update-baseline`, existing
+  `package.json` scripts and GitHub Actions workflows that already run `ark-check` gain
+  `--baseline .ark-baseline.json` without a full `--force` reinstall of gate templates.
+- **Grok in default agent tools:** no-signal `--install-agent-gates` now installs
+  claude + cursor + codex + **grok**; `GROK_BUILD` / `XAI_GROK` env also adds Grok when
+  other hosts are detected.
+
+### Added
+
+- **`start` pins `arkgate` as a devDependency** (opt out with `--no-install`) so CI/`npx`
+  are not forced to rely on a stale global install.
+- **False-green contract soft block:** doctor adoption gap
+  `contract-false-green-io-under-application` when Domain/Persistence are empty while
+  Application globs still cover I/O dirs (airtable/supabase/prisma/…). `ark start`
+  wrap-up and `/ark-autopilot` steer to `/ark-adopt` / `/ark-contract` instead of pure
+  ENFORCE victory.
+- **`bin/lib/field-install.mjs`:** field-install helpers (baseline sync, pin, false-green)
+  extracted from the agent-gates surface for scannability; re-exported from `agent-gates.mjs`.
+
+### Changed
+
+- **Public ROADMAP:** active backlog is **Track W** (constrained write → verified repair:
+  W1–W6). Finished foundation tracks live under Shipped.
+
+## 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

@@ -44,6 +44,7 @@ import {
   REQUIRED_GATE_FILES,
   codexPromptsDir,
 } from './lib/agent-gates.mjs';
+import { syncBaselineIntoCheckSurfaces } from './lib/field-install.mjs';
 import {
   detectEnforcement,
   renderHtmlReport,
@@ -201,7 +202,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 +210,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',
@@ -1087,8 +1088,25 @@ async function main() {
       console.log('Gate with: ark-check --root . --config ark.config.json --strict-config');
       return;
     }
-    const { fullPath, count } = writeBaseline(root, args.baseline, violations);
+    const { fullPath, count } = writeBaseline(root, baselineName, violations);
     console.log(`Wrote ${fullPath} with ${count} frozen violation key(s).`);
+    // Keep existing package.json scripts + CI workflows on the ratchet without a
+    // full --force reinstall (field log: baseline after start left CI without --baseline).
+    const baselineRel = path.isAbsolute(baselineName)
+      ? path.relative(root, baselineName).split(path.sep).join('/')
+      : String(baselineName).replace(/^\.\/+/, '');
+    const sync = syncBaselineIntoCheckSurfaces(root, {
+      baselineRel: baselineRel || '.ark-baseline.json',
+    });
+    if (sync.changed.length > 0) {
+      console.log(
+        `Synced --baseline into: ${sync.changed.map((c) => c.file).join(', ')}`
+      );
+    } else {
+      console.log(
+        'No existing check scripts/workflows needed a --baseline patch (add check:architecture or re-run --install-agent-gates).'
+      );
+    }
     console.log('Commit it and gate CI with: ark-check --baseline (only NEW violations fail).');
     if (summary.total > 0) printViolationBreakdown(summary);
     return;

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',