@tailor-platform/erp-kit 0.1.0 → 0.1.2

package/dist/cli.js

@@ -1,421 +1,113 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { z as z2 } from "zod";
-import { defineCommand as defineCommand2, runMain, arg as arg2 } from "politty";
+import { z as z4 } from "zod";
+import { defineCommand as defineCommand4, runMain, arg as arg4 } from "politty";
 
-// src/mdschema.ts
-import path from "path";
+// src/commands/init.ts
 import fs from "fs";
-import { execFile } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-function getMdschemaBin() {
-  const pkgPath = require2.resolve("@jackchuka/mdschema/package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
-  if (!bin) {
-    throw new Error("Could not resolve mdschema binary from package.json bin field");
-  }
-  return path.join(path.dirname(pkgPath), bin);
-}
-function runMdschema(args, cwd2) {
-  return new Promise((resolve4) => {
-    execFile(
-      getMdschemaBin(),
-      args,
-      { encoding: "utf-8", cwd: cwd2, timeout: 3e4 },
-      (error, stdout, stderr) => {
-        if (error) {
-          const execError = error;
-          resolve4({
-            exitCode: execError.code === "ENOENT" ? 127 : execError.status ?? 1,
-            stdout: stdout ?? "",
-            stderr: stderr ?? ""
-          });
-        } else {
-          resolve4({ exitCode: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
-        }
-      }
-    );
-  });
-}
-
-// src/schemas.ts
-import path3 from "path";
-
-// src/util.ts
 import path2 from "path";
-var PACKAGE_ROOT = path2.resolve(import.meta.dirname, "..");
+import chalk from "chalk";
 
-// src/schemas.ts
-var SCHEMAS_ROOT = path3.join(PACKAGE_ROOT, "schemas");
-var MODULE_SCHEMAS = {
-  module: path3.join(SCHEMAS_ROOT, "module", "module.yml"),
-  command: path3.join(SCHEMAS_ROOT, "module", "command.yml"),
-  model: path3.join(SCHEMAS_ROOT, "module", "model.yml"),
-  feature: path3.join(SCHEMAS_ROOT, "module", "feature.yml")
-};
-var APP_COMPOSE_SCHEMAS = {
-  requirements: path3.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
-  actors: path3.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
-  "business-flow": path3.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
-  story: path3.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
-  screen: path3.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
-  resolver: path3.join(SCHEMAS_ROOT, "app-compose", "resolver.yml")
-};
-var ALL_SCHEMAS = {
-  ...MODULE_SCHEMAS,
-  ...APP_COMPOSE_SCHEMAS
-};
+// src/util.ts
+import path from "path";
+var PACKAGE_ROOT = path.resolve(import.meta.dirname, "..");
 
-// src/commands/check.ts
-function buildCheckTargets(config) {
-  const targets = [];
-  if (config.modulesRoot) {
-    const m = config.modulesRoot;
-    targets.push(
-      { glob: `${m}/[a-zA-Z]*/docs/features/*.md`, schemaKey: "feature" },
-      { glob: `${m}/[a-zA-Z]*/docs/commands/*.md`, schemaKey: "command" },
-      { glob: `${m}/[a-zA-Z]*/docs/models/*.md`, schemaKey: "model" },
-      { glob: `${m}/[a-zA-Z]*/README.md`, schemaKey: "module" }
-    );
-  }
-  if (config.appRoot) {
-    const a = config.appRoot;
-    targets.push(
-      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
-      { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
-      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
-      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },
-      { glob: `${a}/[a-zA-Z]*/docs/screen/*.md`, schemaKey: "screen" },
-      { glob: `${a}/[a-zA-Z]*/docs/resolver/*.md`, schemaKey: "resolver" }
-    );
-  }
-  return targets;
-}
-async function runCheck(config, cwd2) {
-  const targets = buildCheckTargets(config);
-  const results = await Promise.all(
-    targets.map(async (target) => {
-      const schemaPath = ALL_SCHEMAS[target.schemaKey];
-      if (!schemaPath) {
-        console.error(`Unknown schema key: ${target.schemaKey}`);
-        return 2;
+// src/commands/init.ts
+var SKILLS_SRC = path2.join(PACKAGE_ROOT, "skills");
+var FRAMEWORK_SKILLS = [
+  "1-module-docs",
+  "2-module-feature-breakdown",
+  "3-module-doc-review",
+  "4-module-tdd-implementation",
+  "5-module-implementation-review",
+  "app-compose-1-requirement-analysis",
+  "app-compose-2-requirements-breakdown",
+  "app-compose-3-doc-review",
+  "app-compose-4-design-mock",
+  "app-compose-5-design-mock-review",
+  "app-compose-6-implementation-spec",
+  "mock-scenario"
+];
+function copyDirectoryRecursive(srcDir, destDir, force) {
+  let copied = 0;
+  let skipped = 0;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path2.join(srcDir, entry.name);
+    const destPath = path2.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      const sub = copyDirectoryRecursive(srcPath, destPath, force);
+      copied += sub.copied;
+      skipped += sub.skipped;
+    } else {
+      if (!force && fs.existsSync(destPath)) {
+        skipped++;
+        continue;
       }
-      const { exitCode, stdout, stderr } = await runMdschema(
-        ["check", target.glob, "--schema", schemaPath],
-        cwd2
-      );
-      if (stdout.trim()) console.log(stdout);
-      if (stderr.trim()) console.error(stderr);
-      return exitCode;
-    })
-  );
-  if (results.includes(2)) return 2;
-  return results.some((code) => code !== 0) ? 1 : 0;
-}
-
-// src/commands/sync-check.ts
-import path4 from "path";
-import fg from "fast-glob";
-import chalk from "chalk";
-function moduleCategories(root) {
-  return [
-    {
-      name: "command",
-      sourcePattern: `${root}/*/command/*.ts`,
-      docPattern: `${root}/*/docs/commands/*.md`,
-      exclusions: [/\.test\.ts$/]
-    },
-    {
-      name: "model",
-      sourcePattern: `${root}/*/db/*.ts`,
-      docPattern: `${root}/*/docs/models/*.md`,
-      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
     }
-  ];
+  }
+  return { copied, skipped };
 }
-function appComposeCategories(root) {
-  return [
-    {
-      name: "resolver",
-      sourcePattern: `${root}/*/backend/src/modules/**/resolvers/*.ts`,
-      docPattern: `${root}/*/docs/resolver/*.md`,
-      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+function runInit(cwd4, force) {
+  console.log(chalk.bold("erp-kit init\n"));
+  const skillsDest = path2.join(cwd4, ".agents", "skills");
+  let copiedCount = 0;
+  let skippedCount = 0;
+  for (const skill of FRAMEWORK_SKILLS) {
+    const srcSkillDir = path2.join(SKILLS_SRC, skill);
+    if (!fs.existsSync(srcSkillDir)) continue;
+    const destDir = path2.join(skillsDest, skill);
+    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
+    copiedCount += result.copied;
+    if (result.skipped > 0) {
+      console.log(chalk.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
+      skippedCount += result.skipped;
     }
-  ];
-}
-function shouldExclude(fileName, exclusions) {
-  return exclusions.some((pattern) => pattern.test(fileName));
-}
-async function runSyncCheck(config, cwd2) {
-  const errors = [];
-  let totalSources = 0;
-  let totalDocs = 0;
-  const allCategories = [];
-  if (config.modulesRoot) {
-    allCategories.push(...moduleCategories(config.modulesRoot));
-  }
-  if (config.appRoot) {
-    allCategories.push(...appComposeCategories(config.appRoot));
   }
-  for (const category of allCategories) {
-    const sources = await fg(category.sourcePattern, { cwd: cwd2 });
-    const docs = await fg(category.docPattern, { cwd: cwd2 });
-    const sourceBasenames = /* @__PURE__ */ new Map();
-    const docBasenames = /* @__PURE__ */ new Map();
-    for (const sourcePath of sources) {
-      const fileName = path4.basename(sourcePath);
-      if (shouldExclude(fileName, category.exclusions)) continue;
-      const basename2 = path4.basename(sourcePath, path4.extname(sourcePath));
-      sourceBasenames.set(basename2.toLowerCase(), sourcePath);
-    }
-    for (const docPath of docs) {
-      const basename2 = path4.basename(docPath, path4.extname(docPath));
-      docBasenames.set(basename2.toLowerCase(), docPath);
-    }
-    for (const [basename2, sourcePath] of sourceBasenames) {
-      if (!docBasenames.has(basename2)) {
-        errors.push({
-          type: "missing-doc",
-          category: category.name,
-          sourcePath,
-          expectedBasename: basename2
-        });
-      }
-    }
-    for (const [basename2, docPath] of docBasenames) {
-      if (!sourceBasenames.has(basename2)) {
-        errors.push({
-          type: "orphaned-doc",
-          category: category.name,
-          docPath,
-          expectedBasename: basename2
-        });
-      }
-    }
-    totalSources += sourceBasenames.size;
-    totalDocs += docBasenames.size;
+  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
+  if (skippedCount > 0) {
+    console.log(
+      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`)
+    );
   }
-  return {
-    exitCode: errors.length > 0 ? 1 : 0,
-    errors,
-    summary: {
-      categoriesChecked: allCategories.length,
-      totalSources,
-      totalDocs
-    }
-  };
-}
-function formatSyncCheckReport(result) {
-  const lines = [];
-  lines.push(chalk.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
-  if (result.errors.length > 0) {
-    lines.push(chalk.red.bold("Errors:\n"));
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const error of result.errors) {
-      const existing = byCategory.get(error.category) ?? [];
-      existing.push(error);
-      byCategory.set(error.category, existing);
+  const claudeSkills = path2.join(cwd4, ".claude", "skills");
+  const relTarget = path2.relative(path2.dirname(claudeSkills), skillsDest);
+  const claudeSkillsExists = (() => {
+    try {
+      fs.lstatSync(claudeSkills);
+      return true;
+    } catch {
+      return false;
     }
-    for (const [category, categoryErrors] of byCategory) {
-      lines.push(chalk.cyan(`  Category: ${category}
-`));
-      for (const error of categoryErrors) {
-        if (error.type === "missing-doc") {
-          lines.push(`  ${chalk.red(error.sourcePath)}`);
-          lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
-        } else {
-          lines.push(`  ${chalk.red(error.docPath)}`);
-          lines.push(
-            `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
-          );
-        }
-        lines.push("");
+  })();
+  if (claudeSkillsExists) {
+    const stat2 = fs.lstatSync(claudeSkills);
+    if (stat2.isSymbolicLink()) {
+      const current = fs.readlinkSync(claudeSkills);
+      if (current === relTarget) {
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (already linked)"));
+      } else if (force) {
+        fs.unlinkSync(claudeSkills);
+        fs.symlinkSync(relTarget, claudeSkills);
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (relinked)"));
+      } else {
+        console.log(
+          chalk.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`)
+        );
       }
+    } else {
+      console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
     }
   } else {
-    lines.push(chalk.green("All source files have corresponding documentation.\n"));
-  }
-  lines.push(chalk.bold("Summary:"));
-  lines.push(`  Categories checked: ${result.summary.categoriesChecked}`);
-  lines.push(
-    `  Source files: ${result.summary.totalSources}, Doc files: ${result.summary.totalDocs}`
-  );
-  if (result.errors.length > 0) {
-    lines.push(chalk.red(`  Errors: ${result.errors.length}`));
-    lines.push("");
-    lines.push(chalk.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
-  } else {
-    lines.push(chalk.green("  Errors: 0"));
-    lines.push("");
-    lines.push(chalk.green.bold("docs-sync-check passed."));
+    fs.mkdirSync(path2.dirname(claudeSkills), { recursive: true });
+    fs.symlinkSync(relTarget, claudeSkills);
+    console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
   }
-  return lines.join("\n");
-}
-
-// src/commands/scaffold.ts
-import path5 from "path";
-import fs2 from "fs";
-var MODULE_TYPES = ["module", "feature", "command", "model"];
-var APP_TYPES = [
-  "requirements",
-  "actors",
-  "business-flow",
-  "story",
-  "screen",
-  "resolver"
-];
-var ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES];
-var MODULE_DIR_MAP = {
-  feature: "docs/features",
-  command: "docs/commands",
-  model: "docs/models"
-};
-var APP_DIR_MAP = {
-  actors: "docs/actors",
-  "business-flow": "docs/business-flow",
-  screen: "docs/screen",
-  resolver: "docs/resolver"
-};
-function isModuleType(type) {
-  return MODULE_TYPES.includes(type);
-}
-function resolveScaffoldPath(type, parentName, name, root) {
-  if (type === "module" || type === "requirements") {
-    return path5.join(root, parentName, "README.md");
-  }
-  if (!name) {
-    throw new Error(`Name is required for scaffold type "${type}"`);
-  }
-  if (type === "business-flow") {
-    return path5.join(root, parentName, "docs/business-flow", name, "README.md");
-  }
-  if (type === "story") {
-    const parts = name.split("/");
-    if (parts.length !== 2) {
-      throw new Error(
-        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`
-      );
-    }
-    return path5.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
-  }
-  if (MODULE_DIR_MAP[type]) {
-    return path5.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
-  }
-  if (APP_DIR_MAP[type]) {
-    return path5.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
-  }
-  throw new Error(`Unknown scaffold type: ${type}`);
-}
-async function runScaffold(type, parentName, name, root, cwd2) {
-  const outputPath = resolveScaffoldPath(type, parentName, name, root);
-  const absoluteOutput = path5.resolve(cwd2, outputPath);
-  if (fs2.existsSync(absoluteOutput)) {
-    console.error(`File already exists: ${outputPath}`);
-    return 1;
-  }
-  const schemaPath = ALL_SCHEMAS[type];
-  if (!schemaPath) {
-    console.error(`No schema found for type: ${type}`);
-    return 2;
-  }
-  try {
-    fs2.mkdirSync(path5.dirname(absoluteOutput), { recursive: true });
-  } catch (err) {
-    console.error(
-      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return 1;
-  }
-  const { exitCode, stdout, stderr } = await runMdschema(
-    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
-    cwd2
-  );
-  if (stdout.trim()) console.log(stdout);
-  if (stderr.trim()) console.error(stderr);
-  return exitCode;
-}
-
-// src/commands/init.ts
-import fs3 from "fs";
-import path6 from "path";
-import chalk2 from "chalk";
-var SKILLS_SRC = path6.join(PACKAGE_ROOT, "skills");
-var RULES_SRC = path6.join(PACKAGE_ROOT, "rules");
-var FRAMEWORK_SKILLS = [
-  "1-module-docs",
-  "2-module-feature-breakdown",
-  "3-module-doc-review",
-  "4-module-tdd-implementation",
-  "5-module-implementation-review",
-  "app-compose-1-requirement-analysis",
-  "app-compose-2-requirements-breakdown",
-  "app-compose-3-doc-review",
-  "app-compose-4-design-mock",
-  "app-compose-5-design-mock-review",
-  "app-compose-6-implementation-spec",
-  "mock-scenario"
-];
-function runInit(cwd2, force) {
-  console.log(chalk2.bold("erp-kit init\n"));
-  const skillsDest = path6.join(cwd2, ".agents", "skills");
-  let copiedCount = 0;
-  let skippedCount = 0;
-  for (const skill of FRAMEWORK_SKILLS) {
-    const srcSkill = path6.join(SKILLS_SRC, skill, "SKILL.md");
-    const destDir = path6.join(skillsDest, skill);
-    const destSkill = path6.join(destDir, "SKILL.md");
-    if (!fs3.existsSync(srcSkill)) continue;
-    if (!force && fs3.existsSync(destSkill)) {
-      console.log(chalk2.yellow(`  Skipped ${skill}/SKILL.md (already exists)`));
-      skippedCount++;
-      continue;
-    }
-    fs3.mkdirSync(destDir, { recursive: true });
-    fs3.copyFileSync(srcSkill, destSkill);
-    copiedCount++;
-  }
-  console.log(chalk2.green(`  Copied ${copiedCount} framework skills to .agents/skills/`));
-  if (skippedCount > 0) {
-    console.log(
-      chalk2.yellow(`  Skipped ${skippedCount} existing skills (use --force to overwrite)`)
-    );
-  }
-  const rulesDest = path6.join(cwd2, ".agents", "rules");
-  let rulesCount = 0;
-  let rulesSkipped = 0;
-  if (fs3.existsSync(RULES_SRC)) {
-    const copyRulesRecursive = (srcDir, destDir) => {
-      for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
-        const srcPath = path6.join(srcDir, entry.name);
-        const destPath = path6.join(destDir, entry.name);
-        if (entry.isDirectory()) {
-          copyRulesRecursive(srcPath, destPath);
-        } else {
-          if (!force && fs3.existsSync(destPath)) {
-            const rel = path6.relative(rulesDest, destPath);
-            console.log(chalk2.yellow(`  Skipped rule ${rel} (already exists)`));
-            rulesSkipped++;
-            continue;
-          }
-          fs3.mkdirSync(destDir, { recursive: true });
-          fs3.copyFileSync(srcPath, destPath);
-          rulesCount++;
-        }
-      }
-    };
-    copyRulesRecursive(RULES_SRC, rulesDest);
-  }
-  console.log(chalk2.green(`  Copied ${rulesCount} framework rules to .agents/rules/`));
-  if (rulesSkipped > 0) {
-    console.log(
-      chalk2.yellow(`  Skipped ${rulesSkipped} existing rules (use --force to overwrite)`)
-    );
-  }
-  console.log(chalk2.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
-  return 0;
+  console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
+  return 0;
 }
 
 // src/commands/mock/index.ts
@@ -600,12 +292,12 @@ Reverse proxy listening on http://localhost:${port}`);
 // src/commands/mock/validate.ts
 import { readdir, readFile, stat } from "fs/promises";
 import { join as join2, resolve as resolve3, relative as relative2, dirname as dirname2, basename } from "path";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function pass(msg) {
-  console.log(chalk3.green(`\u2713 ${msg}`));
+  console.log(chalk2.green(`\u2713 ${msg}`));
 }
 function fail(ctx, msg) {
-  console.log(chalk3.red(`\u2717 ${msg}`));
+  console.log(chalk2.red(`\u2717 ${msg}`));
   ctx.failures++;
 }
 async function subdirs(dir) {
@@ -663,232 +355,680 @@ function checkResponseQuality(ctx, data, label) {
     }
   }
 }
-function checkDatabucketRefs(ctx, data, label) {
-  const bucketIds = new Set((data.data ?? []).map((d) => d.id));
-  for (const route of data.routes ?? []) {
-    for (const resp of route.responses ?? []) {
-      if (resp.bodyType === "DATABUCKET") {
-        const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
-        if (resp.databucketID && bucketIds.has(resp.databucketID)) {
-          pass(`${respLabel}: databucket "${resp.databucketID}" exists`);
+function checkDatabucketRefs(ctx, data, label) {
+  const bucketIds = new Set((data.data ?? []).map((d) => d.id));
+  for (const route of data.routes ?? []) {
+    for (const resp of route.responses ?? []) {
+      if (resp.bodyType === "DATABUCKET") {
+        const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
+        if (resp.databucketID && bucketIds.has(resp.databucketID)) {
+          pass(`${respLabel}: databucket "${resp.databucketID}" exists`);
+        } else {
+          fail(ctx, `${respLabel}: databucketID "${resp.databucketID}" not found in data array`);
+        }
+      }
+    }
+  }
+}
+async function discoverAllScenarios(mocksDir) {
+  const scenarios = [];
+  const providers = await subdirs(mocksDir);
+  for (const provider of providers) {
+    const providerDir = join2(mocksDir, provider);
+    for (const scenario of await subdirs(providerDir)) {
+      scenarios.push(`${provider}/${scenario}`);
+    }
+  }
+  return scenarios;
+}
+function resolveScenarioDir(arg5) {
+  const abs = resolve3(arg5);
+  if (basename(abs) === "mock.json") return dirname2(abs);
+  return abs;
+}
+async function validateScenario(ctx, scenarioDir, mocksDir) {
+  const label = relative2(mocksDir, scenarioDir);
+  console.log(chalk2.bold(`
+\u2500\u2500 ${label} \u2500\u2500`));
+  let entries;
+  try {
+    entries = await readdir(scenarioDir);
+  } catch {
+    fail(ctx, `${label}: directory not found`);
+    return;
+  }
+  const hasMock = checkStructure(ctx, entries, label);
+  if (!hasMock) return;
+  const mockPath = join2(scenarioDir, "mock.json");
+  let data;
+  try {
+    data = JSON.parse(await readFile(mockPath, "utf-8"));
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    fail(ctx, `${label}: invalid JSON \u2014 ${errMsg}`);
+    return;
+  }
+  await checkSchema(ctx, data, label);
+  checkResponseQuality(ctx, data, label);
+  checkDatabucketRefs(ctx, data, label);
+}
+async function runMockValidate(mocksRoot, paths) {
+  const ctx = { failures: 0 };
+  const mocksDir = resolve3(mocksRoot);
+  const targets = paths.length > 0 ? paths.map(resolveScenarioDir) : (await discoverAllScenarios(mocksDir)).map((s) => join2(mocksDir, s));
+  if (targets.length === 0) {
+    fail(ctx, "No scenarios found under mocks/");
+    return 1;
+  }
+  console.log(chalk2.bold("\nValidating mock configs...\n"));
+  for (const target of targets) {
+    await validateScenario(ctx, target, mocksDir);
+  }
+  console.log(chalk2.bold("\n\u2500\u2500 summary \u2500\u2500"));
+  if (ctx.failures === 0) {
+    console.log(chalk2.green("\u2713 All checks passed"));
+  } else {
+    console.log(chalk2.red(`\u2717 ${ctx.failures} check(s) failed`));
+  }
+  return ctx.failures === 0 ? 0 : 1;
+}
+
+// src/commands/mock/index.ts
+var startCommand = defineCommand({
+  name: "start",
+  description: "Start mock API servers with reverse proxy",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory"
+    }),
+    port: arg(z.coerce.number().default(3e3), {
+      alias: "p",
+      description: "Reverse proxy port"
+    }),
+    filter: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Filter by provider or provider/scenario"
+    })
+  }),
+  run: async (args) => {
+    const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
+    process.exit(exitCode);
+  }
+});
+var validateCommand = defineCommand({
+  name: "validate",
+  description: "Validate mock scenario configs",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory"
+    }),
+    paths: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Specific scenario paths to validate"
+    })
+  }),
+  run: async (args) => {
+    const exitCode = await runMockValidate(args.mocksRoot, args.paths);
+    process.exit(exitCode);
+  }
+});
+var mockCommand = defineCommand({
+  name: "mock",
+  description: "Mock API server management",
+  subCommands: {
+    start: startCommand,
+    validate: validateCommand
+  }
+});
+
+// src/commands/module/index.ts
+import { z as z2 } from "zod";
+import { defineCommand as defineCommand2, arg as arg2 } from "politty";
+
+// src/mdschema.ts
+import path3 from "path";
+import fs2 from "fs";
+import { execFile } from "child_process";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function getMdschemaBin() {
+  const pkgPath = require2.resolve("@jackchuka/mdschema/package.json");
+  const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
+  if (!bin) {
+    throw new Error("Could not resolve mdschema binary from package.json bin field");
+  }
+  return path3.join(path3.dirname(pkgPath), bin);
+}
+function runMdschema(args, cwd4) {
+  return new Promise((resolve4) => {
+    execFile(
+      getMdschemaBin(),
+      args,
+      { encoding: "utf-8", cwd: cwd4, timeout: 3e4 },
+      (error, stdout, stderr) => {
+        if (error) {
+          const execError = error;
+          resolve4({
+            exitCode: execError.code === "ENOENT" ? 127 : execError.status ?? 1,
+            stdout: stdout ?? "",
+            stderr: stderr ?? ""
+          });
+        } else {
+          resolve4({ exitCode: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
+        }
+      }
+    );
+  });
+}
+
+// src/schemas.ts
+import path4 from "path";
+var SCHEMAS_ROOT = path4.join(PACKAGE_ROOT, "schemas");
+var MODULE_SCHEMAS = {
+  module: path4.join(SCHEMAS_ROOT, "module", "module.yml"),
+  command: path4.join(SCHEMAS_ROOT, "module", "command.yml"),
+  model: path4.join(SCHEMAS_ROOT, "module", "model.yml"),
+  feature: path4.join(SCHEMAS_ROOT, "module", "feature.yml"),
+  query: path4.join(SCHEMAS_ROOT, "module", "query.yml")
+};
+var APP_COMPOSE_SCHEMAS = {
+  requirements: path4.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
+  actors: path4.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
+  "business-flow": path4.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
+  story: path4.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
+  screen: path4.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
+  resolver: path4.join(SCHEMAS_ROOT, "app-compose", "resolver.yml")
+};
+var ALL_SCHEMAS = {
+  ...MODULE_SCHEMAS,
+  ...APP_COMPOSE_SCHEMAS
+};
+
+// src/commands/check.ts
+function buildCheckTargets(config) {
+  const targets = [];
+  if (config.modulesRoot) {
+    const m = config.modulesRoot;
+    targets.push(
+      { glob: `${m}/[a-zA-Z]*/docs/features/*.md`, schemaKey: "feature" },
+      { glob: `${m}/[a-zA-Z]*/docs/commands/*.md`, schemaKey: "command" },
+      { glob: `${m}/[a-zA-Z]*/docs/models/*.md`, schemaKey: "model" },
+      { glob: `${m}/[a-zA-Z]*/docs/queries/*.md`, schemaKey: "query" },
+      { glob: `${m}/[a-zA-Z]*/README.md`, schemaKey: "module" }
+    );
+  }
+  if (config.appRoot) {
+    const a = config.appRoot;
+    targets.push(
+      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
+      { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },
+      { glob: `${a}/[a-zA-Z]*/docs/screen/*.md`, schemaKey: "screen" },
+      { glob: `${a}/[a-zA-Z]*/docs/resolver/*.md`, schemaKey: "resolver" }
+    );
+  }
+  return targets;
+}
+async function runCheck(config, cwd4) {
+  const targets = buildCheckTargets(config);
+  const results = await Promise.all(
+    targets.map(async (target) => {
+      const schemaPath = ALL_SCHEMAS[target.schemaKey];
+      if (!schemaPath) {
+        console.error(`Unknown schema key: ${target.schemaKey}`);
+        return 2;
+      }
+      const { exitCode, stdout, stderr } = await runMdschema(
+        ["check", target.glob, "--schema", schemaPath],
+        cwd4
+      );
+      if (stdout.trim()) console.log(stdout);
+      if (stderr.trim()) console.error(stderr);
+      return exitCode;
+    })
+  );
+  if (results.includes(2)) return 2;
+  return results.some((code) => code !== 0) ? 1 : 0;
+}
+
+// src/commands/sync-check.ts
+import path5 from "path";
+import fg from "fast-glob";
+import chalk3 from "chalk";
+function moduleCategories(root) {
+  return [
+    {
+      name: "command",
+      sourcePattern: `${root}/*/command/*.ts`,
+      docPattern: `${root}/*/docs/commands/*.md`,
+      exclusions: [/\.test\.ts$/]
+    },
+    {
+      name: "model",
+      sourcePattern: `${root}/*/db/*.ts`,
+      docPattern: `${root}/*/docs/models/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+    },
+    {
+      name: "query",
+      sourcePattern: `${root}/*/query/*.ts`,
+      docPattern: `${root}/*/docs/queries/*.md`,
+      exclusions: [/\.test\.ts$/]
+    }
+  ];
+}
+function appComposeCategories(root) {
+  return [
+    {
+      name: "resolver",
+      sourcePattern: `${root}/*/backend/src/modules/**/resolvers/*.ts`,
+      docPattern: `${root}/*/docs/resolver/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+    }
+  ];
+}
+function shouldExclude(fileName, exclusions) {
+  return exclusions.some((pattern) => pattern.test(fileName));
+}
+async function runSyncCheck(config, cwd4) {
+  const errors = [];
+  let totalSources = 0;
+  let totalDocs = 0;
+  const allCategories = [];
+  if (config.modulesRoot) {
+    allCategories.push(...moduleCategories(config.modulesRoot));
+  }
+  if (config.appRoot) {
+    allCategories.push(...appComposeCategories(config.appRoot));
+  }
+  for (const category of allCategories) {
+    const sources = await fg(category.sourcePattern, { cwd: cwd4 });
+    const docs = await fg(category.docPattern, { cwd: cwd4 });
+    const sourceBasenames = /* @__PURE__ */ new Map();
+    const docBasenames = /* @__PURE__ */ new Map();
+    for (const sourcePath of sources) {
+      const fileName = path5.basename(sourcePath);
+      if (shouldExclude(fileName, category.exclusions)) continue;
+      const basename2 = path5.basename(sourcePath, path5.extname(sourcePath));
+      sourceBasenames.set(basename2.toLowerCase(), sourcePath);
+    }
+    for (const docPath of docs) {
+      const basename2 = path5.basename(docPath, path5.extname(docPath));
+      docBasenames.set(basename2.toLowerCase(), docPath);
+    }
+    for (const [basename2, sourcePath] of sourceBasenames) {
+      if (!docBasenames.has(basename2)) {
+        errors.push({
+          type: "missing-doc",
+          category: category.name,
+          sourcePath,
+          expectedBasename: basename2
+        });
+      }
+    }
+    for (const [basename2, docPath] of docBasenames) {
+      if (!sourceBasenames.has(basename2)) {
+        errors.push({
+          type: "orphaned-doc",
+          category: category.name,
+          docPath,
+          expectedBasename: basename2
+        });
+      }
+    }
+    totalSources += sourceBasenames.size;
+    totalDocs += docBasenames.size;
+  }
+  return {
+    exitCode: errors.length > 0 ? 1 : 0,
+    errors,
+    summary: {
+      categoriesChecked: allCategories.length,
+      totalSources,
+      totalDocs
+    }
+  };
+}
+function formatSyncCheckReport(result) {
+  const lines = [];
+  lines.push(chalk3.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
+  if (result.errors.length > 0) {
+    lines.push(chalk3.red.bold("Errors:\n"));
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const error of result.errors) {
+      const existing = byCategory.get(error.category) ?? [];
+      existing.push(error);
+      byCategory.set(error.category, existing);
+    }
+    for (const [category, categoryErrors] of byCategory) {
+      lines.push(chalk3.cyan(`  Category: ${category}
+`));
+      for (const error of categoryErrors) {
+        if (error.type === "missing-doc") {
+          lines.push(`  ${chalk3.red(error.sourcePath)}`);
+          lines.push(`    ${chalk3.yellow("Missing documentation for:")} ${error.expectedBasename}`);
         } else {
-          fail(ctx, `${respLabel}: databucketID "${resp.databucketID}" not found in data array`);
+          lines.push(`  ${chalk3.red(error.docPath)}`);
+          lines.push(
+            `    ${chalk3.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
+          );
         }
+        lines.push("");
       }
     }
+  } else {
+    lines.push(chalk3.green("All source files have corresponding documentation.\n"));
+  }
+  lines.push(chalk3.bold("Summary:"));
+  lines.push(`  Categories checked: ${result.summary.categoriesChecked}`);
+  lines.push(
+    `  Source files: ${result.summary.totalSources}, Doc files: ${result.summary.totalDocs}`
+  );
+  if (result.errors.length > 0) {
+    lines.push(chalk3.red(`  Errors: ${result.errors.length}`));
+    lines.push("");
+    lines.push(chalk3.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
+  } else {
+    lines.push(chalk3.green("  Errors: 0"));
+    lines.push("");
+    lines.push(chalk3.green.bold("docs-sync-check passed."));
   }
+  return lines.join("\n");
 }
-async function discoverAllScenarios(mocksDir) {
-  const scenarios = [];
-  const providers = await subdirs(mocksDir);
-  for (const provider of providers) {
-    const providerDir = join2(mocksDir, provider);
-    for (const scenario of await subdirs(providerDir)) {
-      scenarios.push(`${provider}/${scenario}`);
+
+// src/commands/scaffold.ts
+import path6 from "path";
+import fs3 from "fs";
+var MODULE_TYPES = ["module", "feature", "command", "model", "query"];
+var APP_TYPES = [
+  "requirements",
+  "actors",
+  "business-flow",
+  "story",
+  "screen",
+  "resolver"
+];
+var ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES];
+var MODULE_DIR_MAP = {
+  feature: "docs/features",
+  command: "docs/commands",
+  model: "docs/models",
+  query: "docs/queries"
+};
+var APP_DIR_MAP = {
+  actors: "docs/actors",
+  "business-flow": "docs/business-flow",
+  screen: "docs/screen",
+  resolver: "docs/resolver"
+};
+function resolveScaffoldPath(type, parentName, name, root) {
+  if (type === "module" || type === "requirements") {
+    return path6.join(root, parentName, "README.md");
+  }
+  if (!name) {
+    throw new Error(`Name is required for scaffold type "${type}"`);
+  }
+  if (type === "business-flow") {
+    return path6.join(root, parentName, "docs/business-flow", name, "README.md");
+  }
+  if (type === "story") {
+    const parts = name.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`
+      );
     }
+    return path6.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
   }
-  return scenarios;
-}
-function resolveScenarioDir(arg3) {
-  const abs = resolve3(arg3);
-  if (basename(abs) === "mock.json") return dirname2(abs);
-  return abs;
-}
-async function validateScenario(ctx, scenarioDir, mocksDir) {
-  const label = relative2(mocksDir, scenarioDir);
-  console.log(chalk3.bold(`
-\u2500\u2500 ${label} \u2500\u2500`));
-  let entries;
-  try {
-    entries = await readdir(scenarioDir);
-  } catch {
-    fail(ctx, `${label}: directory not found`);
-    return;
+  if (MODULE_DIR_MAP[type]) {
+    return path6.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
   }
-  const hasMock = checkStructure(ctx, entries, label);
-  if (!hasMock) return;
-  const mockPath = join2(scenarioDir, "mock.json");
-  let data;
-  try {
-    data = JSON.parse(await readFile(mockPath, "utf-8"));
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    fail(ctx, `${label}: invalid JSON \u2014 ${errMsg}`);
-    return;
+  if (APP_DIR_MAP[type]) {
+    return path6.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
   }
-  await checkSchema(ctx, data, label);
-  checkResponseQuality(ctx, data, label);
-  checkDatabucketRefs(ctx, data, label);
+  throw new Error(`Unknown scaffold type: ${type}`);
 }
-async function runMockValidate(mocksRoot, paths) {
-  const ctx = { failures: 0 };
-  const mocksDir = resolve3(mocksRoot);
-  const targets = paths.length > 0 ? paths.map(resolveScenarioDir) : (await discoverAllScenarios(mocksDir)).map((s) => join2(mocksDir, s));
-  if (targets.length === 0) {
-    fail(ctx, "No scenarios found under mocks/");
+async function runScaffold(type, parentName, name, root, cwd4) {
+  const outputPath = resolveScaffoldPath(type, parentName, name, root);
+  const absoluteOutput = path6.resolve(cwd4, outputPath);
+  if (fs3.existsSync(absoluteOutput)) {
+    console.error(`File already exists: ${outputPath}`);
     return 1;
   }
-  console.log(chalk3.bold("\nValidating mock configs...\n"));
-  for (const target of targets) {
-    await validateScenario(ctx, target, mocksDir);
+  const schemaPath = ALL_SCHEMAS[type];
+  if (!schemaPath) {
+    console.error(`No schema found for type: ${type}`);
+    return 2;
   }
-  console.log(chalk3.bold("\n\u2500\u2500 summary \u2500\u2500"));
-  if (ctx.failures === 0) {
-    console.log(chalk3.green("\u2713 All checks passed"));
-  } else {
-    console.log(chalk3.red(`\u2717 ${ctx.failures} check(s) failed`));
+  try {
+    fs3.mkdirSync(path6.dirname(absoluteOutput), { recursive: true });
+  } catch (err) {
+    console.error(
+      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
   }
-  return ctx.failures === 0 ? 0 : 1;
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
+    cwd4
+  );
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+  return exitCode;
 }
 
-// src/commands/mock/index.ts
-var startCommand = defineCommand({
-  name: "start",
-  description: "Start mock API servers with reverse proxy",
-  args: z.object({
-    mocksRoot: arg(z.string().default("./mocks"), {
-      description: "Path to mocks directory"
-    }),
-    port: arg(z.coerce.number().default(3e3), {
-      alias: "p",
-      description: "Reverse proxy port"
-    }),
-    filter: arg(z.array(z.string()).default([]), {
-      positional: true,
-      description: "Filter by provider or provider/scenario"
-    })
-  }),
+// src/commands/module/list.ts
+import { readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import chalk4 from "chalk";
+var MODULES_DIR = join3(PACKAGE_ROOT, "src", "modules");
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["shared", "testing"]);
+function countFiles(dir, pattern, exclusions) {
+  if (!existsSync2(dir)) return 0;
+  return readdirSync2(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
+}
+function listModules() {
+  if (!existsSync2(MODULES_DIR)) return [];
+  return readdirSync2(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).map((d) => {
+    const modDir = join3(MODULES_DIR, d.name);
+    return {
+      name: d.name,
+      commands: countFiles(join3(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
+      models: countFiles(join3(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
+      features: countFiles(join3(modDir, "docs", "features"), /\.md$/, [])
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function formatModuleList(modules) {
+  if (modules.length === 0) return "No modules found.";
+  const lines = [];
+  lines.push(chalk4.bold("Modules:\n"));
+  const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
+  for (const mod of modules) {
+    const counts = [
+      `${mod.commands} commands`,
+      `${mod.models} models`,
+      `${mod.features} features`
+    ].join(", ");
+    lines.push(`  ${mod.name.padEnd(nameWidth)}  ${counts}`);
+  }
+  lines.push("");
+  lines.push(`${modules.length} modules`);
+  return lines.join("\n");
+}
+function runModuleList() {
+  const modules = listModules();
+  console.log(formatModuleList(modules));
+  return 0;
+}
+
+// src/commands/module/index.ts
+var cwd = process.cwd();
+var rootArgs = z2.object({
+  root: arg2(z2.string(), {
+    alias: "r",
+    description: "Path to modules directory"
+  })
+});
+var listCommand = defineCommand2({
+  name: "list",
+  description: "List available modules",
+  run: () => {
+    const exitCode = runModuleList();
+    process.exit(exitCode);
+  }
+});
+var checkCommand = defineCommand2({
+  name: "check",
+  description: "Validate module docs against schemas",
+  args: rootArgs,
   run: async (args) => {
-    const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
+    const exitCode = await runCheck({ modulesRoot: args.root }, cwd);
     process.exit(exitCode);
   }
 });
-var validateCommand = defineCommand({
-  name: "validate",
-  description: "Validate mock scenario configs",
-  args: z.object({
-    mocksRoot: arg(z.string().default("./mocks"), {
-      description: "Path to mocks directory"
+var syncCheckCommand = defineCommand2({
+  name: "sync-check",
+  description: "Validate source <-> doc correspondence",
+  args: rootArgs,
+  run: async (args) => {
+    const result = await runSyncCheck({ modulesRoot: args.root }, cwd);
+    console.log(formatSyncCheckReport(result));
+    process.exit(result.exitCode);
+  }
+});
+var scaffoldCommand = defineCommand2({
+  name: "scaffold",
+  description: "Generate module doc from schema template",
+  args: rootArgs.extend({
+    type: arg2(z2.enum(MODULE_TYPES), {
+      positional: true,
+      description: `Scaffold type (${MODULE_TYPES.join(", ")})`
     }),
-    paths: arg(z.array(z.string()).default([]), {
+    parent: arg2(z2.string(), {
       positional: true,
-      description: "Specific scenario paths to validate"
+      description: "Module name"
+    }),
+    name: arg2(z2.string().optional(), {
+      positional: true,
+      description: "Item name (required for feature, command, model)"
     })
   }),
   run: async (args) => {
-    const exitCode = await runMockValidate(args.mocksRoot, args.paths);
+    const exitCode = await runScaffold(
+      args.type,
+      args.parent,
+      args.name,
+      args.root,
+      cwd
+    );
     process.exit(exitCode);
   }
 });
-var mockCommand = defineCommand({
-  name: "mock",
-  description: "Mock API server management",
+var moduleCommand = defineCommand2({
+  name: "module",
+  description: "Module management",
   subCommands: {
-    start: startCommand,
-    validate: validateCommand
+    list: listCommand,
+    check: checkCommand,
+    "sync-check": syncCheckCommand,
+    scaffold: scaffoldCommand
   }
 });
 
-// src/cli.ts
-var cwd = process.cwd();
-var rootArgs = z2.object({
-  modulesRoot: arg2(z2.string().optional(), {
-    alias: "m",
-    description: "Path to modules directory"
-  }),
-  appRoot: arg2(z2.string().optional(), {
-    alias: "a",
-    description: "Path to app-compose directory (apps/ or examples/)"
+// src/commands/app/index.ts
+import { z as z3 } from "zod";
+import { defineCommand as defineCommand3, arg as arg3 } from "politty";
+var cwd2 = process.cwd();
+var rootArgs2 = z3.object({
+  root: arg3(z3.string(), {
+    alias: "r",
+    description: "Path to app-compose directory"
   })
 });
-function requireRoot(args) {
-  const paths = { modulesRoot: args.modulesRoot, appRoot: args.appRoot };
-  if (!paths.modulesRoot && !paths.appRoot) {
-    console.error("At least one of --modules-root or --app-root is required.");
-    process.exit(2);
-  }
-  return paths;
-}
-var checkCommand = defineCommand2({
+var checkCommand2 = defineCommand3({
   name: "check",
-  description: "Validate docs against schemas",
-  args: rootArgs,
+  description: "Validate app docs against schemas",
+  args: rootArgs2,
   run: async (args) => {
-    const paths = requireRoot(args);
-    const exitCode = await runCheck(paths, cwd);
+    const exitCode = await runCheck({ appRoot: args.root }, cwd2);
     process.exit(exitCode);
   }
 });
-var syncCheckCommand = defineCommand2({
+var syncCheckCommand2 = defineCommand3({
   name: "sync-check",
   description: "Validate source <-> doc correspondence",
-  args: rootArgs,
+  args: rootArgs2,
   run: async (args) => {
-    const paths = requireRoot(args);
-    const result = await runSyncCheck(paths, cwd);
+    const result = await runSyncCheck({ appRoot: args.root }, cwd2);
     console.log(formatSyncCheckReport(result));
     process.exit(result.exitCode);
   }
 });
-var scaffoldCommand = defineCommand2({
+var scaffoldCommand2 = defineCommand3({
   name: "scaffold",
-  description: "Generate doc file from schema template",
-  args: rootArgs.extend({
-    type: arg2(z2.enum(ALL_TYPES), {
+  description: "Generate app doc from schema template",
+  args: rootArgs2.extend({
+    type: arg3(z3.enum(APP_TYPES), {
       positional: true,
-      description: `Scaffold type (${ALL_TYPES.join(", ")})`
+      description: `Scaffold type (${APP_TYPES.join(", ")})`
     }),
-    parent: arg2(z2.string(), {
+    parent: arg3(z3.string(), {
       positional: true,
-      description: "Parent name (module or app name)"
+      description: "App name"
     }),
-    name: arg2(z2.string().optional(), {
+    name: arg3(z3.string().optional(), {
       positional: true,
       description: "Item name (required for most types)"
     })
   }),
   run: async (args) => {
-    const paths = requireRoot(args);
-    const root = isModuleType(args.type) ? paths.modulesRoot : paths.appRoot;
-    if (!root) {
-      console.error(
-        `--${isModuleType(args.type) ? "modules-root" : "app-root"} is required for scaffold type "${args.type}".`
-      );
-      process.exit(2);
-    }
     const exitCode = await runScaffold(
       args.type,
       args.parent,
       args.name,
-      root,
-      cwd
+      args.root,
+      cwd2
     );
     process.exit(exitCode);
   }
 });
-var initCommand = defineCommand2({
+var appCommand = defineCommand3({
+  name: "app",
+  description: "App-compose management",
+  subCommands: {
+    check: checkCommand2,
+    "sync-check": syncCheckCommand2,
+    scaffold: scaffoldCommand2
+  }
+});
+
+// src/cli.ts
+var cwd3 = process.cwd();
+var initCommand = defineCommand4({
   name: "init",
-  description: "Set up consumer repo (skills, rules)",
-  args: z2.object({
-    force: arg2(z2.boolean().default(false), {
+  description: "Set up consumer repo with framework skills",
+  args: z4.object({
+    force: arg4(z4.boolean().default(false), {
       alias: "f",
-      description: "Overwrite existing skills and rules"
+      description: "Overwrite existing skills"
     })
   }),
   run: (args) => {
-    const exitCode = runInit(cwd, args.force);
+    const exitCode = runInit(cwd3, args.force);
     process.exit(exitCode);
   }
 });
-var main = defineCommand2({
+var main = defineCommand4({
   name: "erp-kit",
-  description: "Documentation validation and scaffolding tool",
+  description: "ERP module framework CLI",
   subCommands: {
-    check: checkCommand,
-    "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
-    init: initCommand,
-    mock: mockCommand
+    module: moduleCommand,
+    app: appCommand,
+    mock: mockCommand,
+    init: initCommand
   }
 });
 void runMain(main);