@tailor-platform/erp-kit 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @tailor-platform/erp-kit
 
+## 0.6.0
+
+### Minor Changes
+
+- 0cb94dc: - Add manufacturing module with BOM, work orders, and production tracking
+  - Add story test case sync-check and stub generation for `erp-kit test` command
+  - Update workspace creation instructions and deployment steps in skills
+
+### Patch Changes
+
+- 0cb94dc: - Fix relative shared imports to use package self-reference for consistent module resolution
+  - Fix priority calibration in requirements review skill to improve accuracy
+  - Fix severity validation in module-2 requirements review skill
+  - Update module-4-plan-review skill and regenerate .agents/skills
+
+## 0.5.1
+
+### Patch Changes
+
+- fb40e4d: - Fix mdschema binary resolution to use platform-specific native binaries, enabling Windows support
+  - Fix init commands to be idempotent when directory already exists instead of erroring
+  - Add package.json and dev tooling to module template
+  - Update app skill to use erp-kit app generate seed
+
 ## 0.5.0
 
 ### Minor Changes

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import { arg, defineCommand, runMain } from "politty";
 import { z } from "zod";
 import chalk from "chalk";
-import fs, { existsSync, readFileSync, readdirSync } from "node:fs";
+import fs, { existsSync, globSync, readFileSync, readdirSync } from "node:fs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import { execFile, execSync } from "node:child_process";
 import fg from "fast-glob";
@@ -364,12 +364,35 @@ function runLicenseCheck(configPath) {
 //#endregion
 //#region src/mdschema.ts
 const require = createRequire(import.meta.url);
+const PLATFORMS = {
+	darwin: {
+		arm64: "@jackchuka/mdschema-darwin-arm64",
+		x64: "@jackchuka/mdschema-darwin-x64"
+	},
+	linux: {
+		arm64: "@jackchuka/mdschema-linux-arm64",
+		x64: "@jackchuka/mdschema-linux-x64"
+	},
+	win32: {
+		arm64: "@jackchuka/mdschema-windows-arm64",
+		x64: "@jackchuka/mdschema-windows-x64"
+	}
+};
 function getMdschemaBin() {
 	const pkgPath = require.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;
+	const pkgDir = path.dirname(pkgPath);
+	const mdschemaRequire = createRequire(pkgPath);
+	const ext = process.platform === "win32" ? ".exe" : "";
+	const pkg = PLATFORMS[process.platform]?.[process.arch];
+	if (pkg) try {
+		return mdschemaRequire.resolve(`${pkg}/bin/mdschema${ext}`);
+	} catch {}
+	const localBin = path.join(pkgDir, "bin", `mdschema${ext}`);
+	if (fs.existsSync(localBin)) return localBin;
+	const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	const bin = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.mdschema;
 	if (!bin) throw new Error("Could not resolve mdschema binary from package.json bin field");
-	return path.join(path.dirname(pkgPath), bin);
+	return path.join(pkgDir, bin);
 }
 function runMdschema(args, cwd) {
 	return new Promise((resolve) => {
@@ -429,11 +452,12 @@ const MODULE_PATHS = {
 	}
 };
 const APP_PATHS = {
-	storySegment: "story",
+	tests: { stories: "backend/src/tests/stories" },
 	docs: {
 		resolver: "docs/resolver",
 		actors: "docs/actors",
 		businessFlow: "docs/business-flow",
+		story: "story",
 		screen: "docs/screen"
 	}
 };
@@ -469,7 +493,14 @@ function appComposeCategories(root) {
 		exclusions: [/\.test\.ts$/, /^index\.ts$/]
 	}];
 }
-function testCaseCategories(root) {
+function appTestCaseCategories(root) {
+	return {
+		name: "story-test-case",
+		docPattern: `${root}/*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
+		testDir: APP_PATHS.tests.stories
+	};
+}
+function moduleTestCaseCategories(root) {
 	return [{
 		name: "command-test-case",
 		docPattern: `${root}/*/${MODULE_PATHS.docs.commands}/*.md`,
@@ -513,7 +544,7 @@ function buildCheckTargets(config) {
 			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/README.md`,
 			schemaKey: "business-flow"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.storySegment}/*.md`,
+			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
 			schemaKey: "story"
 		}, {
 			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.screen}/*.md`,
@@ -552,10 +583,6 @@ async function runCheck(config, cwd) {
 //#region src/commands/init-module.ts
 function runInitModule(name, dir) {
 	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;
 }
@@ -578,10 +605,6 @@ async function runInitModuleWithReadme(name, dir, cwd) {
 }
 function runInitApp(name, dir) {
 	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;
 }
@@ -727,9 +750,9 @@ function parseItDescriptionsFromTest(content) {
 function toCamelCase(pascalCase) {
 	return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
 }
-async function runTestCaseSyncCheck(root, cwd) {
+async function runModuleTestCaseSyncCheck(root, cwd) {
 	const errors = [];
-	const categories = testCaseCategories(root);
+	const categories = moduleTestCaseCategories(root);
 	for (const category of categories) {
 		const docPaths = await fg(category.docPattern, { cwd });
 		for (const docPath of docPaths) {
@@ -765,15 +788,57 @@ async function runTestCaseSyncCheck(root, cwd) {
 	}
 	return errors;
 }
+function resolveStoryTestPath(docPath, testDir) {
+	const match = /^(.+)\/docs\/business-flow\/([^/]+)\/story\/([^/]+)\.md$/.exec(docPath);
+	if (!match) return null;
+	const [, appPath, flow, name] = match;
+	return `${appPath}/${testDir}/${flow}/${name}.test.ts`;
+}
+async function runAppTestCaseSyncCheck(appRoot, cwd) {
+	const errors = [];
+	const config = appTestCaseCategories(appRoot);
+	const docPaths = await fg(config.docPattern, { cwd });
+	for (const docPath of docPaths) {
+		const docFullPath = path.join(cwd, docPath);
+		const docTestCases = parseTestCasesFromDoc(fs.readFileSync(docFullPath, "utf-8"));
+		if (docTestCases.length === 0) continue;
+		const testPath = resolveStoryTestPath(docPath, config.testDir);
+		if (!testPath) continue;
+		const testFullPath = path.join(cwd, testPath);
+		if (!fs.existsSync(testFullPath)) continue;
+		const itDescriptions = parseItDescriptionsFromTest(fs.readFileSync(testFullPath, "utf-8"));
+		const docSet = new Set(docTestCases);
+		const testSet = new Set(itDescriptions);
+		for (const docCase of docSet) if (!testSet.has(docCase)) errors.push({
+			type: "missing-test-case",
+			category: config.name,
+			docPath,
+			sourcePath: testPath,
+			expectedBasename: docCase
+		});
+		for (const testCase of testSet) if (!docSet.has(testCase)) errors.push({
+			type: "extra-test-case",
+			category: config.name,
+			docPath,
+			sourcePath: testPath,
+			expectedBasename: testCase
+		});
+	}
+	return errors;
+}
 //#endregion
 //#region src/commands/sync-check.ts
 async function runSyncCheck(config, cwd) {
 	const sourceResult = await runSourceSyncCheck(config, cwd);
 	if (config.modulesRoot) {
-		const testCaseErrors = await runTestCaseSyncCheck(config.modulesRoot, cwd);
+		const testCaseErrors = await runModuleTestCaseSyncCheck(config.modulesRoot, cwd);
 		sourceResult.errors.push(...testCaseErrors);
-		sourceResult.exitCode = sourceResult.errors.length > 0 ? 1 : 0;
 	}
+	if (config.appRoot) {
+		const storyErrors = await runAppTestCaseSyncCheck(config.appRoot, cwd);
+		sourceResult.errors.push(...storyErrors);
+	}
+	sourceResult.exitCode = sourceResult.errors.length > 0 ? 1 : 0;
 	return sourceResult;
 }
 function formatSyncCheckReport(result) {
@@ -1077,10 +1142,22 @@ describe("${name}", () => {
     expect(resolver.default.name).toBe("${name}");
   });
 });
+`;
+	} },
+	storyTest: { render: (name, testCases) => {
+		return `import { describe, expect, inject, it } from "vitest";
+import { createGraphQLClient } from "@/tests/utils/graphql-client";
+
+describe("${name}", () => {
+  const graphQLClient = createGraphQLClient(inject("url"), inject("token"));
+
+${testCases.map((tc) => `  it("${tc}", async () => {\n    // TODO: implement\n  });`).join("\n\n")}
+});
 `;
 	} }
 };
-function renderStub(type, name) {
+function renderStub(type, name, testCases) {
+	if (type === "storyTest") return templates.storyTest.render(name, testCases);
 	return templates[type].render(name);
 }
 //#endregion
@@ -1106,6 +1183,9 @@ function generateResolverStub(resolverName) {
 function generateResolverTestStub(resolverName) {
 	return renderStub("resolverTest", resolverName);
 }
+function generateStoryTestStub(name, testCases) {
+	return renderStub("storyTest", name, testCases);
+}
 //#endregion
 //#region src/generator/scaffold.ts
 function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
@@ -1129,7 +1209,16 @@ function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
 	}
 }
 function scaffoldModuleBoilerplate(moduleDir, moduleName) {
-	copyTemplateDir(path.join(PACKAGE_ROOT, "templates", "scaffold", "module"), moduleDir, { "template-module": moduleName }, new Set(["permissions.ts", "tailor.config.ts"]));
+	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "module");
+	const erpKitVersion = readErpKitVersion();
+	copyTemplateDir(templateDir, moduleDir, {
+		"template-module": moduleName,
+		"\"workspace:*\"": `"${erpKitVersion}"`
+	}, new Set([
+		"package.json",
+		"permissions.ts",
+		"tailor.config.ts"
+	]));
 }
 function scaffoldAppBoilerplate(appDir, appName) {
 	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "app");
@@ -1290,7 +1379,7 @@ function resolveDocPath(type, name, modulePath) {
 	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 path.join(modulePath, APP_PATHS.docs.businessFlow, parts[0], APP_PATHS.storySegment, `${parts[1]}.md`);
+		return path.join(modulePath, APP_PATHS.docs.businessFlow, parts[0], APP_PATHS.docs.story, `${parts[1]}.md`);
 	}
 	if (MODULE_DIR_MAP[type]) return path.join(modulePath, MODULE_DIR_MAP[type], `${name}.md`);
 	if (APP_DIR_MAP[type]) return path.join(modulePath, APP_DIR_MAP[type], `${name}.md`);
@@ -1516,19 +1605,16 @@ function parseExceptionHandlingFromRaw(markdown) {
 function runGenerateAppCode(appPath) {
 	const appName = path.basename(appPath);
 	scaffoldAppBoilerplate(appPath, appName);
+	generateResolverStubs(appPath, appName);
+	generateStoryTestStubs(appPath, appName);
+	return 0;
+}
+function generateResolverStubs(appPath, appName) {
 	const docsDir = path.join(appPath, "docs", "resolver");
-	const resolverDir = path.join(appPath, "backend", "src", "resolvers");
-	if (!fs.existsSync(docsDir)) {
-		console.log(`No docs/resolver/ directory found — skipping resolver generation`);
-		console.log(`Generated boilerplate for ${appName}`);
-		return 0;
-	}
+	if (!fs.existsSync(docsDir)) return;
 	const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
-	if (mdFiles.length === 0) {
-		console.log(`No resolver docs found — skipping resolver generation`);
-		console.log(`Generated boilerplate for ${appName}`);
-		return 0;
-	}
+	if (mdFiles.length === 0) return;
+	const resolverDir = path.join(appPath, "backend", "src", "resolvers");
 	fs.mkdirSync(resolverDir, { recursive: true });
 	let generated = 0;
 	for (const file of mdFiles) {
@@ -1546,8 +1632,26 @@ function runGenerateAppCode(appPath) {
 			console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
 		}
 	}
-	console.log(`Scaffolded ${generated} resolver(s) for ${appName}`);
-	return 0;
+	if (generated > 0) console.log(`Scaffolded ${generated} resolver(s) for ${appName}`);
+}
+function generateStoryTestStubs(appPath, appName) {
+	const storyDocs = globSync(path.join(appPath, "docs/business-flow/*/story/*.md"));
+	let generated = 0;
+	for (const storyDocPath of storyDocs) {
+		const testCases = parseTestCasesFromDoc(fs.readFileSync(storyDocPath, "utf-8"));
+		if (testCases.length === 0) continue;
+		const match = /\/docs\/business-flow\/([^/]+)\/story\/([^/]+)\.md$/.exec(storyDocPath);
+		if (!match) continue;
+		const [, flow, storyName] = match;
+		const testDir = path.join(appPath, APP_PATHS.tests.stories, flow);
+		const testFile = path.join(testDir, `${storyName}.test.ts`);
+		if (fs.existsSync(testFile)) continue;
+		fs.mkdirSync(testDir, { recursive: true });
+		fs.writeFileSync(testFile, generateStoryTestStub(storyName, testCases));
+		console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
+		generated++;
+	}
+	if (generated > 0) console.log(`Scaffolded ${generated} story test(s) for ${appName}`);
 }
 //#endregion
 //#region src/shared/uuidv5.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/erp-kit",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Opinionated ERP toolkit for building business applications on Tailor Platform",
   "license": "MIT",
   "bin": {

package/skills/erp-kit-app-5-impl-backend/SKILL.md

@@ -90,7 +90,10 @@ For each resolver, check whether its spec (`docs/resolver/*.md`) documents error
 
 Do not directly mutate module-owned tables via Kysely — always use module commands.
 
+After resolvers are done, implement the story integration test stubs generated in Phase 1b (`backend/src/tests/stories/`). Each stub has `it()` descriptions from the story doc's `## Test Cases`. Use the scaffolded GraphQL client and `inject("url")` / `inject("token")` to call resolvers. Run `pnpm test:integration` and `pnpm erp-kit app sync-check` to verify.
+
 > **Parallelize if possible:** Dispatch one agent per resolver. Each agent writes only to its own files:
+>
 > - `src/resolvers/<resolverName>.ts`
 > - `src/executors/<resolverName>.ts`
 >
@@ -99,16 +102,18 @@ Do not directly mutate module-owned tables via Kysely — always use module comm
 ### Phase 5: Generated Files
 
 - **Kysely types** (`src/generated/kysely-tailordb.ts`) — Auto-generated by `pnpm generate` after deployment. Before deployment, create a minimal placeholder so the codebase typechecks.
-- **Seed data** (`seed/`) — `exec.mjs` runner + `data/*.jsonl` (records) and `data/*.schema.ts` (validation). Create seed records for initial data (permissions, roles, test users, etc.). Seeded users must have concrete permission keys required by the wired modules.
+- **Seed data** (`seed/`) — `exec.mjs` runner + `data/*.jsonl` (records) and `data/*.schema.ts` (validation).
+  1. **Module seed** — Run `pnpm erp-kit app generate seed -p <app-path>` to generate module-provided defaults (currencies, units, UoM categories, exchange rates). This writes JSONL files to `seed/data/`, skipping files that already exist.
+  2. **App-specific seed** — Manually create seed records for permissions, roles, test users, and domain-specific data. Seeded users must have concrete permission keys required by the wired modules.
 
 ### Phase 6: Deploy Backend & Next Steps
 
 Frontend implementation requires a deployed backend (for GraphQL schema generation). Prompt the user to:
 
-1. Create a workspace and configure `.env` (including `TAILOR_PLATFORM_WORKSPACE_ID`)
-2. Run `pnpm deploy` and `pnpm generate`
-3. Run `pnpm seed` if seed data was created
-4. Retrieve OAuth2 client ID via `tailor-sdk oauth2client get default --json` for frontend `.env`
+1. Create a workspace via `tailor-sdk workspace create --name <NAME> --region <us-west|asia-northeast>` and configure `.env` (including `TAILOR_PLATFORM_WORKSPACE_ID`)
+2. Run `pnpm run deploy` and `pnpm run generate`
+3. Run `pnpm run seed` if seed data was created
+4. Retrieve OAuth2 client ID via `tailor-sdk oauth2client get default --json --env-file-if-exists .env` for frontend `.env`
 
 Wait for the user to confirm deployment is complete before proceeding.
 

package/skills/erp-kit-app-7-impl-review/SKILL.md

@@ -63,7 +63,7 @@ cd <APP_ROOT>/frontend && pnpm lint && pnpm typecheck && pnpm build
 erp-kit app sync-check -p <APP_ROOT>/..
 ```
 
-Report pass/fail for each check. `sync-check` detects missing resolver implementations and orphaned docs, so groups A-C agents can skip file-existence checks and focus on content parity.
+Report pass/fail for each check. `sync-check` detects missing resolver implementations, orphaned docs, and story doc ↔ integration test case mismatches, so groups A-C agents can skip file-existence checks and focus on content parity.
 
 ## Step 3: Aggregate Results
 

package/skills/erp-kit-module-6-impl-review/SKILL.md

@@ -31,35 +31,57 @@ Define shared context for all agents:
 
 Verify at least `MODEL_DOCS`, `COMMAND_DOCS`, or `QUERY_DOCS` is non-empty. If no docs exist, stop with: "No docs found for module <MODULE_NAME>."
 
-## Step 2: Dispatch Agents (parallelize if possible)
+## Step 2: Dispatch Agents (parallelize ALL agents in a single message)
 
-Launch 3 Agent tool calls in parallel — one per domain (model, command, query).
-Each agent receives: MODULE_NAME, all relevant doc/code/test file paths for its domain.
-Each agent runs all parity perspectives (doc→code, error, doc→test) internally and returns: structured JSON per [references/impl-parity-report-format.md](references/impl-parity-report-format.md).
-If a doc or code directory is empty, the agent reports "no files found" and skips.
+Split each parity check into its own agent, then further split by file batches when there are many files. Target **~5 agents per domain** (model, command, query) for maximum parallelism. Launch **ALL agents in a single message** — do NOT wait for one domain to finish before starting another.
 
-| Agent | Domain  | Prompt Templates                                                                                                                                                                                                                                                                   | Inputs                                                              |
-| ----- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
-| 1     | Model   | [references/model-doc-code-parity.md](references/model-doc-code-parity.md)                                                                                                                                                                                                         | MODEL_DOCS, MODEL_CODE                                              |
-| 2     | Command | [references/command-doc-code-parity.md](references/command-doc-code-parity.md), [references/command-error-implementation-parity.md](references/command-error-implementation-parity.md), [references/command-doc-test-parity.md](references/command-doc-test-parity.md)               | COMMAND_DOCS, COMMAND_CODE, COMMAND_TEST_CODE, ERROR_DEFS           |
-| 3     | Query   | [references/query-doc-code-parity.md](references/query-doc-code-parity.md), [references/query-error-implementation-parity.md](references/query-error-implementation-parity.md), [references/query-doc-test-parity.md](references/query-doc-test-parity.md)                         | QUERY_DOCS, QUERY_CODE, QUERY_TEST_CODE, ERROR_DEFS                |
+If a doc or code directory is empty, skip that agent entirely.
+
+### Splitting Strategy
+
+1. **Each parity check type = separate agent** (never combine different check types in one agent)
+2. **File batching**: If a check has more than 5 doc files, split docs into batches of 3-5 files each. Each batch becomes its own agent running the same check type on a subset of files.
+3. **Corresponding code/test files**: When batching by doc files, include only the matching code and test files for those specific docs (match by filename stem, e.g., `docs/commands/createFoo.md` → `command/createFoo.ts` + `command/createFoo.test.ts`).
+
+### Agent Table
+
+| Check Type | Domain  | Prompt Template                                                                                            | Inputs per agent                                                     |
+| ---------- | ------- | ---------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| M-1        | Model   | [references/model-doc-code-parity.md](references/model-doc-code-parity.md)                                 | MODEL_DOCS (batch), MODEL_CODE (matching)                            |
+| C-1        | Command | [references/command-doc-code-parity.md](references/command-doc-code-parity.md)                              | COMMAND_DOCS (batch), COMMAND_CODE (matching)                        |
+| C-2        | Command | [references/command-error-implementation-parity.md](references/command-error-implementation-parity.md)      | COMMAND_DOCS (batch), COMMAND_CODE (matching), ERROR_DEFS            |
+| C-3        | Command | [references/command-doc-test-parity.md](references/command-doc-test-parity.md)                              | COMMAND_DOCS (batch), COMMAND_TEST_CODE (matching)                   |
+| Q-1        | Query   | [references/query-doc-code-parity.md](references/query-doc-code-parity.md)                                 | QUERY_DOCS (batch), QUERY_CODE (matching)                            |
+| Q-2        | Query   | [references/query-error-implementation-parity.md](references/query-error-implementation-parity.md)          | QUERY_DOCS (batch), QUERY_CODE (matching), ERROR_DEFS               |
+| Q-3        | Query   | [references/query-doc-test-parity.md](references/query-doc-test-parity.md)                                 | QUERY_DOCS (batch), QUERY_TEST_CODE (matching)                      |
+
+### Batching Example
+
+If a module has 8 command docs: split into 3 batches (3+3+2). Each batch spawns 3 agents (C-1, C-2, C-3) → 9 command agents total. If it has 4 command docs: no batching needed, 3 agents (C-1, C-2, C-3).
+
+For model docs: if 6 models → 2 batches (3+3) → 2 agents (M-1 × 2). If 3 models → 1 agent.
+
+### Agent Dispatch
 
 For each agent:
 
-1. Read ALL prompt template files listed for that agent
+1. Read the prompt template file for that check type
 2. Replace `{{MODULE_NAME}}` with the resolved module name
-3. Replace `{{MODEL_DOCS}}`, `{{COMMAND_DOCS}}`, `{{QUERY_DOCS}}`, `{{MODEL_CODE}}`, `{{COMMAND_CODE}}`, `{{QUERY_CODE}}`, `{{COMMAND_TEST_CODE}}`, `{{QUERY_TEST_CODE}}`, `{{ERROR_DEFS}}` with the actual file paths
-4. Combine the templates into a single prompt and dispatch the agent
+3. Replace template placeholders (`{{MODEL_DOCS}}`, `{{COMMAND_DOCS}}`, `{{QUERY_DOCS}}`, `{{MODEL_CODE}}`, `{{COMMAND_CODE}}`, `{{QUERY_CODE}}`, `{{COMMAND_TEST_CODE}}`, `{{QUERY_TEST_CODE}}`, `{{ERROR_DEFS}}`) with the actual file paths **for this batch only**
+4. Dispatch the agent with the filled prompt
+
+**IMPORTANT**: Launch ALL agents across ALL domains in a single parallel message. Do not serialize by domain.
 
 ## Step 3: Aggregate Results
 
 After ALL agents return:
 
 1. Collect the JSON results from each agent
-2. Merge all `gaps[]` arrays into a single list
-3. Merge all `inconsistencies[]` arrays into a single list
-4. Deduplicate: if two gaps share the same `source + target + check`, keep only one
-5. Calculate totals across all summaries
+2. **Merge batches**: If a check type was split across multiple batches (e.g., C-1 batch 1 + C-1 batch 2), merge their `gaps[]` and `inconsistencies[]` into a single result per check type
+3. Merge all `gaps[]` arrays across all check types into a single list
+4. Merge all `inconsistencies[]` arrays into a single list
+5. Deduplicate: if two gaps share the same `source + target + check`, keep only one
+6. Calculate totals across all summaries
 
 ## Step 4: Severity Validation
 

package/src/commands/generate-doc.ts

@@ -48,7 +48,7 @@ export function resolveDocPath(
       modulePath,
       APP_PATHS.docs.businessFlow,
       parts[0],
-      APP_PATHS.storySegment,
+      APP_PATHS.docs.story,
       `${parts[1]}.md`,
     );
   }

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/lib/discovery.test.ts

@@ -2,7 +2,8 @@ import { describe, it, expect } from "vitest";
 import {
   moduleCategories,
   appComposeCategories,
-  testCaseCategories,
+  moduleTestCaseCategories,
+  appTestCaseCategories,
   buildCheckTargets,
 } from "./discovery";
 
@@ -35,15 +36,24 @@ describe("appComposeCategories", () => {
   });
 });
 
-describe("testCaseCategories", () => {
+describe("moduleTestCaseCategories", () => {
   it("produces command and query test case categories", () => {
-    const cats = testCaseCategories("modules");
+    const cats = moduleTestCaseCategories("modules");
     expect(cats).toHaveLength(2);
     expect(cats[0].testDir).toBe("command");
     expect(cats[1].testDir).toBe("query");
   });
 });
 
+describe("appTestCaseCategories", () => {
+  it("produces story test case category with correct pattern", () => {
+    const cats = appTestCaseCategories("apps");
+    expect(cats.name).toBe("story-test-case");
+    expect(cats.docPattern).toBe("apps/*/docs/business-flow/*/story/*.md");
+    expect(cats.testDir).toBe("backend/src/tests/stories");
+  });
+});
+
 describe("buildCheckTargets", () => {
   it("builds module check targets", () => {
     const targets = buildCheckTargets({ modulesRoot: "modules" });

package/src/commands/lib/discovery.ts

@@ -52,7 +52,15 @@ export function appComposeCategories(root: string): CategoryConfig[] {
   ];
 }
 
-export function testCaseCategories(root: string): TestCaseCategoryConfig[] {
+export function appTestCaseCategories(root: string): TestCaseCategoryConfig {
+  return {
+    name: "story-test-case",
+    docPattern: `${root}/*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
+    testDir: APP_PATHS.tests.stories,
+  };
+}
+
+export function moduleTestCaseCategories(root: string): TestCaseCategoryConfig[] {
   return [
     {
       name: "command-test-case",
@@ -94,7 +102,7 @@ export function buildCheckTargets(config: {
         schemaKey: "business-flow",
       },
       {
-        glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.storySegment}/*.md`,
+        glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
         schemaKey: "story",
       },
       { glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.screen}/*.md`, schemaKey: "screen" },

package/src/commands/lib/paths.ts

@@ -11,12 +11,14 @@ export const MODULE_PATHS = {
 } as const;
 
 export const APP_PATHS = {
-  // Subdirectory name within docs/business-flow/<flow>/story/
-  storySegment: "story",
+  tests: {
+    stories: "backend/src/tests/stories",
+  },
   docs: {
     resolver: "docs/resolver",
     actors: "docs/actors",
     businessFlow: "docs/business-flow",
+    story: "story",
     screen: "docs/screen",
   },
 } as const;