openuispec 0.2.11 → 0.2.12

package/check/index.ts

@@ -14,10 +14,13 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import YAML from "yaml";
 import {
+  computeSharedDrift,
   findProjectDir,
+  hasDriftChanges,
   readManifest,
   readProjectName,
   resolveOutputDir,
+  sharedLayersForTarget,
 } from "../drift/index.js";
 import {
   buildAjv,
@@ -153,6 +156,20 @@ function determinePrepare(
     );
   }
 
+  // Check for shared layer drift (only when tracks are configured)
+  const sharedLayers = sharedLayersForTarget(projectDir, target);
+  for (const layer of sharedLayers) {
+    if (layer.tracks.length === 0) continue;
+    const driftResult = computeSharedDrift(projectDir, layer);
+    if (driftResult.state !== null) {
+      if (hasDriftChanges(driftResult.drift)) {
+        warnings.push(
+          `Shared layer "${layer.name}" has spec drift — shared code may need updates before ${target} generation.`
+        );
+      }
+    }
+  }
+
   const ready =
     missing.length === 0 && backendContextReady && !pendingUserConfirmation;
 

package/cli/index.ts

@@ -95,6 +95,19 @@ function checkRulesVersion(): void {
 
 // ── spec helpers (shared with MCP server) ────────────────────────────
 
+function lookupLocaleKey(content: Record<string, unknown>, key: string): { found: boolean; value: unknown } {
+  if (key in content) return { found: true, value: content[key] };
+  const parts = key.split(".");
+  let current: unknown = content;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object" || Array.isArray(current)) {
+      return { found: false, value: undefined };
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current !== undefined ? { found: true, value: current } : { found: false, value: undefined };
+}
+
 function resolveSpecDir(projectDir: string, manifest: any, key: string): string {
   return resolve(projectDir, manifest.includes?.[key] ?? `./${key}/`);
 }
@@ -293,7 +306,10 @@ async function main(): Promise<void> {
       const content = JSON.parse(readFileSync(filePath, "utf-8"));
       if (keys) {
         const filtered: Record<string, unknown> = {};
-        for (const key of keys) { if (key in content) filtered[key] = content[key]; }
+        for (const key of keys) {
+          const result = lookupLocaleKey(content, key);
+          if (result.found) filtered[key] = result.value;
+        }
         console.log(JSON.stringify(filtered, null, 2));
       } else {
         console.log(JSON.stringify(content, null, 2));

package/cli/init.ts

@@ -33,6 +33,7 @@ export type InitOptionsResponse = {
     options?: string[];
   }>;
   configure_targets_note: string;
+  shared_layer_note?: string;
 };
 
 export function listInitOptions(): InitOptionsResponse {
@@ -78,9 +79,17 @@ export function listInitOptions(): InitOptionsResponse {
         type: "yes_no",
         default: defaults.configureTargets,
       },
+      {
+        key: "with_shared",
+        prompt: "Does the project share code between platforms (e.g. KMP commonMain)?",
+        type: "yes_no",
+        default: false,
+      },
     ],
     configure_targets_note:
       "If configure_targets is true, use `openuispec configure-target <target> --list-options` for each target after init to present stack choices to the user.",
+    shared_layer_note:
+      "If with_shared is true, add shared layer config to generation.shared in the manifest. Each shared layer needs: name, platforms (subset of targets), language, root (path relative to openuispec.yaml), tracks (spec categories: manifest, contracts, flows, screens, tokens, platform, locales), and scope (what code belongs there). Also add generation.structure entries for each target to define where platform-specific UI code goes and its scope.",
   };
 }
 
@@ -171,7 +180,12 @@ function getPackageVersion(): string {
 function manifestTemplate(
   name: string,
   targets: string[],
-  options: { withApi: boolean; backendPath: string | null }
+  options: {
+    withApi: boolean;
+    backendPath: string | null;
+    sharedLayers: SharedLayerAnswers[];
+    structures: StructureAnswers[];
+  }
 ): string {
   const targetList = targets.join(", ");
   const outputLines = targets
@@ -186,6 +200,38 @@ function manifestTemplate(
     })
     .join("\n");
 
+  function yamlPathsBlock(paths: Record<string, string>): string {
+    const entries = Object.entries(paths);
+    return entries.length > 0
+      ? `\n      paths:\n${entries.map(([k, v]) => `        ${k}: "${v}"`).join("\n")}`
+      : "";
+  }
+
+  let sharedBlock = "";
+  if (options.sharedLayers.length > 0) {
+    const layers = options.sharedLayers.map((layer) => {
+      const tracksLine = layer.tracks.length > 0
+        ? `\n      tracks: [${layer.tracks.join(", ")}]`
+        : "";
+      return `    ${layer.name}:
+      platforms: [${layer.platforms.join(", ")}]
+      language: ${layer.language}
+      root: "${layer.root}"
+      scope: "${layer.scope}"${tracksLine}${yamlPathsBlock(layer.paths)}`;
+    }).join("\n");
+    sharedBlock = `  shared:\n${layers}\n`;
+  }
+
+  let structureBlock = "";
+  if (options.structures.length > 0) {
+    const entries = options.structures.map((s) => {
+      const scopeLine = s.scope ? `\n      scope: "${s.scope}"` : "";
+      return `    ${s.target}:
+      root: "${s.root}"${scopeLine}${yamlPathsBlock(s.paths)}`;
+    }).join("\n");
+    structureBlock = `  structure:\n${entries}\n`;
+  }
+
   return `# ${name} — OpenUISpec v0.1
 spec_version: "0.1"
 
@@ -218,7 +264,7 @@ ${options.withApi ? `  code_roots:
     backend: "${options.backendPath}"                # Required when api.endpoints are declared
 ` : ""}  output_format:
 ${outputLines}
-
+${sharedBlock}${structureBlock}
 data_model: {}
 
 api:
@@ -679,6 +725,23 @@ export function extractRulesVersion(filePath: string): string | null {
 
 export { getPackageVersion };
 
+interface SharedLayerAnswers {
+  name: string;
+  platforms: string[];
+  language: string;
+  root: string;
+  tracks: string[];
+  scope: string;
+  paths: Record<string, string>;
+}
+
+interface StructureAnswers {
+  target: string;
+  root: string;
+  scope: string;
+  paths: Record<string, string>;
+}
+
 interface InitOptions {
   defaults: boolean;
   quiet: boolean;
@@ -688,6 +751,7 @@ interface InitOptions {
   withApi?: boolean;
   backendPath?: string;
   configureTargets?: boolean;
+  withShared?: boolean;
 }
 
 interface InitAnswers {
@@ -697,6 +761,8 @@ interface InitAnswers {
   withApi: boolean;
   backendPath: string | null;
   configureTargets: boolean;
+  sharedLayers: SharedLayerAnswers[];
+  structures: StructureAnswers[];
 }
 
 function parseTargetsValue(raw: string): string[] {
@@ -752,6 +818,12 @@ function parseInitArgs(argv: string[]): InitOptions {
       case "--no-configure-targets":
         options.configureTargets = false;
         break;
+      case "--with-shared":
+        options.withShared = true;
+        break;
+      case "--no-shared":
+        options.withShared = false;
+        break;
       default:
         if (arg.startsWith("--")) {
           console.error(`Error: Unknown init option: ${arg}`);
@@ -773,9 +845,127 @@ function collectDefaults(): InitAnswers {
     withApi: true,
     backendPath: "../backend/",
     configureTargets: true,
+    sharedLayers: [],
+    structures: [],
   };
 }
 
+const SHARED_LAYER_DEFAULTS: Record<string, {
+  language: string;
+  root: string;
+  tracks: string[];
+  scope: string;
+  paths: Record<string, string>;
+  structureScope: Record<string, string>;
+}> = {
+  kmp: {
+    language: "kotlin",
+    root: "../shared",
+    tracks: [],
+    scope: "Business logic, data models, repositories, API clients, view models/stores. No UI rendering.",
+    paths: { domain: "commonMain/domain/", features: "commonMain/features/" },
+    structureScope: {
+      ios: "Pure SwiftUI views and navigation. All business logic comes from the shared layer.",
+      android: "Pure Compose UI and navigation. All business logic comes from the shared layer.",
+    },
+  },
+};
+
+function defaultSharedConfig(targets: string[]): {
+  sharedLayers: SharedLayerAnswers[];
+  structures: StructureAnswers[];
+} {
+  const mobilePlatforms = targets.filter((t) => t === "ios" || t === "android");
+  if (mobilePlatforms.length < 2) {
+    return { sharedLayers: [], structures: [] };
+  }
+
+  const preset = SHARED_LAYER_DEFAULTS.kmp;
+  const sharedLayers: SharedLayerAnswers[] = [{
+    name: "mobile_common",
+    platforms: mobilePlatforms,
+    language: preset.language,
+    root: preset.root,
+    tracks: preset.tracks,
+    scope: preset.scope,
+    paths: preset.paths,
+  }];
+
+  const structures: StructureAnswers[] = mobilePlatforms.map((t) => ({
+    target: t,
+    root: preset.root,
+    scope: preset.structureScope[t] ?? `Pure ${t} UI. Business logic comes from the shared layer.`,
+    paths: { ui: `${t}App/ui/` },
+  }));
+
+  return { sharedLayers, structures };
+}
+
+async function collectSharedLayerAnswers(
+  rl: ReturnType<typeof createInterface>,
+  targets: string[],
+): Promise<{ sharedLayers: SharedLayerAnswers[]; structures: StructureAnswers[] }> {
+  const withShared = await askYesNo(rl, "\nShare code between platforms (e.g. KMP commonMain)?", false);
+  if (!withShared) return { sharedLayers: [], structures: [] };
+
+  const defaults = defaultSharedConfig(targets);
+  const defaultLayer = defaults.sharedLayers[0];
+  if (!defaultLayer) return { sharedLayers: [], structures: [] };
+
+  console.log("\n  Shared layer defaults (KMP):");
+  console.log(`    platforms: ${defaultLayer.platforms.join(", ")}`);
+  console.log(`    language: ${defaultLayer.language}`);
+  console.log(`    root: ${defaultLayer.root}`);
+  console.log(`    scope: ${defaultLayer.scope}`);
+
+  const useDefaults = await askYesNo(rl, "  Use these defaults?", true);
+  if (useDefaults) return defaults;
+
+  const layerName = await ask(rl, "  Shared layer name", defaultLayer.name);
+  const platformsRaw = await askList(rl, "  Platforms", targets, defaultLayer.platforms);
+  const language = await ask(rl, "  Language", defaultLayer.language);
+  const root = await ask(rl, "  Root path (relative to openuispec.yaml)", defaultLayer.root);
+  const scope = await ask(rl, "  Scope (what code belongs here)", defaultLayer.scope);
+  const wantTracks = await askYesNo(rl, "  Enable hash-based drift tracking for this layer?", false);
+  const tracksRaw = wantTracks
+    ? await askList(
+        rl,
+        "  Tracked spec categories",
+        ["manifest", "tokens", "contracts", "screens", "flows", "platform", "locales"],
+        ["manifest", "contracts", "flows"]
+      )
+    : [];
+
+  const sharedLayers: SharedLayerAnswers[] = [{
+    name: layerName,
+    platforms: platformsRaw,
+    language,
+    root,
+    tracks: tracksRaw,
+    scope,
+    paths: defaultLayer.paths,
+  }];
+
+  const structures: StructureAnswers[] = [];
+  for (const t of platformsRaw) {
+    const defaultStructure = defaults.structures.find((s) => s.target === t);
+    const structRoot = await ask(rl, `  ${t} structure root`, defaultStructure?.root ?? root);
+    const structScope = await ask(
+      rl,
+      `  ${t} scope (what code belongs in the ${t} target)`,
+      defaultStructure?.scope ?? `Pure ${t} UI rendering.`
+    );
+    structures.push({
+      target: t,
+      root: structRoot,
+      scope: structScope,
+      paths: defaultStructure?.paths ?? { ui: `${t}App/ui/` },
+    });
+  }
+
+  return { sharedLayers, structures };
+}
+
 async function collectInteractiveAnswers(rl: ReturnType<typeof createInterface>): Promise<InitAnswers> {
   const defaults = collectDefaults();
   const name = await ask(rl, "Project name", defaults.name);
@@ -792,6 +982,7 @@ async function collectInteractiveAnswers(rl: ReturnType<typeof createInterface>)
     ? await ask(rl, "Backend folder path relative to openuispec.yaml", defaults.backendPath ?? "../backend/")
     : null;
   const configureTargets = await askYesNo(rl, "Configure target stacks now?", defaults.configureTargets);
+  const { sharedLayers, structures } = await collectSharedLayerAnswers(rl, targets);
 
   return {
     name,
@@ -800,6 +991,8 @@ async function collectInteractiveAnswers(rl: ReturnType<typeof createInterface>)
     withApi,
     backendPath,
     configureTargets,
+    sharedLayers,
+    structures,
   };
 }
 
@@ -823,6 +1016,8 @@ function collectNonInteractiveAnswers(argv: string[]): InitAnswers {
 
   const withApi = parsed.withApi ?? defaults.withApi;
   const backendPath = withApi ? parsed.backendPath ?? defaults.backendPath : null;
+  const withShared = parsed.withShared ?? false;
+  const { sharedLayers, structures } = withShared ? defaultSharedConfig(targets) : { sharedLayers: [], structures: [] };
 
   return {
     name: parsed.name ?? defaults.name,
@@ -831,6 +1026,8 @@ function collectNonInteractiveAnswers(argv: string[]): InitAnswers {
     withApi,
     backendPath,
     configureTargets: parsed.configureTargets ?? defaults.configureTargets,
+    sharedLayers,
+    structures,
   };
 }
 
@@ -879,6 +1076,8 @@ export async function init(argv: string[] = []): Promise<void> {
       manifestTemplate(answers.name, answers.targets, {
         withApi: answers.withApi,
         backendPath: answers.backendPath,
+        sharedLayers: answers.sharedLayers,
+        structures: answers.structures,
       }),
       quiet
     );

package/docs/file-formats.md

@@ -64,6 +64,42 @@ Paths are relative to `openuispec.yaml`. The `.openuispec-state.json` file recor
 - `generation.extra_rules` can hold project-wide generation conventions
 - `drift --snapshot` requires that target output directory to already exist
 
+## Shared code layers
+
+Projects that share business logic between platforms (e.g. KMP `commonMain`) can declare `generation.shared` to tell AI what code belongs in the shared layer vs platform-specific targets:
+
+```yaml
+generation:
+  targets: [ios, android, web]
+  shared:
+    mobile_common:
+      platforms: [ios, android]
+      language: kotlin
+      root: "../shared"
+      scope: "Business logic, data models, repositories, API clients, view models. No UI rendering."
+      # tracks: [manifest, contracts]   # optional — enables hash-based drift detection for this layer
+      paths:
+        domain: "commonMain/domain/"
+        features: "commonMain/features/"
+  structure:
+    ios:
+      root: "../shared"
+      scope: "Pure SwiftUI views and navigation. All business logic comes from the shared layer."
+      paths:
+        ui: "iosApp/ui/"
+    android:
+      root: "../shared"
+      scope: "Pure Compose UI and navigation. All business logic comes from the shared layer."
+      paths:
+        ui: "androidApp/ui/"
+```
+
+- **`scope`** (required on shared, optional on structure) — tells AI what code belongs where. This is the primary mechanism for routing generation work between shared and platform layers.
+- **`tracks`** (optional) — when set, enables hash-based drift detection scoped to specific spec categories (`manifest`, `tokens`, `contracts`, `screens`, `flows`, `platform`, `locales`). When omitted, the shared layer relies on `scope` alone.
+- **`structure`** — when present, overrides the heuristic code root discovery for a target. Paths are relative to `root`.
+- Shared layers are not targets — they are tracked alongside targets in `prepare` and `status` output.
+- `openuispec init --with-shared` scaffolds KMP defaults when both ios and android targets are selected.
+
 ## Spec sections overview
 
 | Section | What it defines |

package/docs/implementation-notes.md

@@ -87,6 +87,13 @@
   - backend generation context
     - if the manifest declares `api.endpoints`, `generation.code_roots.backend` is required
     - `prepare` should surface the resolved backend root so AI can inspect backend code when generating API clients
+- Shared code layers (`generation.shared`):
+  - when configured, `prepare` includes `shared_layers` in its output with per-layer `scope`, `already_generated`, and `guidance`
+  - `scope` tells AI what code belongs in the shared layer vs the platform target — this is the primary routing mechanism
+  - optional `tracks` enables hash-based drift detection scoped to specific spec categories
+  - `generation.structure` overrides heuristic code root discovery when present, and its `scope` field tells AI what goes in the platform-specific target
+  - `suggestCodeRoots` includes shared layer roots and structure paths alongside target output directories
+  - generation rules include shared layer and target scope descriptions
 - Important positioning:
   - `prepare` does not generate code
   - `prepare` does not verify code correctness

package/drift/index.ts

@@ -73,6 +73,33 @@ export interface ExplainResult {
   files: FileExplanation[];
 }
 
+// ── shared layer types ───────────────────────────────────────────────
+
+export interface SharedLayerConfig {
+  name: string;
+  platforms: string[];
+  language: string;
+  root: string;           // resolved absolute path
+  paths: Record<string, string>;
+  tracks: string[];       // spec categories to track for drift
+  scope: string;          // what code belongs in this layer
+}
+
+export interface SharedLayerState {
+  spec_version: string;
+  snapshot_at: string;
+  layer_name: string;
+  generated_by_target: string;
+  baseline?: BaselineRef;
+  files: Record<string, FileEntry>;
+}
+
+export interface SharedLayerDriftResult {
+  layer: SharedLayerConfig;
+  drift: DriftResult;
+  state: SharedLayerState | null;
+}
+
 // ── helpers ───────────────────────────────────────────────────────────
 
 export function listFiles(dir: string, ext: string): string[] {
@@ -166,16 +193,43 @@ export function discoverSpecFiles(projectDir: string): string[] {
   return files;
 }
 
-function categorize(relPath: string): string {
-  if (relPath === "openuispec.yaml") return "Manifest";
+/** Classify a relative spec path into a lowercase category. */
+export function specCategory(relPath: string): string {
+  if (relPath === "openuispec.yaml") return "manifest";
   const dir = dirname(relPath);
-  if (dir === "tokens") return "Tokens";
-  if (dir === "screens") return "Screens";
-  if (dir === "flows") return "Flows";
-  if (dir === "platform") return "Platform";
-  if (dir === "locales") return "Locales";
-  if (dir === "contracts") return "Contracts";
-  return "Other";
+  if (dir === "tokens") return "tokens";
+  if (dir === "screens") return "screens";
+  if (dir === "flows") return "flows";
+  if (dir === "platform") return "platform";
+  if (dir === "locales") return "locales";
+  if (dir === "contracts") return "contracts";
+  return "other";
+}
+
+function categorize(relPath: string): string {
+  const cat = specCategory(relPath);
+  return cat.charAt(0).toUpperCase() + cat.slice(1);
+}
+
+/** Returns true when a DriftResult contains any changes. */
+export function hasDriftChanges(d: DriftResult): boolean {
+  return d.changed.length > 0 || d.added.length > 0 || d.removed.length > 0;
+}
+
+/** Hash spec files into FileEntry records keyed by relative path. */
+export function buildFileEntries(
+  projectDir: string,
+  files: string[]
+): { entries: Record<string, FileEntry>; stubs: number } {
+  const entries: Record<string, FileEntry> = {};
+  let stubs = 0;
+  for (const f of files) {
+    const rel = relative(projectDir, f);
+    const status = hasStatusSemantics(rel) ? readStatus(f) : "ready";
+    entries[rel] = { hash: hashFile(f), status };
+    if (status === "stub") stubs++;
+  }
+  return { entries, stubs };
 }
 
 function runGit(args: string[], cwd: string): string | null {
@@ -536,6 +590,158 @@ function normalizeEntry(value: string | FileEntry): FileEntry {
   return value;
 }
 
+// ── shared layers ────────────────────────────────────────────────────
+
+/** Parse `generation.shared` from the manifest and resolve roots to absolute paths. */
+export function readSharedLayers(projectDir: string): SharedLayerConfig[] {
+  const manifest = readManifest(projectDir);
+  const shared = manifest.generation?.shared;
+  if (!shared || typeof shared !== "object") return [];
+
+  return Object.entries(shared).map(([name, config]) => {
+    const cfg = config as Record<string, any>;
+    return {
+      name,
+      platforms: Array.isArray(cfg.platforms) ? cfg.platforms : [],
+      language: typeof cfg.language === "string" ? cfg.language : "",
+      root: resolve(projectDir, cfg.root ?? "."),
+      paths: typeof cfg.paths === "object" && cfg.paths !== null ? cfg.paths : {},
+      tracks: Array.isArray(cfg.tracks) ? cfg.tracks : [],
+      scope: typeof cfg.scope === "string" ? cfg.scope : "",
+    };
+  });
+}
+
+/** Return shared layers whose `platforms` array includes the given target. */
+export function sharedLayersForTarget(projectDir: string, target: string): SharedLayerConfig[] {
+  return readSharedLayers(projectDir).filter((layer) => layer.platforms.includes(target));
+}
+
+/** Returns the state file path for a shared layer. */
+export function sharedLayerStatePath(layer: SharedLayerConfig): string {
+  return join(layer.root, `.openuispec-shared-${layer.name}.json`);
+}
+
+/** Read an existing shared layer state file, or null if it doesn't exist. */
+export function readSharedLayerState(layer: SharedLayerConfig): SharedLayerState | null {
+  try {
+    return JSON.parse(readFileSync(sharedLayerStatePath(layer), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Filter spec files to only those in the given categories. */
+function filterSpecFilesByCategories(
+  projectDir: string,
+  files: string[],
+  categories: string[]
+): string[] {
+  const catSet = new Set(categories);
+  return files.filter((f) => catSet.has(specCategory(relative(projectDir, f))));
+}
+
+/** Create a snapshot of spec state for a shared layer. */
+export function createSharedSnapshot(
+  cwd: string,
+  layerName: string,
+  generatedByTarget: string
+): SnapshotResult {
+  const projectDir = findProjectDir(cwd);
+  const layers = readSharedLayers(projectDir);
+  const layer = layers.find((l) => l.name === layerName);
+  if (!layer) {
+    throw new Error(`Shared layer "${layerName}" not found in generation.shared`);
+  }
+
+  const manifest = readManifest(projectDir);
+  const allFiles = discoverSpecFiles(projectDir);
+  const files = filterSpecFilesByCategories(projectDir, allFiles, layer.tracks);
+  const baseline = captureBaseline(projectDir, allFiles);
+
+  const { entries, stubs: stubCount } = buildFileEntries(projectDir, files);
+
+  const state: SharedLayerState = {
+    spec_version: manifest.spec_version ?? "0.1",
+    snapshot_at: new Date().toISOString(),
+    layer_name: layerName,
+    generated_by_target: generatedByTarget,
+    baseline,
+    files: entries,
+  };
+
+  const outPath = sharedLayerStatePath(layer);
+  writeFileSync(outPath, JSON.stringify(state, null, 2) + "\n");
+
+  return {
+    target: `shared:${layerName}`,
+    snapshot_at: state.snapshot_at,
+    files_hashed: Object.keys(entries).length,
+    stubs: stubCount,
+    state_path: relative(cwd, outPath),
+    baseline: formatBaseline(baseline),
+  };
+}
+
+/** Compute drift for a shared layer against its saved state. */
+export function computeSharedDrift(
+  projectDir: string,
+  layer: SharedLayerConfig
+): SharedLayerDriftResult {
+  const state = readSharedLayerState(layer);
+  if (!state) {
+    return {
+      layer,
+      drift: { changed: [], added: [], removed: [], unchanged: [] },
+      state: null,
+    };
+  }
+
+  const allFiles = discoverSpecFiles(projectDir);
+  const files = filterSpecFilesByCategories(projectDir, allFiles, layer.tracks);
+  const { entries: current } = buildFileEntries(projectDir, files);
+
+  const drift: DriftResult = { changed: [], added: [], removed: [], unchanged: [] };
+
+  for (const [rel, entry] of Object.entries(current)) {
+    const snapshotEntry = state.files[rel]
+      ? normalizeEntry(state.files[rel] as string | FileEntry)
+      : null;
+    if (!snapshotEntry) {
+      drift.added.push(rel);
+    } else if (snapshotEntry.hash !== entry.hash) {
+      drift.changed.push(rel);
+    } else {
+      drift.unchanged.push(rel);
+    }
+  }
+
+  for (const rel of Object.keys(state.files)) {
+    if (!(rel in current)) {
+      drift.removed.push(rel);
+    }
+  }
+
+  return { layer, drift, state };
+}
+
+/** Read `generation.structure[target]` from the manifest. */
+export function readTargetStructure(
+  projectDir: string,
+  target: string
+): { root: string; paths: Record<string, string>; scope: string } | null {
+  const manifest = readManifest(projectDir);
+  const structure = manifest.generation?.structure?.[target];
+  if (!structure || typeof structure !== "object" || typeof structure.root !== "string") {
+    return null;
+  }
+  return {
+    root: resolve(projectDir, structure.root),
+    paths: typeof structure.paths === "object" && structure.paths !== null ? structure.paths : {},
+    scope: typeof structure.scope === "string" ? structure.scope : "",
+  };
+}
+
 // ── snapshot ──────────────────────────────────────────────────────────
 
 export interface SnapshotResult {
@@ -561,16 +767,7 @@ export function createSnapshot(cwd: string, target: string): SnapshotResult {
   const manifest = readManifest(projectDir);
   const files = discoverSpecFiles(projectDir);
   const baseline = captureBaseline(projectDir, files);
-
-  const entries: Record<string, FileEntry> = {};
-  let stubCount = 0;
-
-  for (const f of files) {
-    const rel = relative(projectDir, f);
-    const status = hasStatusSemantics(rel) ? readStatus(f) : "ready";
-    entries[rel] = { hash: hashFile(f), status };
-    if (status === "stub") stubCount++;
-  }
+  const { entries, stubs: stubCount } = buildFileEntries(projectDir, files);
 
   const state: StateFile = {
     spec_version: manifest.spec_version ?? "0.1",
@@ -583,6 +780,20 @@ export function createSnapshot(cwd: string, target: string): SnapshotResult {
   const outPath = stateFilePath(projectDir, projectName, target);
   writeFileSync(outPath, JSON.stringify(state, null, 2) + "\n");
 
+  // Auto-snapshot shared layers with tracks for this target if their state file doesn't exist yet
+  const sharedLayers = sharedLayersForTarget(projectDir, target);
+  for (const layer of sharedLayers) {
+    if (layer.tracks.length === 0) continue;
+    const layerStatePath = sharedLayerStatePath(layer);
+    if (!existsSync(layerStatePath) && existsSync(layer.root)) {
+      try {
+        createSharedSnapshot(cwd, layer.name, target);
+      } catch {
+        // Non-fatal: shared layer snapshot is best-effort during target snapshot
+      }
+    }
+  }
+
   return {
     target,
     snapshot_at: state.snapshot_at,
@@ -619,6 +830,7 @@ export interface CheckResult {
   stubDrift: DriftResult;
   statuses: Record<string, string>;
   explanation?: ExplainResult;
+  shared_layer_drift?: SharedLayerDriftResult[];
 }
 
 export function computeDrift(
@@ -627,13 +839,7 @@ export function computeDrift(
   includeAll: boolean
 ): CheckResult {
   const files = discoverSpecFiles(projectDir);
-
-  const current: Record<string, FileEntry> = {};
-  for (const f of files) {
-    const rel = relative(projectDir, f);
-    const status = hasStatusSemantics(rel) ? readStatus(f) : "ready";
-    current[rel] = { hash: hashFile(f), status };
-  }
+  const { entries: current } = buildFileEntries(projectDir, files);
 
   const drift: DriftResult = { changed: [], added: [], removed: [], unchanged: [] };
   const stubDrift: DriftResult = { changed: [], added: [], removed: [], unchanged: [] };
@@ -688,6 +894,15 @@ export function loadTargetDrift(
     result.explanation = explainDrift(projectDir, result);
   }
 
+  // Include shared layer drift for this target (only layers with tracks configured)
+  const sharedLayers = sharedLayersForTarget(projectDir, target);
+  const trackingLayers = sharedLayers.filter((l) => l.tracks.length > 0);
+  if (trackingLayers.length > 0) {
+    result.shared_layer_drift = trackingLayers.map((layer) =>
+      computeSharedDrift(projectDir, layer)
+    );
+  }
+
   return { projectDir, projectName, statePath, result };
 }
 

package/mcp-server/index.ts

@@ -147,9 +147,12 @@ server.registerTool(
       const baselineReminder = baselinePending
         ? " ⚠ Baseline pending — remind user to run `openuispec drift --snapshot --target " + target + "` when satisfied."
         : "";
+      const sharedHint = result.shared_layers?.length
+        ? ` ℹ ${result.shared_layers.length} shared layer(s) detected — check shared_layers for generation guidance.`
+        : "";
       const hint = (include_specs
         ? "next_tool: openuispec_check (after generating code)"
-        : "next_tool: openuispec_read_specs (load spec contents for generation)") + baselineReminder;
+        : "next_tool: openuispec_read_specs (load spec contents for generation)") + baselineReminder + sharedHint;
       return toolResult(result, hint);
     } catch (err) {
       return toolError(err);
@@ -676,6 +679,25 @@ server.registerTool(
   }
 );
 
+// ── locale key lookup (supports both flat dotted keys and nested objects) ──
+
+function lookupLocaleKey(content: Record<string, unknown>, key: string): { found: boolean; value: unknown } {
+  // 1. Try flat (literal) key first: { "nav.tasks": "Tasks" }
+  if (key in content) {
+    return { found: true, value: content[key] };
+  }
+  // 2. Try nested path: { nav: { tasks: "Tasks" } }
+  const parts = key.split(".");
+  let current: unknown = content;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object" || Array.isArray(current)) {
+      return { found: false, value: undefined };
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current !== undefined ? { found: true, value: current } : { found: false, value: undefined };
+}
+
 // ── tool: openuispec_get_locale ─────────────────────────────────────
 
 server.registerTool(
@@ -710,9 +732,8 @@ server.registerTool(
       if (keys && keys.length > 0) {
         const filtered: Record<string, unknown> = {};
         for (const key of keys) {
-          if (key in content) {
-            filtered[key] = content[key];
-          }
+          const { found, value } = lookupLocaleKey(content, key);
+          if (found) filtered[key] = value;
         }
         return toolResult({ locale, path: relative(projectDir, filePath), content: filtered });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openuispec",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "license": "MIT",
   "type": "module",
   "description": "A semantic UI specification format for AI-native, platform-native app development",

package/prepare/index.ts

@@ -21,10 +21,17 @@ import {
   readManifest,
   readProjectName,
   readStatus,
+  hasDriftChanges,
+  readSharedLayerState,
+  readTargetStructure,
   resolveOutputDir,
+  sharedLayersForTarget,
+  specCategory,
+  computeSharedDrift,
   type FileExplanation,
   type ExplainResult,
   type SemanticChange,
+  type SharedLayerConfig,
 } from "../drift/index.js";
 
 interface PrepareItem {
@@ -116,6 +123,20 @@ interface PrepareBootstrapBundle {
   reference_examples: string[];
 }
 
+interface SharedLayerInfo {
+  name: string;
+  platforms: string[];
+  language: string;
+  root: string;
+  paths: Record<string, string>;
+  scope: string;
+  tracks: string[];
+  already_generated: boolean;
+  generated_by_target: string | null;
+  has_drift: boolean;
+  guidance: string;
+}
+
 interface SpecFileContent {
   path: string;
   category: string;
@@ -148,6 +169,7 @@ export interface PrepareResult {
   changes_available: boolean;
   explanation_note?: string;
   items: PrepareItem[];
+  shared_layers?: SharedLayerInfo[];
   bootstrap?: PrepareBootstrapBundle;
   spec_contents?: SpecFileContent[];
   next_steps: string[];
@@ -321,13 +343,88 @@ function resolveBackendRoot(projectDir: string, manifest: Record<string, any>):
   return resolve(projectDir, backendRoot);
 }
 
-function categorizeSpecFile(relPath: string): string {
-  if (relPath === "openuispec.yaml") return "manifest";
-  const group = relPath.split("/")[0];
-  return group || "other";
+// Use specCategory from drift/index.ts (imported above) instead of a local duplicate.
+const categorizeSpecFile = specCategory;
+
+function buildSharedLayerInfos(projectDir: string, target: string, layers?: SharedLayerConfig[]): SharedLayerInfo[] {
+  const resolvedLayers = layers ?? sharedLayersForTarget(projectDir, target);
+  if (resolvedLayers.length === 0) return [];
+
+  return resolvedLayers.map((layer) => {
+    const state = readSharedLayerState(layer);
+    const alreadyGenerated = state !== null;
+
+    // Only compute hash-based drift when tracks are configured
+    let hasDrift = false;
+    if (layer.tracks.length > 0) {
+      const driftResult = computeSharedDrift(projectDir, layer);
+      hasDrift = driftResult.state !== null && hasDriftChanges(driftResult.drift);
+    }
+
+    let guidance: string;
+    if (alreadyGenerated && !hasDrift) {
+      guidance = `Shared code already generated by ${state!.generated_by_target} — read existing code, don't regenerate.`;
+    } else if (alreadyGenerated && hasDrift) {
+      guidance = `Generated by ${state!.generated_by_target} but spec has drifted — review shared code for needed updates.`;
+    } else {
+      guidance = `Generate shared layer alongside ${target} platform code.`;
+    }
+
+    return {
+      name: layer.name,
+      platforms: layer.platforms,
+      language: layer.language,
+      root: layer.root,
+      paths: layer.paths,
+      scope: layer.scope,
+      tracks: layer.tracks,
+      already_generated: alreadyGenerated,
+      generated_by_target: state?.generated_by_target ?? null,
+      has_drift: hasDrift,
+      guidance,
+    };
+  });
+}
+
+function collectSharedLayerPaths(layers: SharedLayerConfig[]): string[] {
+  const paths: string[] = [];
+  for (const layer of layers) {
+    paths.push(layer.root);
+    for (const p of Object.values(layer.paths)) {
+      paths.push(resolve(layer.root, p));
+    }
+  }
+  return paths;
 }
 
-function suggestCodeRoots(target: string, outputDir: string): string[] {
+function dedupeExistingPaths(candidates: string[]): string[] {
+  const seen = new Set<string>();
+  return candidates
+    .map((c) => resolve(c))
+    .filter((c) => existsSync(c))
+    .filter((c) => {
+      if (seen.has(c)) return false;
+      seen.add(c);
+      return true;
+    });
+}
+
+function suggestCodeRoots(target: string, outputDir: string, projectDir?: string, sharedLayers?: SharedLayerConfig[]): string[] {
+  const layers = sharedLayers ?? (projectDir ? sharedLayersForTarget(projectDir, target) : []);
+
+  // When generation.structure is defined for the target, use it instead of heuristics
+  if (projectDir) {
+    const structure = readTargetStructure(projectDir, target);
+    if (structure) {
+      const candidates = [
+        structure.root,
+        ...Object.values(structure.paths).map((p) => resolve(structure.root, p)),
+        ...collectSharedLayerPaths(layers),
+      ];
+      return dedupeExistingPaths(candidates);
+    }
+  }
+
   const candidates: string[] = [];
 
   if (target === "web") {
@@ -345,15 +442,8 @@ function suggestCodeRoots(target: string, outputDir: string): string[] {
     candidates.push(outputDir);
   }
 
-  const seen = new Set<string>();
-  return candidates
-    .map((candidate) => resolve(candidate))
-    .filter((candidate) => existsSync(candidate))
-    .filter((candidate) => {
-      if (seen.has(candidate)) return false;
-      seen.add(candidate);
-      return true;
-    });
+  candidates.push(...collectSharedLayerPaths(layers));
+  return dedupeExistingPaths(candidates);
 }
 
 function walkFiles(root: string, files: string[], depth = 0): void {
@@ -511,7 +601,7 @@ function buildBootstrapNotes(category: string, target: string, specStatus: strin
   return notes;
 }
 
-function generationRules(target: string, outputDir: string, manifest: Record<string, any>): string[] {
+function generationRules(target: string, outputDir: string, manifest: Record<string, any>, sharedLayers?: SharedLayerInfo[]): string[] {
   const outputFormat = manifest.generation?.output_format?.[target] ?? {};
   const rules = [
     "Read openuispec.yaml first, then follow the referenced spec files instead of inventing structure from memory.",
@@ -528,6 +618,31 @@ function generationRules(target: string, outputDir: string, manifest: Record<str
     );
   }
 
+  if (sharedLayers && sharedLayers.length > 0) {
+    for (const layer of sharedLayers) {
+      if (layer.already_generated) {
+        rules.push(
+          `Shared layer "${layer.name}" already generated by ${layer.generated_by_target}. Read the existing code under ${layer.root} instead of regenerating it.`
+        );
+      } else {
+        rules.push(
+          `Generate shared layer "${layer.name}" (${layer.language}) under ${layer.root} alongside ${target} platform code.`
+        );
+      }
+      if (layer.scope) {
+        rules.push(
+          `Shared layer "${layer.name}" scope: ${layer.scope}`
+        );
+      }
+    }
+  }
+
+  // Include target structure scope when defined
+  const structure = manifest.generation?.structure?.[target];
+  if (structure?.scope) {
+    rules.push(`Target "${target}" scope: ${structure.scope}`);
+  }
+
   return rules;
 }
 
@@ -1070,8 +1185,10 @@ function buildBootstrapPrepareResult(cwd: string, target: string, includeContent
   const platformDef = readPlatformDefinition(projectDir, manifest, target);
   const platformConfig = buildPlatformConfig(target, platformDef);
   const outputFormat = manifest.generation?.output_format?.[target] ?? {};
-  const codeRoots = suggestCodeRoots(target, outputDir);
+  const sharedLayerConfigs = sharedLayersForTarget(projectDir, target);
+  const codeRoots = suggestCodeRoots(target, outputDir, projectDir, sharedLayerConfigs);
   const missingDecisions = missingPlatformDecisions(target, platformDef);
+  const sharedLayerInfos = buildSharedLayerInfos(projectDir, target, sharedLayerConfigs);
   const backendRoot = resolveBackendRoot(projectDir, manifest);
   const backendContextReady = true; // backend is optional — not a generation blocker
   const pendingUserConfirmation = platformConfig.stack_confirmation.requires_user_confirmation;
@@ -1140,6 +1257,7 @@ function buildBootstrapPrepareResult(cwd: string, target: string, includeContent
     changes_available: false,
     explanation_note: "No snapshot exists yet. This is a first-time generation bundle.",
     items: [],
+    ...(sharedLayerInfos.length > 0 ? { shared_layers: sharedLayerInfos } : {}),
     ...(includeContents ? { spec_contents: readAllSpecContents(projectDir) } : {}),
     bootstrap: {
       output_exists: existsSync(outputDir),
@@ -1157,7 +1275,7 @@ function buildBootstrapPrepareResult(cwd: string, target: string, includeContent
         supported_locales: manifest.i18n?.supported_locales ?? [],
       },
       spec_files: bootstrapSpecFiles(projectDir, target),
-      generation_rules: generationRules(target, outputDir, manifest),
+      generation_rules: generationRules(target, outputDir, manifest, sharedLayerInfos),
       generation_constraints: generationConstraints(target, platformConfig),
       generation_warnings: generationWarnings(target, platformConfig),
       reference_examples: referenceExamples(),
@@ -1169,8 +1287,10 @@ function buildBootstrapPrepareResult(cwd: string, target: string, includeContent
 function buildUpdatePrepareResult(cwd: string, target: string, includeContents: boolean = false): PrepareResult {
   const { projectDir, projectName, result } = loadTargetDrift(cwd, target, false, true);
   const outputDir = resolveOutputDir(projectDir, projectName, target);
-  const codeRoots = suggestCodeRoots(target, outputDir);
+  const sharedLayerConfigs = sharedLayersForTarget(projectDir, target);
+  const codeRoots = suggestCodeRoots(target, outputDir, projectDir, sharedLayerConfigs);
   const manifest = readManifest(projectDir);
+  const sharedLayerInfos = buildSharedLayerInfos(projectDir, target, sharedLayerConfigs);
   const platformDef = readPlatformDefinition(projectDir, manifest, target);
   const platformConfig = buildPlatformConfig(target, platformDef);
   const outputFormat = manifest.generation?.output_format?.[target] ?? {};
@@ -1211,6 +1331,7 @@ function buildUpdatePrepareResult(cwd: string, target: string, includeContents:
     changes_available: result.explanation?.available ?? false,
     explanation_note: result.explanation?.note,
     items,
+    ...(sharedLayerInfos.length > 0 ? { shared_layers: sharedLayerInfos } : {}),
     ...(includeContents ? { spec_contents: readAllSpecContents(projectDir) } : {}),
     next_steps: nextSteps,
   };

package/schema/openuispec.schema.json

@@ -152,6 +152,65 @@
             },
             "additionalProperties": true
           }
+        },
+        "shared": {
+          "type": "object",
+          "description": "Named shared code layers that span multiple targets (e.g. KMP common modules)",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "platforms": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "language": {
+                "type": "string"
+              },
+              "root": {
+                "type": "string"
+              },
+              "paths": {
+                "type": "object",
+                "additionalProperties": { "type": "string" }
+              },
+              "tracks": {
+                "type": "array",
+                "description": "Spec categories this shared layer tracks for drift. Must be explicit — choose which categories actually affect the shared code.",
+                "items": {
+                  "type": "string",
+                  "enum": ["manifest", "tokens", "contracts", "screens", "flows", "platform", "locales"]
+                }
+              },
+              "scope": {
+                "type": "string",
+                "description": "What code belongs in this shared layer (e.g. 'Business logic, data models, repositories, API clients, view models. No UI rendering.')"
+              }
+            },
+            "required": ["platforms", "language", "root", "scope"],
+            "additionalProperties": false
+          }
+        },
+        "structure": {
+          "type": "object",
+          "description": "Per-target output directory structure (overrides heuristic code root discovery)",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "root": {
+                "type": "string"
+              },
+              "paths": {
+                "type": "object",
+                "additionalProperties": { "type": "string" }
+              },
+              "scope": {
+                "type": "string",
+                "description": "What code belongs in this target directory (e.g. 'Pure SwiftUI views and navigation. All business logic comes from the shared layer.')"
+              }
+            },
+            "required": ["root"],
+            "additionalProperties": false
+          }
         }
       },
       "required": [

package/schema/semantic-lint.ts

@@ -5,6 +5,23 @@ import { listFiles, readManifest } from "../drift/index.js";
 
 type UnknownRecord = Record<string, unknown>;
 
+/** Collect all locale keys from a JSON object, supporting both flat dotted keys and nested objects. */
+function collectLocaleKeys(data: unknown, prefix = ""): string[] {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+  const keys: string[] = [];
+  for (const [key, value] of Object.entries(data as UnknownRecord)) {
+    if (key.startsWith("$")) continue; // skip $locale, $direction
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      keys.push(fullKey);
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      // Nested object — recurse to flatten
+      keys.push(...collectLocaleKeys(value, fullKey));
+    }
+  }
+  return keys;
+}
+
 export interface Includes {
   tokens: string;
   contracts: string;
@@ -212,7 +229,14 @@ function buildContext(projectDir: string, includes: Includes, manifest: UnknownR
   for (const filePath of listFiles(localeDir, ".json")) {
     const localeName = basename(filePath, ".json");
     const data = loadJson(filePath);
-    localeFiles.set(localeName, new Set(Object.keys(data)));
+    // Support both flat dotted keys ("nav.home": "Home") and nested objects ({ nav: { home: "Home" } })
+    const flatKeys = Object.keys(data as object).filter(k => !k.startsWith("$"));
+    const hasNestedObjects = flatKeys.some(k => {
+      const v = (data as UnknownRecord)[k];
+      return typeof v === "object" && v !== null && !Array.isArray(v);
+    });
+    const allKeys = hasNestedObjects ? collectLocaleKeys(data) : flatKeys;
+    localeFiles.set(localeName, new Set(allKeys));
   }
 
   const formatterNames = new Set<string>([

package/spec/openuispec-v0.1.md

@@ -90,6 +90,19 @@ generation:
     ios: { language: swift, framework: swiftui }
     android: { language: kotlin, framework: compose }
     web: { language: typescript, framework: react }
+  # shared:                          # optional: cross-platform shared code layers
+  #   mobile_common:
+  #     platforms: [ios, android]
+  #     language: kotlin
+  #     root: "../shared"
+  #     scope: "Business logic, data models, repositories, view models. No UI."
+  #     paths:
+  #       domain: "commonMain/domain/"
+  # structure:                       # optional: per-target directory structure (overrides heuristics)
+  #   ios:
+  #     root: "../shared"
+  #     scope: "Pure SwiftUI views and navigation."
+  #     paths: { ui: "iosApp/ui/" }
 ```
 
 ---

package/status/index.ts

@@ -10,14 +10,19 @@
 import { existsSync } from "node:fs";
 import {
   computeDrift,
+  computeSharedDrift,
   discoverTargets,
   explainDrift,
   findProjectDir,
   formatBaseline,
+  hasDriftChanges,
   readOutputDirs,
   readProjectName,
+  readSharedLayers,
+  readSharedLayerState,
   resolveOutputDir,
   stateFilePath,
+  type SharedLayerConfig,
   type StateFile,
 } from "../drift/index.js";
 
@@ -45,9 +50,21 @@ interface TargetStatus {
   note?: string;
 }
 
+interface SharedLayerStatus {
+  name: string;
+  platforms: string[];
+  root: string;
+  snapshot: boolean;
+  snapshot_at: string | null;
+  generated_by_target: string | null;
+  has_drift: boolean;
+  status: "up to date" | "behind" | "needs generation";
+}
+
 export interface StatusResult {
   project: string;
   targets: TargetStatus[];
+  shared_layers?: SharedLayerStatus[];
 }
 
 function configuredTargets(projectDir: string): string[] {
@@ -141,6 +158,38 @@ function buildTargetStatus(cwd: string, projectDir: string, projectName: string,
   };
 }
 
+function buildSharedLayerStatus(projectDir: string, layer: SharedLayerConfig): SharedLayerStatus {
+  const state = readSharedLayerState(layer);
+  if (!state) {
+    return {
+      name: layer.name,
+      platforms: layer.platforms,
+      root: layer.root,
+      snapshot: false,
+      snapshot_at: null,
+      generated_by_target: null,
+      has_drift: false,
+      status: "needs generation",
+    };
+  }
+
+  let hasDrift = false;
+  if (layer.tracks.length > 0) {
+    hasDrift = hasDriftChanges(computeSharedDrift(projectDir, layer).drift);
+  }
+
+  return {
+    name: layer.name,
+    platforms: layer.platforms,
+    root: layer.root,
+    snapshot: true,
+    snapshot_at: state.snapshot_at,
+    generated_by_target: state.generated_by_target,
+    has_drift: hasDrift,
+    status: hasDrift ? "behind" : "up to date",
+  };
+}
+
 export function buildStatusResult(cwd: string = process.cwd()): StatusResult {
   const projectDir = findProjectDir(cwd);
   const projectName = readProjectName(projectDir);
@@ -148,9 +197,15 @@ export function buildStatusResult(cwd: string = process.cwd()): StatusResult {
     buildTargetStatus(cwd, projectDir, projectName, target)
   );
 
+  const sharedLayers = readSharedLayers(projectDir);
+  const sharedLayerStatuses = sharedLayers.length > 0
+    ? sharedLayers.map((layer) => buildSharedLayerStatus(projectDir, layer))
+    : undefined;
+
   return {
     project: projectName,
     targets,
+    ...(sharedLayerStatuses ? { shared_layers: sharedLayerStatuses } : {}),
   };
 }
 
@@ -182,6 +237,21 @@ function printReport(result: StatusResult): void {
     console.log(`  next: ${target.recommended_next_step}`);
     console.log("");
   }
+
+  if (result.shared_layers && result.shared_layers.length > 0) {
+    console.log("Shared Layers");
+    console.log("─────────────");
+    for (const layer of result.shared_layers) {
+      console.log(`${layer.name} (${layer.platforms.join(", ")})`);
+      console.log(`  root: ${layer.root}`);
+      console.log(`  snapshot: ${layer.snapshot ? layer.snapshot_at : "missing"}`);
+      if (layer.generated_by_target) {
+        console.log(`  generated by: ${layer.generated_by_target}`);
+      }
+      console.log(`  status: ${layer.status}`);
+      console.log("");
+    }
+  }
 }
 
 export function runStatus(argv: string[]): void {