@tailor-platform/erp-kit 0.5.1 → 0.7.0

package/dist/cli.mjs

@@ -3,9 +3,9 @@ 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 { 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";
@@ -452,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"
 	}
 };
@@ -487,12 +488,19 @@ 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$/]
 	}];
 }
-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`,
@@ -527,22 +535,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.storySegment}/*.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"
 		});
 	}
@@ -622,6 +630,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,
@@ -742,9 +756,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) {
@@ -758,7 +772,16 @@ async function runTestCaseSyncCheck(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);
@@ -780,15 +803,66 @@ 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)) {
+			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);
+		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) {
@@ -817,6 +891,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("");
 			}
@@ -1082,46 +1159,23 @@ export default createResolver({
 });
 `;
 	} },
-	resolverTest: { render: (name) => {
-		return `import { describe, expect, it } from "vitest";
+	storyTest: { render: (name, testCases) => {
+		return `import { describe, expect, inject, it } from "vitest";
+import { createGraphQLClient } from "@/tests/utils/graphql-client";
 
 describe("${name}", () => {
-  it("should be implemented", async () => {
-    const resolver = await import("./${name}");
-    expect(resolver.default).toBeDefined();
-    expect(resolver.default.name).toBe("${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
-//#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);
-}
-//#endregion
 //#region src/generator/scaffold.ts
 function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
 	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
@@ -1226,12 +1280,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)}`);
 		}
 	}
@@ -1249,12 +1303,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)}`);
 				}
 			}
@@ -1271,7 +1325,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)}`);
 				}
 			}
@@ -1314,7 +1368,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`);
@@ -1351,7 +1405,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"
@@ -1375,7 +1429,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);
 				});
 			}
@@ -1386,7 +1440,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);
@@ -1398,7 +1452,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"
@@ -1409,7 +1463,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);
 		});
 	}
@@ -1420,7 +1474,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);
 		});
@@ -1441,7 +1495,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);
 		});
 	}
@@ -1540,19 +1594,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) {
@@ -1560,18 +1611,31 @@ function runGenerateAppCode(appPath) {
 		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)}`);
-		}
 	}
-	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, renderStub("storyTest", 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
@@ -1958,6 +2022,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();
@@ -2063,7 +2480,8 @@ const appCommand = defineCommand({
 		check: checkCommand,
 		"sync-check": syncCheckCommand,
 		init: initCommand$1,
-		generate: generateCommand
+		generate: generateCommand,
+		progress: progressCommand
 	}
 });
 //#endregion