@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/skills/erp-kit-module-6-impl-review/references/query-doc-test-parity.md

@@ -0,0 +1,108 @@
+# Query Doc → Test Coverage Parity Check
+
+## Context
+
+Module: {{MODULE_NAME}}
+Query docs: {{QUERY_DOCS}}
+Test code: {{QUERY_TEST_CODE}}
+
+## Instructions
+
+1. Read ALL query docs at the paths above
+2. Read ALL test code files at the paths above
+3. For each query doc, extract process flow branches, error scenarios, and edge cases
+4. For each test file, extract test case descriptions and assertions
+5. Run every parity check below against each query
+6. Return results as JSON per the Output Format section
+
+## Extraction: Query Docs
+
+From each query doc, extract:
+
+### Process Flow Branches
+
+From the mermaid flowchart, identify each decision node and its outcomes:
+
+- Decision: "Permission check?" → Authorized path, Unauthorized path
+- Decision: "Entity exists?" → Found path, Not found path
+- Decision: "Scope valid?" → Valid scope path, Invalid scope path
+- Each terminal node = one expected test case
+
+### Error Scenarios
+
+From the Error Scenarios section:
+
+- Error code + condition = one expected error test case
+
+### Null/Empty Return Paths
+
+From the process flow, identify "not found → return null" or "no results → return empty array" patterns:
+
+- These need explicit test cases
+
+### Pagination Scenarios
+
+For paginated queries:
+
+- Has more results → `hasNextPage: true`
+- Last page → `hasNextPage: false`
+- Empty results → empty items array
+
+## Extraction: Test Code
+
+From each test file (`query/*.test.ts`), extract:
+
+- **Test descriptions**: `it("...")` or `test("...")` strings
+- **Error assertions**: checks for specific error types/codes
+- **Happy path tests**: tests that verify successful outcomes
+- **Null/empty result tests**: tests that verify not-found or empty list handling
+- **Authorization tests**: tests that verify permission and scope checks
+- **Fixture usage**: which fixtures are used
+
+See [testing.md](testing.md) for canonical testing patterns.
+
+## Parity Checks
+
+For each query:
+
+| Check ID                | Question                                                     |
+| ----------------------- | ------------------------------------------------------------ |
+| process_flow_coverage   | Does each branch in process flow have a test case?           |
+| error_scenario_tests    | Does each documented error scenario have a test assertion?   |
+| happy_path_tests        | Are success paths tested?                                    |
+| null_empty_result_tests | If doc shows "not found → null" or "empty → []", is tested? |
+| authorization_tests     | Are permission and scope check paths tested?                 |
+| pagination_tests        | If doc describes pagination, are boundary cases tested?      |
+
+### How to Check
+
+1. Count process flow branches from query doc flowchart
+2. Count test cases in corresponding test file
+3. Map each branch to a test case by description/assertion
+4. Identify any branches without corresponding tests
+
+## Common Gap Patterns
+
+- **Uncovered process branches**: Flowchart branch has no test
+- **Missing error tests**: Error scenario has no assertion
+- **Missing null/empty tests**: "Not found → null" path untested
+- **Missing authorization tests**: Permission or scope check untested
+- **Missing pagination edge cases**: hasNextPage boundary untested
+- **Missing filter combination tests**: Search queries with multiple filters untested
+- **Test without doc branch**: Test exists but doesn't map to documented flow (potential doc gap)
+
+## Output Format
+
+Return a JSON object:
+
+```json
+{
+  "check_type": "query-doc-test-parity",
+  "module": "{{MODULE_NAME}}",
+  "gaps": [...],
+  "inconsistencies": [...],
+  "summary": { "total_checks": N, "passed": N, "failed": N, "skipped": N }
+}
+```
+
+See [impl-parity-report-format.md](impl-parity-report-format.md) for field definitions.

package/skills/erp-kit-module-6-impl-review/references/query-error-implementation-parity.md

@@ -0,0 +1,100 @@
+# Query Error Implementation Parity Check
+
+## Context
+
+Module: {{MODULE_NAME}}
+Query docs: {{QUERY_DOCS}}
+Error definitions: {{ERROR_DEFS}}
+Query code: {{QUERY_CODE}}
+Test code: {{QUERY_TEST_CODE}}
+
+## Instructions
+
+1. Read ALL query docs at the paths above
+2. Read the error definitions file at the path above
+3. Read ALL query code files at the paths above
+4. Read ALL test code files at the paths above
+5. For each documented error scenario, trace through generated class → query return → test assertion
+6. Run every parity check below
+7. Return results as JSON per the Output Format section
+
+## Extraction: Query Docs
+
+From each query doc's Error Scenarios section, extract:
+
+- **Error code**: e.g. `INSUFFICIENT_PERMISSION`, `INVALID_SCOPE`
+- **Condition**: when this error is returned
+- **Expected class name**: derived from error code (PascalCase + `Error` suffix)
+
+## Extraction: Error Definitions
+
+From `lib/errors.generated.ts`, extract:
+
+- **Error class names**: exported error classes
+- **Error codes**: the code constant in each class
+- **Error message patterns**: message templates
+
+See [errors.md](errors.md) for error generation patterns.
+
+## Extraction: Query Code
+
+From each query file (`query/*.ts`, excluding `*.test.ts` and `*.generated.ts`), extract:
+
+- **Error imports**: which error classes are imported from `../lib/errors.generated`
+- **Error returns**: `return err(new XError(...))` statements
+- **Error codes used**: which error codes appear in the code
+- **Permission checks**: `requirePermission(ctx, ...)` calls that return errors
+- **Scope checks**: scope authorization checks that return errors
+
+## Extraction: Test Code
+
+From each test file (`query/*.test.ts`), extract:
+
+- **Error assertions**: tests that check for specific error types or codes
+- **Error test descriptions**: test names that reference error scenarios
+- **Authorization test cases**: tests verifying permission/scope rejections
+
+## Parity Checks
+
+For each error scenario documented in query docs:
+
+| Check ID              | Question                                                                                                                                     |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| error_class_generated | Does the error class exist in `errors.generated.ts`?                                                                                         |
+| error_code_accuracy   | Does the generated error code equal `{MODULE_PREFIX}_{DOC_CODE}`? The generator prefixes doc codes with the module name in UPPER_SNAKE_CASE. |
+| error_returned        | Does the query code return this error via `err(new XError(...))`?                                                                            |
+| error_import          | Does the query code import the error class from `errors.generated`?                                                                          |
+| error_test_exists     | Does a test case assert this error scenario?                                                                                                 |
+
+### How to Check
+
+1. List all error codes from query docs
+2. Verify each has a generated class in `errors.generated.ts`
+3. Check query code imports and returns the error
+4. Check test file has an assertion for this error
+
+## Common Gap Patterns
+
+- **Missing error class**: Error code in doc but no generated class (re-run `erp-kit module generate code -p <path>`)
+- **Error not returned**: Generated class exists but query code doesn't return it
+- **Error not imported**: Query uses inline error instead of generated class
+- **Missing error test**: Error is returned in code but no test asserts it
+- **Error code mismatch**: Doc code differs from generated/code code
+- **Missing permission error**: Doc requires permission but no `requirePermission` call in code
+- **Missing scope error**: Doc describes scope restriction but no scope check in code
+
+## Output Format
+
+Return a JSON object:
+
+```json
+{
+  "check_type": "query-error-implementation-parity",
+  "module": "{{MODULE_NAME}}",
+  "gaps": [...],
+  "inconsistencies": [...],
+  "summary": { "total_checks": N, "passed": N, "failed": N, "skipped": N }
+}
+```
+
+See [impl-parity-report-format.md](impl-parity-report-format.md) for field definitions.

package/src/commands/app/index.ts

@@ -5,6 +5,7 @@ import { runCheck } from "../check";
 import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
 import { runGenerateDoc, APP_DOC_TYPES, type DocType } from "../generate-doc";
 import { runGenerateAppCode } from "../../generator/generate-app-code";
+import { runGenerateSeed } from "../../generator/generate-seed";
 import { runInitAppWithReadme } from "../init-module";
 import { executeCommand, success, silentFailure } from "../lib/command-result";
 
@@ -13,7 +14,7 @@ const cwd = process.cwd();
 const pathArgs = z.object({
   path: arg(z.string(), {
     alias: "p",
-    description: "Path to app-compose directory",
+    description: "Path to app directory",
   }),
 });
 
@@ -97,18 +98,32 @@ const codeCommand = defineCommand({
   },
 });
 
+const seedCommand = defineCommand({
+  name: "seed",
+  description: "Generate seed data from module defaults",
+  args: pathArgs,
+  run: (args) => {
+    return executeCommand(() => {
+      const appPath = path.resolve(cwd, args.path);
+      const exitCode = runGenerateSeed(appPath);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
+  },
+});
+
 const generateCommand = defineCommand({
   name: "generate",
-  description: "Generate docs and code for an app",
+  description: "Generate docs, code, and seed data for an app",
   subCommands: {
     doc: docCommand,
     code: codeCommand,
+    seed: seedCommand,
   },
 });
 
 export const appCommand = defineCommand({
   name: "app",
-  description: "App-compose management",
+  description: "App management",
   subCommands: {
     check: checkCommand,
     "sync-check": syncCheckCommand,

package/src/commands/check.test.ts

@@ -13,7 +13,7 @@ describe("buildCheckTargets", () => {
     ]);
   });
 
-  it("generates app-compose targets when appRoot is set", () => {
+  it("generates app targets when appRoot is set", () => {
     const targets = buildCheckTargets({ modulesRoot: undefined, appRoot: "apps" });
     expect(targets[0].glob).toBe("apps/[a-zA-Z]*/README.md");
     expect(targets).toHaveLength(6);

package/src/commands/doc/module.ts

@@ -4,7 +4,6 @@ import { PACKAGE_ROOT } from "../../util";
 import { MODULE_PATHS } from "../lib/paths";
 
 const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS = new Set(["shared", "testing"]);
 
 const DOC_TYPE_MAP: Record<string, string> = {
   command: MODULE_PATHS.docs.commands,
@@ -32,7 +31,7 @@ export function runDocModule(
   docName?: string,
   format = "text",
 ): number {
-  if (!existsSync(MODULES_DIR) || EXCLUDED_DIRS.has(moduleName)) {
+  if (!existsSync(MODULES_DIR)) {
     console.error(`Module not found: ${moduleName}`);
     return 1;
   }
@@ -41,7 +40,7 @@ export function runDocModule(
   if (!existsSync(modDir)) {
     console.error(`Module not found: ${moduleName}`);
     const available = readdirSync(MODULES_DIR, { withFileTypes: true })
-      .filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name))
+      .filter((d) => d.isDirectory())
       .map((d) => d.name)
       .sort();
     console.error(`Available modules: ${available.join(", ")}`);

package/src/commands/doc/modules.test.ts

@@ -22,13 +22,6 @@ describe("getModuleOverviews", () => {
     expect(primitives!.dependencies).toEqual([]);
   });
 
-  it("excludes shared and testing directories", () => {
-    const modules = getModuleOverviews();
-    const names = modules.map((m) => m.name);
-    expect(names).not.toContain("shared");
-    expect(names).not.toContain("testing");
-  });
-
   it("returns modules in alphabetical order", () => {
     const modules = getModuleOverviews();
     const names = modules.map((m) => m.name);

package/src/commands/doc/modules.ts

@@ -4,7 +4,6 @@ import { PACKAGE_ROOT } from "../../util";
 import { MODULE_PATHS } from "../lib/paths";
 
 const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS = new Set(["shared", "testing"]);
 
 interface ModuleOverview {
   name: string;
@@ -46,7 +45,7 @@ function extractDependencies(readmePath: string): string[] {
 export function getModuleOverviews(): ModuleOverview[] {
   if (!existsSync(MODULES_DIR)) return [];
   return readdirSync(MODULES_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name))
+    .filter((d) => d.isDirectory())
     .map((d) => {
       const modDir = join(MODULES_DIR, d.name);
       const readmePath = join(modDir, "README.md");

package/src/commands/doc/search.ts

@@ -4,7 +4,6 @@ import { PACKAGE_ROOT } from "../../util";
 import { MODULE_PATHS } from "../lib/paths";
 
 const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS = new Set(["shared", "testing"]);
 
 const DOC_TYPE_MAP: Record<string, string> = {
   command: MODULE_PATHS.docs.commands,
@@ -53,7 +52,7 @@ export function searchModuleDocs(query: string, typeFilter?: string): SearchResu
 
   const results: SearchResult[] = [];
   const modules = readdirSync(MODULES_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name))
+    .filter((d) => d.isDirectory())
     .sort((a, b) => a.name.localeCompare(b.name));
 
   for (const mod of modules) {

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

@@ -14,12 +14,19 @@ describe("runInitModule", () => {
   });
 
   it("creates module directory", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "init-module-test-"));
+    const exitCode = runInitModule("my-module", tmpDir);
+    expect(exitCode).toBe(0);
+    expect(fs.existsSync(path.join(tmpDir, "my-module"))).toBe(true);
+  });
+
+  it("succeeds if module directory already exists", () => {
     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
+    expect(exitCode).toBe(0);
   });
 });
 
@@ -32,12 +39,19 @@ describe("runInitApp", () => {
     }
   });
 
-  it("errors if app directory already exists", () => {
+  it("creates app directory", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "init-app-test-"));
+    const exitCode = runInitApp("my-app", tmpDir);
+    expect(exitCode).toBe(0);
+    expect(fs.existsSync(path.join(tmpDir, "my-app"))).toBe(true);
+  });
+
+  it("succeeds 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);
+    expect(exitCode).toBe(0);
   });
 });

package/src/commands/init-module.ts

@@ -5,12 +5,6 @@ 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;
 }
@@ -40,12 +34,6 @@ export async function runInitModuleWithReadme(
 
 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;
 }

package/src/commands/init.ts

@@ -23,6 +23,10 @@ export function runInit(cwd: string): number {
   const symlink = setupSymlink(cwd);
   if (symlink === "linked") {
     console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
+  } else if (symlink === "copied") {
+    console.log(
+      chalk.yellow("  .claude/skills (copied — re-run `erp-kit update skills` after changes)"),
+    );
   } else if (symlink === "skipped_directory") {
     console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
   }

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

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { copySkills, copyWorkflows, copyConfigs, setupSymlink } from "./distribute";
 
 describe("copySkills", () => {
@@ -123,4 +123,35 @@ describe("setupSymlink", () => {
     const result = setupSymlink(tmpDir);
     expect(result).toBe("skipped_directory");
   });
+
+  it("falls back to copy when symlink creation fails", () => {
+    // Populate .agents/skills with a test file so copy has something to work with
+    const agentsSkills = path.join(tmpDir, ".agents", "skills", "test-skill");
+    fs.mkdirSync(agentsSkills, { recursive: true });
+    fs.writeFileSync(path.join(agentsSkills, "SKILL.md"), "# Test");
+
+    // Simulate Windows EPERM — symlink creation fails
+    vi.spyOn(fs, "symlinkSync").mockImplementation(() => {
+      const err = new Error("EPERM: operation not permitted") as NodeJS.ErrnoException;
+      err.code = "EPERM";
+      throw err;
+    });
+
+    try {
+      const result = setupSymlink(tmpDir);
+      expect(result).toBe("copied");
+
+      const claudeSkills = path.join(tmpDir, ".claude", "skills");
+      expect(fs.existsSync(claudeSkills)).toBe(true);
+      expect(fs.statSync(claudeSkills).isDirectory()).toBe(true);
+      // Not a symlink — it's a real directory copy
+      expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
+      // Content was copied
+      expect(fs.readFileSync(path.join(claudeSkills, "test-skill", "SKILL.md"), "utf-8")).toBe(
+        "# Test",
+      );
+    } finally {
+      vi.restoreAllMocks();
+    }
+  });
 });

package/src/commands/lib/distribute.ts

@@ -90,7 +90,20 @@ export function copyConfigs(cwd: string): CopyResult {
   return { copied, removed: 0 };
 }
 
-export type SymlinkResult = "linked" | "already_linked" | "skipped_directory";
+export type SymlinkResult = "linked" | "already_linked" | "skipped_directory" | "copied";
+
+function createSymlink(target: string, linkPath: string): void {
+  const type = process.platform === "win32" ? "junction" : undefined;
+  // Junctions on Windows require absolute targets
+  const resolvedTarget =
+    type === "junction" ? path.resolve(path.dirname(linkPath), target) : target;
+  fs.symlinkSync(resolvedTarget, linkPath, type);
+}
+
+function copySkillsDirectory(src: string, dest: string): void {
+  if (!fs.existsSync(src)) return;
+  fs.cpSync(src, dest, { recursive: true });
+}
 
 export function setupSymlink(cwd: string): SymlinkResult {
   const skillsDest = path.join(cwd, ".agents", "skills");
@@ -111,15 +124,44 @@ export function setupSymlink(cwd: string): SymlinkResult {
       const current = fs.readlinkSync(claudeSkills);
       if (current === relTarget) return "already_linked";
       fs.unlinkSync(claudeSkills);
-      fs.symlinkSync(relTarget, claudeSkills);
-      return "linked";
+      try {
+        createSymlink(relTarget, claudeSkills);
+        return "linked";
+      } catch {
+        copySkillsDirectory(skillsDest, claudeSkills);
+        return "copied";
+      }
     }
     return "skipped_directory";
   }
 
   fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
-  fs.symlinkSync(relTarget, claudeSkills);
-  return "linked";
+  try {
+    createSymlink(relTarget, claudeSkills);
+    return "linked";
+  } catch {
+    copySkillsDirectory(skillsDest, claudeSkills);
+    return "copied";
+  }
+}
+
+/**
+ * When .claude/skills is a real directory (copy fallback on Windows),
+ * re-sync it with .agents/skills after an update.
+ */
+export function refreshCopiedSkills(cwd: string): boolean {
+  const claudeSkills = path.join(cwd, ".claude", "skills");
+  try {
+    const stat = fs.lstatSync(claudeSkills);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  // It's a real directory — delete and re-copy from .agents/skills
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  fs.rmSync(claudeSkills, { recursive: true, force: true });
+  copySkillsDirectory(skillsDest, claudeSkills);
+  return true;
 }
 
 export function isAlreadyInitialized(cwd: string): boolean {

package/src/commands/lib/sync-check-source.test.ts

@@ -190,7 +190,7 @@ describe("runSourceSyncCheck", () => {
     fs.writeFileSync(path.join(resolverSrcDir, "myResolver.ts"), "export {}");
 
     const result = await runSourceSyncCheck({ modulesRoot: "modules", appRoot: undefined }, tmpDir);
-    // Without appRoot, app-compose patterns are not checked
+    // Without appRoot, app patterns are not checked
     expect(result.exitCode).toBe(0);
     expect(result.errors).toHaveLength(0);
   });

package/src/commands/update.test.ts

@@ -77,6 +77,22 @@ describe("runUpdate", () => {
     expect(content).toContain("@tailor-platform/erp-kit");
   });
 
+  it("refreshes .claude/skills when it is a copied directory (not a symlink)", () => {
+    // Simulate a prior "copied" fallback: .claude/skills is a real directory with stale content
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(path.join(claudeSkills, "erp-kit-old"), { recursive: true });
+    fs.writeFileSync(path.join(claudeSkills, "erp-kit-old", "SKILL.md"), "# Old");
+
+    runUpdate(tmpDir, ["skills"]);
+
+    // Stale skill should be gone from .claude/skills
+    expect(fs.existsSync(path.join(claudeSkills, "erp-kit-old"))).toBe(false);
+    // Current skills should be present
+    expect(
+      fs.existsSync(path.join(claudeSkills, "erp-kit-module-1-requirements", "SKILL.md")),
+    ).toBe(true);
+  });
+
   it("never touches config files", () => {
     const configPath = path.join(tmpDir, "license.config.json");
     fs.writeFileSync(configPath, '{"groups": ["notice"]}');

package/src/commands/update.ts

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { copySkills, copyWorkflows } from "./lib/distribute";
+import { copySkills, copyWorkflows, refreshCopiedSkills } from "./lib/distribute";
 
 export const VALID_RESOURCES = ["skills", "workflows"] as const;
 export type Resource = (typeof VALID_RESOURCES)[number];
@@ -27,6 +27,9 @@ export function runUpdate(cwd: string, resources: string[]): number {
       console.log(chalk.green(`  Removed ${result.removed} stale erp-kit-* skills`));
     }
     console.log(chalk.green(`  Copied ${result.copied} skill files to .agents/skills/`));
+    if (refreshCopiedSkills(cwd)) {
+      console.log(chalk.green(`  Refreshed .claude/skills/ (copy)`));
+    }
   }
 
   if (selected.has("workflows")) {

package/src/generator/generate-code-boilerplate.test.ts

@@ -24,7 +24,7 @@ describe("scaffoldModuleBoilerplate", () => {
       expect(fs.existsSync(path.join(moduleDir, dir))).toBe(true);
     }
 
-    for (const dir of ["db", "command", "executor", "generated", "query"]) {
+    for (const dir of ["db", "command", "executor", "query"]) {
       expect(fs.existsSync(path.join(moduleDir, dir, ".gitkeep"))).toBe(true);
     }
 
@@ -33,8 +33,12 @@ describe("scaffoldModuleBoilerplate", () => {
       "index.ts",
       "permissions.ts",
       "tailor.config.ts",
+      "package.json",
+      "eslint.config.js",
+      "tsconfig.json",
       "lib/types.ts",
       "testing/fixtures.ts",
+      "generated/kysely-tailordb.ts",
     ];
     for (const file of expectedFiles) {
       expect(fs.existsSync(path.join(moduleDir, file))).toBe(true);
@@ -46,6 +50,10 @@ describe("scaffoldModuleBoilerplate", () => {
     const config = fs.readFileSync(path.join(moduleDir, "tailor.config.ts"), "utf-8");
     expect(config).toContain('name: "test-module"');
 
+    const pkg = fs.readFileSync(path.join(moduleDir, "package.json"), "utf-8");
+    expect(pkg).toContain('"name": "test-module"');
+    expect(pkg).not.toContain("workspace:*");
+
     const moduleFile = fs.readFileSync(path.join(moduleDir, "module.ts"), "utf-8");
     expect(moduleFile).toContain("defineModule");
     expect(moduleFile).toContain("commands");