@tailor-platform/erp-kit 0.6.0 → 0.7.0

package/src/commands/app/progress/progress.test.ts

@@ -0,0 +1,128 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { runProgressLog } from "./log";
+import { runProgressSchema } from "./schema-cmd";
+
+function makeTmpApp(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "progress-test-"));
+  execFileSync("git", ["init"], { cwd: dir });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "test"], { cwd: dir });
+  execFileSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
+  return dir;
+}
+
+describe("runProgressLog", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("creates .erp-kit/progress.jsonl and appends a valid entry", () => {
+    tmpDir = makeTmpApp();
+    const input = JSON.stringify({
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note",
+      data: { message: "test", tags: [] },
+    });
+
+    const result = runProgressLog(input, false, tmpDir);
+    expect(result.exitCode).toBe(0);
+
+    const logFile = path.join(tmpDir, ".erp-kit", "progress.jsonl");
+    expect(fs.existsSync(logFile)).toBe(true);
+
+    const lines = fs.readFileSync(logFile, "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const entry = JSON.parse(lines[0]) as Record<string, unknown>;
+    expect(entry.sessionId).toBe("s1");
+    expect(entry.timestamp).toBeDefined();
+    expect(entry.git).toBeDefined();
+    expect(entry.conversation).toEqual([]);
+  });
+
+  it("appends multiple entries", () => {
+    tmpDir = makeTmpApp();
+    const input1 = JSON.stringify({
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note",
+      data: { message: "first", tags: [] },
+    });
+    const input2 = JSON.stringify({
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note",
+      data: { message: "second", tags: [] },
+    });
+
+    runProgressLog(input1, false, tmpDir);
+    runProgressLog(input2, false, tmpDir);
+
+    const logFile = path.join(tmpDir, ".erp-kit", "progress.jsonl");
+    const lines = fs.readFileSync(logFile, "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(2);
+  });
+
+  it("rejects invalid JSON", () => {
+    tmpDir = makeTmpApp();
+    const result = runProgressLog("not json", false, tmpDir);
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("rejects invalid schema (missing prompt)", () => {
+    tmpDir = makeTmpApp();
+    const input = JSON.stringify({
+      v: 1,
+      sessionId: "s1",
+      event: "note",
+      data: { message: "x", tags: [] },
+    });
+    const result = runProgressLog(input, false, tmpDir);
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("dry-run does not write to file", () => {
+    tmpDir = makeTmpApp();
+    const input = JSON.stringify({
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note",
+      data: { message: "test", tags: [] },
+    });
+
+    const result = runProgressLog(input, true, tmpDir);
+    expect(result.exitCode).toBe(0);
+
+    const logFile = path.join(tmpDir, ".erp-kit", "progress.jsonl");
+    expect(fs.existsSync(logFile)).toBe(false);
+  });
+});
+
+describe("runProgressSchema", () => {
+  it("outputs valid JSON Schema", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+
+    const result = runProgressSchema();
+
+    expect(result.exitCode).toBe(0);
+    expect(spy).toHaveBeenCalledOnce();
+
+    const schema = JSON.parse(String(spy.mock.calls[0]?.[0])) as Record<string, unknown>;
+    expect(schema).toHaveProperty("anyOf");
+
+    spy.mockRestore();
+  });
+});

package/src/commands/app/progress/schema-cmd.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { ProgressInput } from "../../../progress/schema";
+import type { CommandResult } from "../../lib/command-result";
+import { success } from "../../lib/command-result";
+
+export function runProgressSchema(): CommandResult {
+  const jsonSchema = z.toJSONSchema(ProgressInput);
+  console.log(JSON.stringify(jsonSchema, null, 2));
+  return success();
+}

package/src/commands/check.test.ts

@@ -13,14 +13,14 @@ describe("buildCheckTargets", () => {
     ]);
   });
 
-  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");
+  it("generates app-compose targets when appRoot is set", () => {
+    const targets = buildCheckTargets({ modulesRoot: undefined, appRoot: "apps/myapp" });
+    expect(targets[0].glob).toBe("apps/myapp/README.md");
     expect(targets).toHaveLength(6);
   });
 
   it("generates both when both roots are set", () => {
-    const targets = buildCheckTargets({ modulesRoot: "modules", appRoot: "examples" });
+    const targets = buildCheckTargets({ modulesRoot: "modules", appRoot: "examples/app1" });
     expect(targets).toHaveLength(11);
   });
 

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

@@ -29,10 +29,10 @@ describe("moduleCategories", () => {
 
 describe("appComposeCategories", () => {
   it("produces resolver category", () => {
-    const cats = appComposeCategories("apps");
+    const cats = appComposeCategories("apps/myapp");
     expect(cats).toHaveLength(1);
     expect(cats[0].name).toBe("resolver");
-    expect(cats[0].docPattern).toBe("apps/*/docs/resolver/*.md");
+    expect(cats[0].docPattern).toBe("apps/myapp/docs/resolver/*.md");
   });
 });
 
@@ -69,16 +69,14 @@ describe("buildCheckTargets", () => {
   });
 
   it("builds app check targets", () => {
-    const targets = buildCheckTargets({ appRoot: "apps" });
+    const targets = buildCheckTargets({ appRoot: "apps/myapp" });
     expect(targets).toHaveLength(6);
     expect(targets.map((t) => t.schemaKey)).toContain("screen");
-    expect(targets.find((t) => t.schemaKey === "screen")!.glob).toBe(
-      "apps/[a-zA-Z]*/docs/screen/*.md",
-    );
+    expect(targets.find((t) => t.schemaKey === "screen")!.glob).toBe("apps/myapp/docs/screen/*.md");
   });
 
   it("builds both when both roots provided", () => {
-    const targets = buildCheckTargets({ modulesRoot: "modules", appRoot: "apps" });
+    const targets = buildCheckTargets({ modulesRoot: "modules", appRoot: "apps/myapp" });
     expect(targets).toHaveLength(11);
   });
 });

package/src/commands/lib/discovery.ts

@@ -45,8 +45,8 @@ export function appComposeCategories(root: string): CategoryConfig[] {
   return [
     {
       name: "resolver",
-      sourcePattern: `${root}/*/backend/src/resolvers/*.ts`,
-      docPattern: `${root}/*/${APP_PATHS.docs.resolver}/*.md`,
+      sourcePattern: `${root}/backend/src/resolvers/*.ts`,
+      docPattern: `${root}/${APP_PATHS.docs.resolver}/*.md`,
       exclusions: [/\.test\.ts$/, /^index\.ts$/],
     },
   ];
@@ -95,18 +95,18 @@ export function buildCheckTargets(config: {
   if (config.appRoot) {
     const a = config.appRoot;
     targets.push(
-      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "app" },
-      { glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.actors}/*.md`, schemaKey: "actors" },
+      { glob: `${a}/README.md`, schemaKey: "app" },
+      { glob: `${a}/${APP_PATHS.docs.actors}/*.md`, schemaKey: "actors" },
       {
-        glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/README.md`,
+        glob: `${a}/${APP_PATHS.docs.businessFlow}/*/README.md`,
         schemaKey: "business-flow",
       },
       {
-        glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
+        glob: `${a}/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
         schemaKey: "story",
       },
-      { glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.screen}/*.md`, schemaKey: "screen" },
-      { glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.resolver}/*.md`, schemaKey: "resolver" },
+      { glob: `${a}/${APP_PATHS.docs.screen}/*.md`, schemaKey: "screen" },
+      { glob: `${a}/${APP_PATHS.docs.resolver}/*.md`, schemaKey: "resolver" },
     );
   }
 

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

@@ -104,7 +104,7 @@ describe("runSourceSyncCheck", () => {
     fs.writeFileSync(path.join(srcDir, "myResolver.ts"), "export {}");
     fs.writeFileSync(path.join(docDir, "myResolver.md"), "# MyResolver");
 
-    const result = await runSourceSyncCheck({ appRoot: "apps" }, tmpDir);
+    const result = await runSourceSyncCheck({ appRoot: "apps/app1" }, tmpDir);
     expect(result.exitCode).toBe(0);
     expect(result.summary.totalSources).toBe(1);
   });

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

@@ -3,7 +3,12 @@ import fg from "fast-glob";
 import { moduleCategories, appComposeCategories, type CategoryConfig } from "./discovery";
 
 export interface CheckError {
-  type: "missing-doc" | "orphaned-doc" | "missing-test-case" | "extra-test-case";
+  type:
+    | "missing-doc"
+    | "orphaned-doc"
+    | "missing-test-case"
+    | "extra-test-case"
+    | "missing-test-file";
   category: string;
   sourcePath?: string;
   docPath?: string;

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

@@ -153,6 +153,29 @@ describe("runModuleTestCaseSyncCheck", () => {
     expect(tcErrors).toHaveLength(0);
   });
 
+  it("reports missing-test-file when test file does not exist", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    const testDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docDir, "CreateOrder.md"),
+      "# CreateOrder\n\n## Test Cases\n\n- creates order\n- validates input\n",
+    );
+    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
+    // No createOrder.test.ts file
+
+    const errors = await runModuleTestCaseSyncCheck("modules", tmpDir);
+    expect(errors).toContainEqual(
+      expect.objectContaining({
+        type: "missing-test-file",
+        category: "command-test-case",
+        expectedBasename: "createOrder.test.ts",
+      }),
+    );
+  });
+
   it("skips test-case check when doc has no Test Cases section", async () => {
     const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
     const testDir = path.join(tmpDir, "modules", "foo", "command");
@@ -243,6 +266,26 @@ describe("runAppTestCaseSyncCheck", () => {
     expect(errors).toHaveLength(0);
   });
 
+  it("reports missing-test-file when story test file does not exist", async () => {
+    const flow = "item-lifecycle";
+    const storyDir = path.join(tmpDir, "apps", "my-app", "docs", "business-flow", flow, "story");
+    fs.mkdirSync(storyDir, { recursive: true });
+    // No test file created
+    fs.writeFileSync(
+      path.join(storyDir, "admin--create-item.md"),
+      "# Create Item\n\n## Test Cases\n\n- creates item\n- validates input\n",
+    );
+
+    const errors = await runAppTestCaseSyncCheck("apps", tmpDir);
+    expect(errors).toContainEqual(
+      expect.objectContaining({
+        type: "missing-test-file",
+        category: "story-test-case",
+        expectedBasename: "admin--create-item.test.ts",
+      }),
+    );
+  });
+
   it("skips when story doc has no Test Cases section", async () => {
     setupStoryFixture(
       "admin--view-items",

package/src/commands/lib/sync-check-tests.ts

@@ -31,7 +31,16 @@ export async function runModuleTestCaseSyncCheck(root: string, cwd: string): Pro
       const testPath = path.join(modulePath, category.testDir, testFileName);
       const testFullPath = path.join(cwd, testPath);
 
-      if (!fs.existsSync(testFullPath)) continue;
+      if (!fs.existsSync(testFullPath)) {
+        errors.push({
+          type: "missing-test-file",
+          category: category.name,
+          docPath,
+          sourcePath: testPath,
+          expectedBasename: testFileName,
+        });
+        continue;
+      }
 
       const testContent = fs.readFileSync(testFullPath, "utf-8");
       const itDescriptions = parseItDescriptionsFromTest(testContent);
@@ -92,7 +101,16 @@ export async function runAppTestCaseSyncCheck(appRoot: string, cwd: string): Pro
     if (!testPath) continue;
 
     const testFullPath = path.join(cwd, testPath);
-    if (!fs.existsSync(testFullPath)) continue;
+    if (!fs.existsSync(testFullPath)) {
+      errors.push({
+        type: "missing-test-file",
+        category: config.name,
+        docPath,
+        sourcePath: testPath,
+        expectedBasename: path.basename(testPath),
+      });
+      continue;
+    }
 
     const testContent = fs.readFileSync(testFullPath, "utf-8");
     const itDescriptions = parseItDescriptionsFromTest(testContent);

package/src/commands/sync-check.ts

@@ -54,6 +54,9 @@ export function formatSyncCheckReport(result: SyncCheckResult): string {
           lines.push(
             `    ${chalk.yellow("Extra test case:")} "${error.expectedBasename}" is in test but not in doc`,
           );
+        } else if (error.type === "missing-test-file") {
+          lines.push(`  ${chalk.red(error.docPath)}`);
+          lines.push(`    ${chalk.yellow("Missing test file:")} ${error.expectedBasename}`);
         }
         lines.push("");
       }

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

@@ -62,9 +62,7 @@ Gets profile.
 
     const files = fs.readdirSync(resolverDir).sort();
     // Template scaffolding may copy additional files (e.g. createUser.ts)
-    expect(files).toContain("createItem.test.ts");
     expect(files).toContain("createItem.ts");
-    expect(files).toContain("getMyProfile.test.ts");
     expect(files).toContain("getMyProfile.ts");
     expect(files).not.toContain("createItem.generated.ts");
 
@@ -73,10 +71,6 @@ Gets profile.
     expect(stub).toContain("createResolver");
     expect(stub).toContain('name: "createItem"');
     expect(stub).toContain('getDB("main-db")');
-
-    // Test stub exists
-    const test = fs.readFileSync(path.join(resolverDir, "createItem.test.ts"), "utf-8");
-    expect(test).toContain('describe("createItem"');
   });
 
   it("does not overwrite existing stubs on re-run", () => {

package/src/generator/generate-app-code.ts

@@ -3,11 +3,7 @@ import path from "node:path";
 import { parseTestCasesFromDoc } from "../commands/parse-doc-test-cases";
 import { APP_PATHS } from "../commands/lib/paths";
 import { parseResolverDoc } from "./parse-resolver-doc";
-import {
-  generateResolverStub,
-  generateResolverTestStub,
-  generateStoryTestStub,
-} from "./generate-stubs";
+import { renderStub } from "./stub-templates";
 import { scaffoldAppBoilerplate } from "./scaffold";
 
 export function runGenerateAppCode(appPath: string): number {
@@ -38,16 +34,10 @@ function generateResolverStubs(appPath: string, appName: string): void {
 
     const implFile = path.join(resolverDir, `${doc.resolverName}.ts`);
     if (!fs.existsSync(implFile)) {
-      fs.writeFileSync(implFile, generateResolverStub(doc.resolverName));
+      fs.writeFileSync(implFile, renderStub("resolver", doc.resolverName));
       console.log(`  scaffolded ${path.relative(appPath, implFile)}`);
       generated++;
     }
-
-    const testFile = path.join(resolverDir, `${doc.resolverName}.test.ts`);
-    if (!fs.existsSync(testFile)) {
-      fs.writeFileSync(testFile, generateResolverTestStub(doc.resolverName));
-      console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
-    }
   }
 
   if (generated > 0) {
@@ -75,7 +65,7 @@ function generateStoryTestStubs(appPath: string, appName: string): void {
     if (fs.existsSync(testFile)) continue;
 
     fs.mkdirSync(testDir, { recursive: true });
-    fs.writeFileSync(testFile, generateStoryTestStub(storyName, testCases));
+    fs.writeFileSync(testFile, renderStub("storyTest", storyName, testCases));
     console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
     generated++;
   }

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

@@ -2,13 +2,7 @@ import { describe, expect, it } from "vitest";
 import { moduleNameToPrefix, generateErrors } from "./generate-errors";
 import { generatePermissions } from "./generate-permissions";
 import { generateCommandShell, generateQueryShell } from "./generate-shells";
-import {
-  generateQueryStub,
-  generateQueryTestStub,
-  generateDbStub,
-  generateResolverStub,
-  generateResolverTestStub,
-} from "./generate-stubs";
+import { renderStub } from "./stub-templates";
 import type { ParsedCommandDoc } from "./parse-command-doc";
 
 describe("moduleNameToPrefix", () => {
@@ -174,15 +168,9 @@ describe("generateQueryShell", () => {
   });
 });
 
-describe("generateQueryStub", () => {
+describe("renderStub query", () => {
   it("generates a stub implementation with ReadonlyDB and input interface", () => {
-    const doc: ParsedCommandDoc = {
-      commandName: "getTaxonomyNode",
-      errors: [],
-      externalDependencies: [],
-    };
-
-    const result = generateQueryStub(doc);
+    const result = renderStub("query", "getTaxonomyNode");
 
     expect(result).toContain('import type { ReadonlyDB } from "@tailor-platform/erp-kit/module";');
     expect(result).toContain('import type { DB } from "../generated/kysely-tailordb";');
@@ -194,9 +182,9 @@ describe("generateQueryStub", () => {
   });
 });
 
-describe("generateDbStub", () => {
+describe("renderStub db", () => {
   it("generates an empty db type definition with TODO", () => {
-    const result = generateDbStub("item");
+    const result = renderStub("db", "item");
 
     expect(result).toContain(
       "import { db, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission }",
@@ -210,22 +198,16 @@ describe("generateDbStub", () => {
   });
 
   it("handles camelCase model names", () => {
-    const result = generateDbStub("taxonomyNode");
+    const result = renderStub("db", "taxonomyNode");
 
     expect(result).toContain("export const taxonomyNode = db");
     expect(result).toContain('.type("TaxonomyNode"');
   });
 });
 
-describe("generateQueryTestStub", () => {
+describe("renderStub queryTest", () => {
   it("generates a test stub with createMockDb and run import", () => {
-    const doc: ParsedCommandDoc = {
-      commandName: "getTaxonomyNode",
-      errors: [],
-      externalDependencies: [],
-    };
-
-    const result = generateQueryTestStub(doc);
+    const result = renderStub("queryTest", "getTaxonomyNode");
 
     expect(result).toContain('import { describe, expect, it } from "vitest";');
     expect(result).toContain('import { createMockDb } from "../../../testing/index";');
@@ -238,9 +220,9 @@ describe("generateQueryTestStub", () => {
   });
 });
 
-describe("generateResolverStub", () => {
+describe("renderStub resolver", () => {
   it("generates a createResolver stub with SDK imports and transaction boilerplate", () => {
-    const result = generateResolverStub("createItem");
+    const result = renderStub("resolver", "createItem");
 
     expect(result).toContain('import { createResolver, t } from "@tailor-platform/sdk";');
     expect(result).toContain('import { createContext } from "@tailor-platform/erp-kit/app";');
@@ -252,15 +234,3 @@ describe("generateResolverStub", () => {
     expect(result).toContain('.description("CreateItem response")');
   });
 });
-
-describe("generateResolverTestStub", () => {
-  it("generates a test that imports and verifies the resolver", () => {
-    const result = generateResolverTestStub("createItem");
-
-    expect(result).toContain('import { describe, expect, it } from "vitest";');
-    expect(result).toContain('describe("createItem"');
-    expect(result).toContain('import("./createItem")');
-    expect(result).toContain("expect(resolver.default).toBeDefined()");
-    expect(result).toContain('expect(resolver.default.name).toBe("createItem")');
-  });
-});

package/src/generator/generate-code.ts

@@ -4,13 +4,7 @@ import { parseCommandDoc, type ParsedCommandDoc } from "./parse-command-doc";
 import { generateErrors } from "./generate-errors";
 import { generatePermissions } from "./generate-permissions";
 import { generateCommandShell, generateQueryShell } from "./generate-shells";
-import {
-  generateCommandStub,
-  generateTestStub,
-  generateQueryStub,
-  generateQueryTestStub,
-  generateDbStub,
-} from "./generate-stubs";
+import { renderStub } from "./stub-templates";
 import { scaffoldModuleBoilerplate } from "./scaffold";
 
 export function runGenerateCode(modulePath: string, moduleName: string): number {
@@ -81,13 +75,13 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
     generated++;
 
     if (!fs.existsSync(implFile)) {
-      fs.writeFileSync(implFile, generateCommandStub(doc));
+      fs.writeFileSync(implFile, renderStub("command", doc.commandName));
       console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
     }
 
     const testFile = path.join(commandDir, `${doc.commandName}.test.ts`);
     if (!fs.existsSync(testFile)) {
-      fs.writeFileSync(testFile, generateTestStub(doc));
+      fs.writeFileSync(testFile, renderStub("commandTest", doc.commandName));
       console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
     }
   }
@@ -111,13 +105,13 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
 
         const implFile = path.join(queryDir, `${doc.commandName}.ts`);
         if (!fs.existsSync(implFile)) {
-          fs.writeFileSync(implFile, generateQueryStub(doc));
+          fs.writeFileSync(implFile, renderStub("query", doc.commandName));
           console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
         }
 
         const testFile = path.join(queryDir, `${doc.commandName}.test.ts`);
         if (!fs.existsSync(testFile)) {
-          fs.writeFileSync(testFile, generateQueryTestStub(doc));
+          fs.writeFileSync(testFile, renderStub("queryTest", doc.commandName));
           console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
         }
       }
@@ -137,7 +131,7 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
         const camelName = modelName.charAt(0).toLowerCase() + modelName.slice(1);
         const dbFile = path.join(dbDir, `${camelName}.ts`);
         if (!fs.existsSync(dbFile)) {
-          fs.writeFileSync(dbFile, generateDbStub(camelName));
+          fs.writeFileSync(dbFile, renderStub("db", camelName));
           console.log(`  scaffolded ${path.relative(modulePath, dbFile)}`);
         }
       }

package/src/generator/stub-templates.test.ts

@@ -46,13 +46,6 @@ describe("renderStub", () => {
     expect(result).toContain('getDB("main-db")');
   });
 
-  it("resolverTest: generates test that imports resolver", () => {
-    const result = renderStub("resolverTest", "createItem");
-    expect(result).toContain('describe("createItem"');
-    expect(result).toContain('import("./createItem")');
-    expect(result).toContain("resolver.default");
-  });
-
   it("storyTest: generates integration test with graphql client and test cases", () => {
     const result = renderStub("storyTest", "admin--create-item", [
       "creates item successfully",

package/src/generator/stub-templates.ts

@@ -119,20 +119,6 @@ export default createResolver({
     })
     .description("${toPascal(name)} response"),
 });
-`;
-    },
-  },
-  resolverTest: {
-    render: (name: string) => {
-      return `import { describe, expect, it } from "vitest";
-
-describe("${name}", () => {
-  it("should be implemented", async () => {
-    const resolver = await import("./${name}");
-    expect(resolver.default).toBeDefined();
-    expect(resolver.default.name).toBe("${name}");
-  });
-});
 `;
     },
   },

package/src/modules/finance-ledger/README.md

@@ -0,0 +1,50 @@
+# README
+
+<!-- This section should contain the following subsections in order: -->
+<!-- 1. ## Overview (required) -->
+<!-- 2. ## Key Features (required) -->
+<!-- 3. ## Module Scope (required) -->
+<!-- 4. ## Module Dependencies (required) -->
+
+## Overview
+
+## Key Features
+
+<!-- List requirements: -->
+<!-- Minimum 1 unordered lists required -->
+<!-- Minimum 1 items per list -->
+
+- TODO: Add list item
+
+## Module Scope
+
+<!-- This section should contain the following subsections in order: -->
+<!-- 1. ### In Scope (required) -->
+<!-- 2. ### Out of Scope (required) -->
+<!-- 3. ### Scope Decision Rationale (required) -->
+
+### In Scope
+
+<!-- List requirements: -->
+<!-- Minimum 1 unordered lists required -->
+<!-- Minimum 1 items per list -->
+
+- TODO: Add list item
+
+### Out of Scope
+
+<!-- List requirements: -->
+<!-- Minimum 1 unordered lists required -->
+<!-- Minimum 1 items per list -->
+
+- TODO: Add list item
+
+### Scope Decision Rationale
+
+<!-- Explain why capabilities are in-scope or out-of-scope — domain alignment, separation of concerns, etc. -->
+
+## Module Dependencies
+
+<!-- List requirements: -->
+<!-- Minimum 1 items per list -->
+