@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/src/commands/init-module.test.ts

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, afterEach } from "vitest";
+import { runInitModule, runInitApp } from "./init-module";
+
+describe("runInitModule", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("creates module directory", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "init-module-test-"));
+    const moduleDir = path.join(tmpDir, "my-module");
+    fs.mkdirSync(moduleDir, { recursive: true });
+
+    const exitCode = runInitModule("my-module", tmpDir);
+    expect(exitCode).toBe(1); // should fail — dir exists
+  });
+});
+
+describe("runInitApp", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("errors if app directory already exists", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "init-app-test-"));
+    const appDir = path.join(tmpDir, "my-app");
+    fs.mkdirSync(appDir, { recursive: true });
+
+    const exitCode = runInitApp("my-app", tmpDir);
+    expect(exitCode).toBe(1);
+  });
+});

package/src/commands/init-module.ts

@@ -0,0 +1,74 @@
+import path from "node:path";
+import fs from "node:fs";
+import { runMdschema } from "../mdschema";
+import { MODULE_SCHEMAS, APP_COMPOSE_SCHEMAS } from "../schemas";
+
+export function runInitModule(name: string, dir: string): number {
+  const moduleDir = path.resolve(dir, name);
+
+  if (fs.existsSync(moduleDir)) {
+    console.error(`Directory already exists: ${moduleDir}`);
+    return 1;
+  }
+
+  fs.mkdirSync(moduleDir, { recursive: true });
+  return 0;
+}
+
+export async function runInitModuleWithReadme(
+  name: string,
+  dir: string,
+  cwd: string,
+): Promise<number> {
+  const initResult = runInitModule(name, dir);
+  if (initResult !== 0) return initResult;
+
+  const moduleDir = path.resolve(cwd, dir, name);
+  const readmePath = path.join(moduleDir, "README.md");
+  const schemaPath = MODULE_SCHEMAS.module;
+
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", readmePath],
+    cwd,
+  );
+
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+
+  return exitCode;
+}
+
+export function runInitApp(name: string, dir: string): number {
+  const appDir = path.resolve(dir, name);
+
+  if (fs.existsSync(appDir)) {
+    console.error(`Directory already exists: ${appDir}`);
+    return 1;
+  }
+
+  fs.mkdirSync(appDir, { recursive: true });
+  return 0;
+}
+
+export async function runInitAppWithReadme(
+  name: string,
+  dir: string,
+  cwd: string,
+): Promise<number> {
+  const initResult = runInitApp(name, dir);
+  if (initResult !== 0) return initResult;
+
+  const appDir = path.resolve(cwd, dir, name);
+  const readmePath = path.join(appDir, "README.md");
+  const schemaPath = APP_COMPOSE_SCHEMAS.app;
+
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", readmePath],
+    cwd,
+  );
+
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+
+  return exitCode;
+}

package/src/commands/init.test.ts

@@ -15,91 +15,44 @@ describe("runInit", () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
-  it("copies framework skills to .agents/skills/", () => {
-    runInit(tmpDir, false);
-    const skillPath = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs", "SKILL.md");
-    expect(fs.existsSync(skillPath)).toBe(true);
-  });
+  it("copies skills, workflows, config, and symlink on fresh repo", () => {
+    const exitCode = runInit(tmpDir);
+    expect(exitCode).toBe(0);
 
-  it("copies skill references/ directories", () => {
-    runInit(tmpDir, false);
-    const refPath = path.join(
+    // Skills
+    const skillPath = path.join(
       tmpDir,
       ".agents",
       "skills",
-      "erp-kit-module-4-tdd",
-      "references",
-      "models.md",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
     );
-    expect(fs.existsSync(refPath)).toBe(true);
-
-    const content = fs.readFileSync(refPath, "utf-8");
-    expect(content).toContain("# Database Models");
-  });
-
-  it("does not overwrite project-specific skills", () => {
-    const customSkillDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
-    fs.mkdirSync(customSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(customSkillDir, "SKILL.md"), "# Custom");
-    runInit(tmpDir, false);
-    const content = fs.readFileSync(path.join(customSkillDir, "SKILL.md"), "utf-8");
-    expect(content).toBe("# Custom");
-  });
-
-  it("does not overwrite existing framework skills", () => {
-    const skillDir = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
-    runInit(tmpDir, false);
-    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
-    expect(content).toBe("# Customized");
-  });
-
-  it("overwrites existing framework skills with --force", () => {
-    const skillDir = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
-    runInit(tmpDir, true);
-    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
-    expect(content).not.toBe("# Customized");
-  });
+    expect(fs.existsSync(skillPath)).toBe(true);
 
-  it("creates .claude/skills symlink to .agents/skills", () => {
-    runInit(tmpDir, false);
+    // Symlink
     const claudeSkills = path.join(tmpDir, ".claude", "skills");
     expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(true);
-    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
-  });
 
-  it("skips symlink when .claude/skills is a real directory", () => {
-    const claudeSkills = path.join(tmpDir, ".claude", "skills");
-    fs.mkdirSync(claudeSkills, { recursive: true });
-    runInit(tmpDir, false);
-    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
+    // Workflows
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+
+    // Config
+    const configPath = path.join(tmpDir, "license.config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
   });
 
-  it("removes stale erp-kit-* skills with --force", () => {
-    const staleDir = path.join(tmpDir, ".agents", "skills", "erp-kit-old-skill");
-    fs.mkdirSync(staleDir, { recursive: true });
-    fs.writeFileSync(path.join(staleDir, "SKILL.md"), "# Stale");
-    runInit(tmpDir, true);
-    expect(fs.existsSync(staleDir)).toBe(false);
+  it("refuses to run if already initialized", () => {
+    runInit(tmpDir);
+    const exitCode = runInit(tmpDir);
+    expect(exitCode).toBe(1);
   });
 
-  it("preserves non-erp-kit skills with --force", () => {
+  it("preserves non-erp-kit skills", () => {
     const customDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
     fs.mkdirSync(customDir, { recursive: true });
     fs.writeFileSync(path.join(customDir, "SKILL.md"), "# Custom");
-    runInit(tmpDir, true);
-    expect(fs.existsSync(path.join(customDir, "SKILL.md"))).toBe(true);
+    runInit(tmpDir);
     expect(fs.readFileSync(path.join(customDir, "SKILL.md"), "utf-8")).toBe("# Custom");
   });
-
-  it("relinks symlink with --force when target differs", () => {
-    const claudeSkills = path.join(tmpDir, ".claude", "skills");
-    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
-    fs.symlinkSync("../old-target", claudeSkills);
-    runInit(tmpDir, true);
-    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
-  });
 });

package/src/commands/init.ts

@@ -1,127 +1,40 @@
-import fs from "node:fs";
-import path from "node:path";
 import chalk from "chalk";
-import { PACKAGE_ROOT } from "../util";
-
-const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
-
-function discoverFrameworkSkills(): string[] {
-  if (!fs.existsSync(SKILLS_SRC)) return [];
-  return fs
-    .readdirSync(SKILLS_SRC, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name.startsWith("erp-kit-"))
-    .map((entry) => entry.name);
-}
-
-function copyDirectoryRecursive(
-  srcDir: string,
-  destDir: string,
-  force: boolean,
-): { copied: number; skipped: number } {
-  let copied = 0;
-  let skipped = 0;
-
-  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = path.join(srcDir, entry.name);
-    const destPath = path.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;
-      }
-      fs.mkdirSync(destDir, { recursive: true });
-      fs.copyFileSync(srcPath, destPath);
-      copied++;
-    }
-  }
-
-  return { copied, skipped };
-}
-
-export function runInit(cwd: string, force: boolean): number {
+import {
+  copySkills,
+  copyWorkflows,
+  copyConfigs,
+  setupSymlink,
+  isAlreadyInitialized,
+} from "./lib/distribute";
+
+export function runInit(cwd: string): number {
   console.log(chalk.bold("erp-kit init\n"));
 
-  // --- Skills ---
-  const skillsDest = path.join(cwd, ".agents", "skills");
-
-  // Clean up existing erp-kit-* skills before copying to remove stale names
-  if (force && fs.existsSync(skillsDest)) {
-    let removedCount = 0;
-    for (const entry of fs.readdirSync(skillsDest)) {
-      if (entry.startsWith("erp-kit-")) {
-        fs.rmSync(path.join(skillsDest, entry), { recursive: true, force: true });
-        removedCount++;
-      }
-    }
-    if (removedCount > 0) {
-      console.log(chalk.green(`  Removed ${removedCount} existing erp-kit-* skills`));
-    }
-  }
-
-  let copiedCount = 0;
-  let skippedCount = 0;
-  const frameworkSkills = discoverFrameworkSkills();
-  for (const skill of frameworkSkills) {
-    const srcSkillDir = path.join(SKILLS_SRC, skill);
-    if (!fs.existsSync(srcSkillDir)) continue;
-
-    const destDir = path.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;
-    }
-  }
-  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
-  if (skippedCount > 0) {
+  if (isAlreadyInitialized(cwd)) {
     console.log(
-      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`),
+      chalk.yellow("Already initialized. Use `erp-kit update` to refresh framework resources."),
     );
+    return 1;
   }
 
-  // --- Claude Code symlink ---
-  const claudeSkills = path.join(cwd, ".claude", "skills");
-  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+  const skills = copySkills(cwd);
+  console.log(chalk.green(`  Copied ${skills.copied} skill files to .agents/skills/`));
 
-  // lstatSync doesn't follow symlinks, so dangling symlinks are detected
-  const claudeSkillsExists = (() => {
-    try {
-      fs.lstatSync(claudeSkills);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-
-  if (claudeSkillsExists) {
-    const stat = fs.lstatSync(claudeSkills);
-    if (stat.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 {
-    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
-    fs.symlinkSync(relTarget, claudeSkills);
+  const symlink = setupSymlink(cwd);
+  if (symlink === "linked") {
     console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
+  } else if (symlink === "skipped_directory") {
+    console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
+  }
+
+  const workflows = copyWorkflows(cwd);
+  if (workflows.copied > 0) {
+    console.log(chalk.green(`  Copied ${workflows.copied} workflow(s) to .github/workflows/`));
+  }
+
+  const configs = copyConfigs(cwd);
+  if (configs.copied > 0) {
+    console.log(chalk.green(`  Copied ${configs.copied} config file(s)`));
   }
 
   console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));

package/src/commands/lib/distribute.test.ts

@@ -0,0 +1,126 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { copySkills, copyWorkflows, copyConfigs, setupSymlink } from "./distribute";
+
+describe("copySkills", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies erp-kit-* skills to destination", () => {
+    const result = copySkills(tmpDir);
+    const skillPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
+    );
+    expect(fs.existsSync(skillPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+
+  it("removes stale erp-kit-* skills before copying", () => {
+    const staleDir = path.join(tmpDir, ".agents", "skills", "erp-kit-old-skill");
+    fs.mkdirSync(staleDir, { recursive: true });
+    fs.writeFileSync(path.join(staleDir, "SKILL.md"), "# Stale");
+    const result = copySkills(tmpDir);
+    expect(fs.existsSync(staleDir)).toBe(false);
+    expect(result.removed).toBe(1);
+  });
+
+  it("preserves non-erp-kit skills", () => {
+    const customDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
+    fs.mkdirSync(customDir, { recursive: true });
+    fs.writeFileSync(path.join(customDir, "SKILL.md"), "# Custom");
+    copySkills(tmpDir);
+    expect(fs.readFileSync(path.join(customDir, "SKILL.md"), "utf-8")).toBe("# Custom");
+  });
+});
+
+describe("copyWorkflows", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies workflow templates to .github/workflows/", () => {
+    const result = copyWorkflows(tmpDir);
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+
+  it("overwrites existing workflows", () => {
+    const wfDir = path.join(tmpDir, ".github", "workflows");
+    fs.mkdirSync(wfDir, { recursive: true });
+    fs.writeFileSync(path.join(wfDir, "erp-kit-check.yml"), "# Old");
+    copyWorkflows(tmpDir);
+    const content = fs.readFileSync(path.join(wfDir, "erp-kit-check.yml"), "utf-8");
+    expect(content).not.toBe("# Old");
+  });
+});
+
+describe("copyConfigs", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies config files to repo root", () => {
+    const result = copyConfigs(tmpDir);
+    const configPath = path.join(tmpDir, "license.config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+});
+
+describe("setupSymlink", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates .claude/skills symlink", () => {
+    setupSymlink(tmpDir);
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(true);
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
+  });
+
+  it("skips when correct symlink already exists", () => {
+    setupSymlink(tmpDir);
+    const result = setupSymlink(tmpDir);
+    expect(result).toBe("already_linked");
+  });
+
+  it("skips when .claude/skills is a real directory", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(claudeSkills, { recursive: true });
+    const result = setupSymlink(tmpDir);
+    expect(result).toBe("skipped_directory");
+  });
+});

package/src/commands/lib/distribute.ts

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PACKAGE_ROOT } from "../../util";
+
+const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
+const WORKFLOWS_SRC = path.join(PACKAGE_ROOT, "templates", "workflows");
+const CONFIG_SRC = path.join(PACKAGE_ROOT, "templates", "config");
+
+export interface CopyResult {
+  copied: number;
+  removed: number;
+}
+
+function copyDirectoryRecursive(srcDir: string, destDir: string): number {
+  let copied = 0;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copied += copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+  return copied;
+}
+
+function discoverFrameworkSkills(): string[] {
+  if (!fs.existsSync(SKILLS_SRC)) return [];
+  return fs
+    .readdirSync(SKILLS_SRC, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith("erp-kit-"))
+    .map((entry) => entry.name);
+}
+
+export function copySkills(cwd: string): CopyResult {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+
+  let removed = 0;
+  if (fs.existsSync(skillsDest)) {
+    for (const entry of fs.readdirSync(skillsDest)) {
+      if (entry.startsWith("erp-kit-")) {
+        fs.rmSync(path.join(skillsDest, entry), { recursive: true, force: true });
+        removed++;
+      }
+    }
+  }
+
+  let copied = 0;
+  for (const skill of discoverFrameworkSkills()) {
+    const srcSkillDir = path.join(SKILLS_SRC, skill);
+    if (!fs.existsSync(srcSkillDir)) continue;
+    const destDir = path.join(skillsDest, skill);
+    copied += copyDirectoryRecursive(srcSkillDir, destDir);
+  }
+
+  return { copied, removed };
+}
+
+export function copyWorkflows(cwd: string): CopyResult {
+  const workflowsDest = path.join(cwd, ".github", "workflows");
+  if (!fs.existsSync(WORKFLOWS_SRC)) return { copied: 0, removed: 0 };
+
+  const workflowFiles = fs
+    .readdirSync(WORKFLOWS_SRC)
+    .filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+
+  let copied = 0;
+  for (const file of workflowFiles) {
+    fs.mkdirSync(workflowsDest, { recursive: true });
+    fs.copyFileSync(path.join(WORKFLOWS_SRC, file), path.join(workflowsDest, file));
+    copied++;
+  }
+
+  return { copied, removed: 0 };
+}
+
+export function copyConfigs(cwd: string): CopyResult {
+  if (!fs.existsSync(CONFIG_SRC)) return { copied: 0, removed: 0 };
+
+  let copied = 0;
+  for (const entry of fs.readdirSync(CONFIG_SRC)) {
+    const destPath = path.join(cwd, entry);
+    fs.copyFileSync(path.join(CONFIG_SRC, entry), destPath);
+    copied++;
+  }
+
+  return { copied, removed: 0 };
+}
+
+export type SymlinkResult = "linked" | "already_linked" | "skipped_directory";
+
+export function setupSymlink(cwd: string): SymlinkResult {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  const claudeSkills = path.join(cwd, ".claude", "skills");
+  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+
+  let exists = false;
+  try {
+    fs.lstatSync(claudeSkills);
+    exists = true;
+  } catch {
+    // doesn't exist
+  }
+
+  if (exists) {
+    const stat = fs.lstatSync(claudeSkills);
+    if (stat.isSymbolicLink()) {
+      const current = fs.readlinkSync(claudeSkills);
+      if (current === relTarget) return "already_linked";
+      fs.unlinkSync(claudeSkills);
+      fs.symlinkSync(relTarget, claudeSkills);
+      return "linked";
+    }
+    return "skipped_directory";
+  }
+
+  fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+  fs.symlinkSync(relTarget, claudeSkills);
+  return "linked";
+}
+
+export function isAlreadyInitialized(cwd: string): boolean {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  if (!fs.existsSync(skillsDest)) return false;
+  return fs.readdirSync(skillsDest).some((entry) => entry.startsWith("erp-kit-"));
+}