@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { z } from "zod";
 import chalk from "chalk";
 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 { execFile, execFileSync, execSync } from "node:child_process";
 import fg from "fast-glob";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toString } from "mdast-util-to-string";
@@ -31,10 +31,70 @@ function readErpKitVersion() {
 	return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8")).version;
 }
 //#endregion
+//#region src/generator/scaffold.ts
+const RENAME_MAP = {
+	__dot__gitignore: ".gitignore",
+	"__pnpm-workspace.yaml": "pnpm-workspace.yaml"
+};
+function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles, excludeDirs = /* @__PURE__ */ new Set()) {
+	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+		const srcPath = path.join(srcDir, entry.name);
+		const destName = RENAME_MAP[entry.name] ?? entry.name;
+		const destPath = path.join(destDir, destName);
+		if (entry.name === "node_modules") continue;
+		if (excludeDirs.has(entry.name)) continue;
+		if (entry.isDirectory()) {
+			fs.mkdirSync(destPath, { recursive: true });
+			copyTemplateDir(srcPath, destPath, replacements, placeholderFiles, excludeDirs);
+		} else {
+			if (fs.existsSync(destPath)) continue;
+			fs.mkdirSync(path.dirname(destPath), { recursive: true });
+			if (placeholderFiles.has(entry.name)) {
+				let content = fs.readFileSync(srcPath, "utf-8");
+				for (const [from, to] of Object.entries(replacements)) content = content.replaceAll(from, to);
+				fs.writeFileSync(destPath, content);
+			} else fs.copyFileSync(srcPath, destPath);
+		}
+	}
+}
+function scaffoldModuleBoilerplate(moduleDir, moduleName) {
+	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");
+	const erpKitVersion = readErpKitVersion();
+	copyTemplateDir(templateDir, appDir, {
+		"template-app-frontend": `${appName}-frontend`,
+		"template-app-backend": appName,
+		"template-app": appName,
+		"\"workspace:*\"": `"${erpKitVersion}"`
+	}, new Set([
+		"package.json",
+		"tailor.config.ts",
+		"index.html"
+	]), new Set(["docs"]));
+}
+function scaffoldProjectBoilerplate(projectDir, projectName) {
+	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "project");
+	const erpKitVersion = readErpKitVersion();
+	copyTemplateDir(templateDir, projectDir, {
+		"template-project": projectName,
+		"\"workspace:*\"": `"${erpKitVersion}"`
+	}, new Set(["package.json"]));
+}
+//#endregion
 //#region src/commands/lib/distribute.ts
 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");
 function copyDirectoryRecursive(srcDir, destDir) {
 	let copied = 0;
 	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
@@ -95,22 +155,6 @@ function copyWorkflows(cwd) {
 		removed: 0
 	};
 }
-function copyConfigs(cwd) {
-	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
-	};
-}
 function createSymlink(target, linkPath) {
 	const type = process.platform === "win32" ? "junction" : void 0;
 	const resolvedTarget = type === "junction" ? path.resolve(path.dirname(linkPath), target) : target;
@@ -179,7 +223,7 @@ function isAlreadyInitialized(cwd) {
 }
 //#endregion
 //#region src/commands/init.ts
-function runInit(cwd) {
+function runInit(name, cwd) {
 	console.log(chalk.bold("erp-kit init\n"));
 	if (isAlreadyInitialized(cwd)) {
 		console.log(chalk.yellow("Already initialized. Use `erp-kit update` to refresh framework resources."));
@@ -193,8 +237,8 @@ function runInit(cwd) {
 	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)`));
+	scaffoldProjectBoilerplate(cwd, name);
+	console.log(chalk.green("  Scaffolded project structure"));
 	console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
 	return 0;
 }
@@ -488,8 +532,8 @@ function moduleCategories(root) {
 function appComposeCategories(root) {
 	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$/]
 	}];
 }
@@ -535,22 +579,22 @@ function buildCheckTargets(config) {
 	if (config.appRoot) {
 		const a = config.appRoot;
 		targets.push({
-			glob: `${a}/[a-zA-Z]*/README.md`,
+			glob: `${a}/README.md`,
 			schemaKey: "app"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.actors}/*.md`,
+			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`,
+			glob: `${a}/${APP_PATHS.docs.screen}/*.md`,
 			schemaKey: "screen"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.resolver}/*.md`,
+			glob: `${a}/${APP_PATHS.docs.resolver}/*.md`,
 			schemaKey: "resolver"
 		});
 	}
@@ -630,6 +674,12 @@ async function runInitAppWithReadme(name, dir, cwd) {
 function success() {
 	return { exitCode: 0 };
 }
+function failure(message, exitCode = 1) {
+	return {
+		exitCode,
+		message
+	};
+}
 function silentFailure(exitCode = 1) {
 	return {
 		exitCode,
@@ -766,7 +816,16 @@ async function runModuleTestCaseSyncCheck(root, cwd) {
 			const testFileName = `${toCamelCase(docBasename)}.test.ts`;
 			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 itDescriptions = parseItDescriptionsFromTest(fs.readFileSync(testFullPath, "utf-8"));
 			const docSet = new Set(docTestCases);
 			const testSet = new Set(itDescriptions);
@@ -805,7 +864,16 @@ async function runAppTestCaseSyncCheck(appRoot, cwd) {
 		const testPath = resolveStoryTestPath(docPath, config.testDir);
 		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 itDescriptions = parseItDescriptionsFromTest(fs.readFileSync(testFullPath, "utf-8"));
 		const docSet = new Set(docTestCases);
 		const testSet = new Set(itDescriptions);
@@ -867,6 +935,9 @@ function formatSyncCheckReport(result) {
 				} else if (error.type === "extra-test-case") {
 					lines.push(`  ${chalk.red(error.sourcePath)}`);
 					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("");
 			}
@@ -1130,18 +1201,6 @@ export default createResolver({
     })
     .description("${toPascal(name)} response"),
 });
-`;
-	} },
-	resolverTest: { render: (name) => {
-		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}");
-  });
-});
 `;
 	} },
 	storyTest: { render: (name, testCases) => {
@@ -1161,80 +1220,6 @@ function renderStub(type, name, testCases) {
 	return templates[type].render(name);
 }
 //#endregion
-//#region src/generator/generate-stubs.ts
-function generateCommandStub(doc) {
-	return renderStub("command", doc.commandName);
-}
-function generateTestStub(doc) {
-	return renderStub("commandTest", doc.commandName);
-}
-function generateQueryStub(doc) {
-	return renderStub("query", doc.commandName);
-}
-function generateQueryTestStub(doc) {
-	return renderStub("queryTest", doc.commandName);
-}
-function generateDbStub(modelName) {
-	return renderStub("db", modelName);
-}
-function generateResolverStub(resolverName) {
-	return renderStub("resolver", 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) {
-	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-		const srcPath = path.join(srcDir, entry.name);
-		const destName = entry.name === "__dot__gitignore" ? ".gitignore" : entry.name;
-		const destPath = path.join(destDir, destName);
-		if (entry.name === "node_modules") continue;
-		if (entry.isDirectory()) {
-			fs.mkdirSync(destPath, { recursive: true });
-			copyTemplateDir(srcPath, destPath, replacements, placeholderFiles);
-		} else {
-			if (fs.existsSync(destPath)) continue;
-			fs.mkdirSync(path.dirname(destPath), { recursive: true });
-			if (placeholderFiles.has(entry.name)) {
-				let content = fs.readFileSync(srcPath, "utf-8");
-				for (const [from, to] of Object.entries(replacements)) content = content.replaceAll(from, to);
-				fs.writeFileSync(destPath, content);
-			} else fs.copyFileSync(srcPath, destPath);
-		}
-	}
-}
-function scaffoldModuleBoilerplate(moduleDir, moduleName) {
-	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");
-	const erpKitVersion = readErpKitVersion();
-	copyTemplateDir(templateDir, appDir, {
-		"template-app-frontend": `${appName}-frontend`,
-		"template-app-backend": appName,
-		"template-app": appName,
-		"\"workspace:*\"": `"${erpKitVersion}"`
-	}, new Set([
-		"package.json",
-		"tailor.config.ts",
-		"index.html"
-	]));
-}
-//#endregion
 //#region src/generator/generate-code.ts
 function runGenerateCode(modulePath, moduleName) {
 	scaffoldModuleBoilerplate(modulePath, moduleName);
@@ -1291,12 +1276,12 @@ function runGenerateCode(modulePath, moduleName) {
 		console.log(`  wrote ${path.relative(modulePath, shellFile)}`);
 		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)}`);
 		}
 	}
@@ -1314,12 +1299,12 @@ function runGenerateCode(modulePath, moduleName) {
 				generated++;
 				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)}`);
 				}
 			}
@@ -1336,7 +1321,7 @@ function runGenerateCode(modulePath, moduleName) {
 				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)}`);
 				}
 			}
@@ -1416,7 +1401,7 @@ async function runGenerateDoc(type, name, modulePath, cwd) {
 }
 //#endregion
 //#region src/commands/module/generate.ts
-const cwd$3 = process.cwd();
+const cwd$4 = process.cwd();
 const pathArgs$2 = z.object({ path: arg(z.string(), {
 	alias: "p",
 	description: "Path to the module directory"
@@ -1440,7 +1425,7 @@ const generateCommand$1 = defineCommand({
 			}),
 			run: (args) => {
 				return executeCommand(async () => {
-					const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$3);
+					const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$4);
 					return exitCode === 0 ? success() : silentFailure(exitCode);
 				});
 			}
@@ -1451,7 +1436,7 @@ const generateCommand$1 = defineCommand({
 			args: pathArgs$2,
 			run: (args) => {
 				return executeCommand(() => {
-					const modulePath = path.resolve(cwd$3, args.path);
+					const modulePath = path.resolve(cwd$4, args.path);
 					const moduleName = path.basename(modulePath);
 					console.log(`Generating code for ${moduleName}...`);
 					const exitCode = runGenerateCode(modulePath, moduleName);
@@ -1463,7 +1448,7 @@ const generateCommand$1 = defineCommand({
 });
 //#endregion
 //#region src/commands/module/index.ts
-const cwd$2 = process.cwd();
+const cwd$3 = process.cwd();
 const pathArgs$1 = z.object({ path: arg(z.string(), {
 	alias: "p",
 	description: "Path to modules directory"
@@ -1474,7 +1459,7 @@ const checkCommand$1 = defineCommand({
 	args: pathArgs$1,
 	run: (args) => {
 		return executeCommand(async () => {
-			const exitCode = await runCheck({ modulesRoot: args.path }, cwd$2);
+			const exitCode = await runCheck({ modulesRoot: args.path }, cwd$3);
 			return exitCode === 0 ? success() : silentFailure(exitCode);
 		});
 	}
@@ -1485,7 +1470,7 @@ const syncCheckCommand$1 = defineCommand({
 	args: pathArgs$1,
 	run: (args) => {
 		return executeCommand(async () => {
-			const result = await runSyncCheck({ modulesRoot: args.path }, cwd$2);
+			const result = await runSyncCheck({ modulesRoot: args.path }, cwd$3);
 			console.log(formatSyncCheckReport(result));
 			return result.exitCode === 0 ? success() : silentFailure(result.exitCode);
 		});
@@ -1506,7 +1491,7 @@ const initCommand$2 = defineCommand({
 	}),
 	run: (args) => {
 		return executeCommand(async () => {
-			const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd$2);
+			const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd$3);
 			return exitCode === 0 ? success() : silentFailure(exitCode);
 		});
 	}
@@ -1622,15 +1607,10 @@ function generateResolverStubs(appPath, appName) {
 		const doc = parseResolverDoc(path.basename(file, ".md"), content);
 		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) console.log(`Scaffolded ${generated} resolver(s) for ${appName}`);
 }
@@ -1647,7 +1627,7 @@ function generateStoryTestStubs(appPath, appName) {
 		const testFile = path.join(testDir, `${storyName}.test.ts`);
 		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++;
 	}
@@ -2038,6 +2018,359 @@ function runGenerateSeed(appPath) {
 	console.log(`Generated ${written} file(s), skipped ${skipped} existing`);
 	return 0;
 }
+z.enum([
+	"step.start",
+	"step.complete",
+	"decision",
+	"agent.dispatch",
+	"agent.result",
+	"artifact.create",
+	"validation",
+	"error",
+	"note"
+]);
+const StepStatus = z.enum([
+	"pass",
+	"fail",
+	"blocked"
+]);
+const ArtifactType = z.enum([
+	"doc",
+	"code",
+	"config",
+	"report",
+	"seed",
+	"asset"
+]);
+const ArtifactOperation = z.enum([
+	"create",
+	"update",
+	"delete"
+]);
+const ConversationMessage = z.object({
+	role: z.enum(["user", "agent"]),
+	message: z.string()
+});
+const GitContext = z.object({
+	branch: z.string(),
+	commit: z.string()
+});
+const StepStartData = z.object({
+	skill: z.string(),
+	context: z.record(z.string(), z.unknown())
+});
+const StepCompleteData = z.object({
+	status: StepStatus,
+	summary: z.string(),
+	artifacts: z.array(z.string())
+});
+const DecisionData = z.object({
+	question: z.string(),
+	choice: z.string(),
+	alternatives: z.array(z.string()),
+	rationale: z.string()
+});
+const AgentDispatchData = z.object({
+	agentName: z.string(),
+	task: z.string(),
+	inputs: z.record(z.string(), z.unknown())
+});
+const AgentResultData = z.object({
+	agentName: z.string(),
+	status: z.enum(["pass", "fail"]),
+	outputs: z.record(z.string(), z.unknown()),
+	duration_ms: z.number()
+});
+const ArtifactCreateData = z.object({
+	path: z.string(),
+	type: ArtifactType,
+	operation: ArtifactOperation
+});
+const ValidationData = z.object({
+	command: z.string(),
+	status: z.enum(["pass", "fail"]),
+	issues: z.array(z.string())
+});
+const ErrorData = z.object({
+	message: z.string(),
+	recoverable: z.boolean()
+});
+const NoteData = z.object({
+	message: z.string(),
+	tags: z.array(z.string())
+});
+const convField = () => z.array(ConversationMessage).default([]);
+const StepStartEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("step.start"),
+	data: StepStartData
+});
+const StepCompleteEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("step.complete"),
+	data: StepCompleteData
+});
+const DecisionEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("decision"),
+	data: DecisionData
+});
+const AgentDispatchEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("agent.dispatch"),
+	data: AgentDispatchData
+});
+const AgentResultEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("agent.result"),
+	data: AgentResultData
+});
+const ArtifactCreateEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("artifact.create"),
+	data: ArtifactCreateData
+});
+const ValidationEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("validation"),
+	data: ValidationData
+});
+const ErrorEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("error"),
+	data: ErrorData
+});
+const NoteEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("note"),
+	data: NoteData
+});
+const ProgressEntry = z.union([
+	StepStartEntry,
+	StepCompleteEntry,
+	DecisionEntry,
+	AgentDispatchEntry,
+	AgentResultEntry,
+	ArtifactCreateEntry,
+	ValidationEntry,
+	ErrorEntry,
+	NoteEntry
+]);
+const StepStartInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("step.start"),
+	data: StepStartData
+});
+const StepCompleteInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("step.complete"),
+	data: StepCompleteData
+});
+const DecisionInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("decision"),
+	data: DecisionData
+});
+const AgentDispatchInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("agent.dispatch"),
+	data: AgentDispatchData
+});
+const AgentResultInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("agent.result"),
+	data: AgentResultData
+});
+const ArtifactCreateInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("artifact.create"),
+	data: ArtifactCreateData
+});
+const ValidationInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("validation"),
+	data: ValidationData
+});
+const ErrorInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("error"),
+	data: ErrorData
+});
+const NoteInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("note"),
+	data: NoteData
+});
+const ProgressInput = z.union([
+	StepStartInput,
+	StepCompleteInput,
+	DecisionInput,
+	AgentDispatchInput,
+	AgentResultInput,
+	ArtifactCreateInput,
+	ValidationInput,
+	ErrorInput,
+	NoteInput
+]);
+//#endregion
+//#region src/commands/app/progress/git-context.ts
+function getGitContext(cwd) {
+	return {
+		branch: execFileSync("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			cwd,
+			encoding: "utf-8"
+		}).trim(),
+		commit: execFileSync("git", [
+			"rev-parse",
+			"--short",
+			"HEAD"
+		], {
+			cwd,
+			encoding: "utf-8"
+		}).trim()
+	};
+}
+//#endregion
+//#region src/commands/app/progress/log.ts
+function runProgressLog(jsonInput, dryRun, cwd) {
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonInput);
+	} catch {
+		return failure("Invalid JSON input");
+	}
+	const inputResult = ProgressInput.safeParse(parsed);
+	if (!inputResult.success) return failure(`Invalid progress input: ${inputResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+	const enriched = {
+		...inputResult.data,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		git: getGitContext(cwd)
+	};
+	const entryResult = ProgressEntry.safeParse(enriched);
+	if (!entryResult.success) return failure(`Invalid progress entry after enrichment: ${entryResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+	const line = JSON.stringify(entryResult.data);
+	console.log(line);
+	if (dryRun) return success();
+	const erpKitDir = path.join(cwd, ".erp-kit");
+	fs.mkdirSync(erpKitDir, { recursive: true });
+	fs.appendFileSync(path.join(erpKitDir, "progress.jsonl"), line + "\n", "utf-8");
+	return success();
+}
+//#endregion
+//#region src/commands/app/progress/schema-cmd.ts
+function runProgressSchema() {
+	const jsonSchema = z.toJSONSchema(ProgressInput);
+	console.log(JSON.stringify(jsonSchema, null, 2));
+	return success();
+}
+//#endregion
+//#region src/commands/app/progress/index.ts
+const cwd$2 = process.cwd();
+const progressCommand = defineCommand({
+	name: "progress",
+	description: "Audit log for app skill sessions",
+	subCommands: {
+		log: defineCommand({
+			name: "log",
+			description: "Append a validated entry to the progress log",
+			args: z.object({
+				json: arg(z.string(), { description: "JSON payload (ProgressInput schema)" }),
+				"dry-run": arg(z.boolean().default(false), { description: "Validate without writing" })
+			}),
+			run: (args) => {
+				return executeCommand(() => {
+					return runProgressLog(args.json, args["dry-run"], cwd$2);
+				});
+			}
+		}),
+		schema: defineCommand({
+			name: "schema",
+			description: "Output JSON Schema for progress log input",
+			args: z.object({}),
+			run: () => {
+				return executeCommand(() => {
+					return runProgressSchema();
+				});
+			}
+		})
+	}
+});
 //#endregion
 //#region src/commands/app/index.ts
 const cwd$1 = process.cwd();
@@ -2143,7 +2476,8 @@ const appCommand = defineCommand({
 		check: checkCommand,
 		"sync-check": syncCheckCommand,
 		init: initCommand$1,
-		generate: generateCommand
+		generate: generateCommand,
+		progress: progressCommand
 	}
 });
 //#endregion
@@ -2747,9 +3081,13 @@ runMain(defineCommand({
 		init: defineCommand({
 			name: "init",
 			description: "First-time setup for a consumer repo",
-			run: () => {
+			args: z.object({ name: arg(z.string(), {
+				positional: true,
+				description: "Project name"
+			}) }),
+			run: (args) => {
 				return executeCommand(() => {
-					const exitCode = runInit(cwd);
+					const exitCode = runInit(args.name, cwd);
 					return exitCode === 0 ? success() : silentFailure(exitCode);
 				});
 			}