@tailor-platform/erp-kit 0.6.0 → 0.8.0

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/scaffold.ts

@@ -2,24 +2,33 @@ import fs from "node:fs";
 import path from "node:path";
 import { PACKAGE_ROOT, readErpKitVersion } from "../util";
 
+// Files that need renaming because they cause issues in the repo/pack.
 // npm renames .gitignore during pack (npm/cli#5756).
-// prepack copies .gitignore to __dot__gitignore to preserve it.
+// pnpm-workspace.yaml causes the template dir to be treated as a workspace member.
+// prepack copies these to their safe names; scaffold time restores the originals.
+const RENAME_MAP: Record<string, string> = {
+  __dot__gitignore: ".gitignore",
+  "__pnpm-workspace.yaml": "pnpm-workspace.yaml",
+};
+
 export function copyTemplateDir(
   srcDir: string,
   destDir: string,
   replacements: Record<string, string>,
   placeholderFiles: Set<string>,
+  excludeDirs = new Set<string>(),
 ): void {
   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 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);
+      copyTemplateDir(srcPath, destPath, replacements, placeholderFiles, excludeDirs);
     } else {
       if (fs.existsSync(destPath)) continue;
       fs.mkdirSync(path.dirname(destPath), { recursive: true });
@@ -57,5 +66,17 @@ export function scaffoldAppBoilerplate(appDir: string, appName: string): void {
     '"workspace:*"': `"${erpKitVersion}"`,
   };
   const placeholderFiles = new Set(["package.json", "tailor.config.ts", "index.html"]);
-  copyTemplateDir(templateDir, appDir, replacements, placeholderFiles);
+  // docs are authored by skills (app-1 through app-4), not scaffolded.
+  copyTemplateDir(templateDir, appDir, replacements, placeholderFiles, new Set(["docs"]));
+}
+
+export function scaffoldProjectBoilerplate(projectDir: string, projectName: string): void {
+  const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "project");
+  const erpKitVersion = readErpKitVersion();
+  const replacements = {
+    "template-project": projectName,
+    '"workspace:*"': `"${erpKitVersion}"`,
+  };
+  const placeholderFiles = new Set(["package.json"]);
+  copyTemplateDir(templateDir, projectDir, replacements, placeholderFiles);
 }

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/module.ts

@@ -44,7 +44,10 @@ export {
   all as itemManagementAll,
 } from "./modules/item-management/lib/permissions.generated";
 // audit
-export { defineModule as defineAuditModule } from "./modules/audit/module";
+export {
+  defineModule as defineAuditModule,
+  companyStub as auditCompanyStub,
+} from "./modules/audit/module";
 export {
   permissions as auditPermissions,
   own as auditOwn,

package/src/modules/accounting/README.md

@@ -0,0 +1,63 @@
+# README
+
+## Overview
+
+The accounting module provides management (internal) accounting capabilities for budgeting, cost allocation, profit center reporting, and variance analysis. It enables organizations to track, allocate, and analyze costs for internal decision-making, complementing the financial accounting capabilities provided by `finance-ledger` and `coa-management`.
+
+This module owns cost centers, profit centers, cost elements, budgets, internal orders, and allocation cycles — entities that exist solely for management accounting purposes and are distinct from the general ledger structure.
+
+## Key Features
+
+- **Cost Center Management** — Create and maintain cost centers with hierarchical grouping for overhead cost accumulation and reporting
+- **Cost Element Management** — Define primary cost elements (mapped to GL accounts) and secondary cost elements (internal allocation only)
+- **Profit Center Management** — Create and maintain profit centers with hierarchical grouping for internal P&L reporting
+- **Budget Management** — Create budgets with line items per cost element, manage approval workflows, track budget versions, and enforce budgetary control with commitment-aware availability checks
+- **Cost Allocation** — Execute allocation cycles (assessment/distribution) to distribute overhead costs from sender to receiver cost objects
+- **Internal Order Management** — Track costs for specific short-to-medium-term activities (projects, campaigns, events) with lifecycle management
+- **Variance Analysis** — Compare planned vs. actual costs by cost object and period, categorize variances, and generate management reports
+
+## Module Scope
+
+### In Scope
+
+- Cost center CRUD and hierarchy management
+- Profit center CRUD and hierarchy management
+- Primary and secondary cost element definition
+- Budget creation, approval workflow, and line item entry per cost element
+- Budgetary control with commitment-aware availability checks (Budget - Actual - Commitments - Encumbrances)
+- Commitment tracking via purchase module event consumption (PO confirmed, received, invoiced, cancelled)
+- Budget vs. actual comparison
+- Cost allocation cycles (assessment and distribution methods)
+- Allocation rule definition and execution
+- Internal order lifecycle (created → released → technically completed → closed)
+- Variance calculation and categorization (plan vs. actual) with cost-element-level detail lines
+- Multi-version planning (budget, forecast)
+- Audit trail for budget changes, allocation runs, and variance postings
+
+### Out of Scope
+
+- Financial (external) accounting — owned by `finance-ledger`
+- Chart of accounts and GL account management — owned by `coa-management`
+- Fiscal year and accounting period management — owned by `finance-ledger`
+- Activity-based costing (activity types, rate calculation) — future extension
+- Statistical key figures as allocation drivers — future extension
+- Multi-dimensional profitability analysis (CO-PA style) — future extension
+- What-if scenario modeling and simulation — future extension
+- Internal order settlement to receivers — future extension
+- Rolling forecasts beyond fiscal year boundaries — future extension
+- Manufacturing variance calculation — owned by `manufacturing`; this module consumes results
+- Transfer pricing between legal entities — future extension
+
+### Scope Decision Rationale
+
+The initial scope focuses on the six core entities identified in the roadmap (Budget, BudgetLine, ProfitCenter, CostAllocation, InternalOrder, Variance) plus foundational entities (CostCenter, CostElement) required by all management accounting features. Comprehensive features like activity-based costing and multi-dimensional profitability analysis are deferred as they add significant complexity without being prerequisites for the core budgeting-allocation-variance workflow. The module explicitly does not recreate entities already owned by other modules (fiscal calendar from finance-ledger, GL accounts from coa-management, manufacturing variances from manufacturing).
+
+## Module Dependencies
+
+- `primitives` — Currency definitions for multi-currency budget amounts and variance values
+- `organization` — Company scoping for all management accounting entities; Department/Site as optional mapping targets for cost centers and profit centers
+- `coa-management` — GL account references for primary cost elements, budget line items, and allocation target accounts
+- `finance-ledger` — Fiscal year/period alignment for budget periods; journal entry data as source of actuals; subledger integration pattern for posting allocation journal entries
+- `purchase` — Commitment event consumption for budgetary control: PO confirmation creates commitments, goods receipt and invoice match consume commitments, PO cancellation releases commitments
+- `user-management` — Permission definitions for budget creation, allocation execution, and report access
+- `audit` — Audit trail for budget lifecycle transitions, allocation runs, and variance postings

package/src/modules/accounting/command/activateBudget.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateBudget";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateBudget = defineCommand(permissions.activateBudget, run);

package/src/modules/accounting/command/activateBudget.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  DuplicateActiveBudgetError,
+} from "../lib/errors.generated";
+import { approvedBudget, baseBudget, activeBudget, basePlanVersion } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./activateBudget";
+
+const forecastPlanVersion = { ...basePlanVersion, id: "plan-version-forecast", type: "FORECAST" };
+const simulationPlanVersion = { ...basePlanVersion, id: "plan-version-sim", type: "SIMULATION" };
+
+describe("activateBudget", () => {
+  it("activates an APPROVED budget transitioning it to ACTIVE status", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion) // plan version type BUDGET
+      .mockReturnValueOnce(undefined); // no existing active
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("enables funds checking upon activation", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion)
+      .mockReturnValueOnce(undefined);
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("returns error when budget does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { budgetId: "missing" }, commandCtx);
+
+    expectErr(result, BudgetNotFoundError);
+  });
+
+  it("returns error when budget is not in APPROVED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget); // DRAFT
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when another ACTIVE BUDGET exists for the same cost object and fiscal year", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion) // type BUDGET
+      .mockReturnValueOnce(activeBudget) // existing active
+      .mockReturnValueOnce(basePlanVersion); // existing active's plan version is also BUDGET
+    // no update mock needed — should return error
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectErr(result, DuplicateActiveBudgetError);
+  });
+
+  it("allows multiple ACTIVE FORECAST versions for the same cost object and fiscal year", async () => {
+    const forecastApproved = { ...approvedBudget, planVersionId: forecastPlanVersion.id };
+    const activatedBudget = { ...forecastApproved, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(forecastApproved).mockReturnValueOnce(forecastPlanVersion); // type FORECAST — skip uniqueness check
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("allows multiple ACTIVE SIMULATION versions for the same cost object and fiscal year", async () => {
+    const simApproved = { ...approvedBudget, planVersionId: simulationPlanVersion.id };
+    const activatedBudget = { ...simApproved, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(simApproved).mockReturnValueOnce(simulationPlanVersion); // type SIMULATION — skip uniqueness check
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion)
+      .mockReturnValueOnce(undefined);
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/activateBudget.ts

@@ -0,0 +1,77 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  DuplicateActiveBudgetError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateBudgetInput {
+  budgetId: string;
+}
+
+export async function run(db: Transaction, input: ActivateBudgetInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch budget with lock
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", input.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!budget) {
+    return err(new BudgetNotFoundError(input.budgetId));
+  }
+
+  if (budget.status !== "APPROVED") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Check plan version type — only BUDGET type needs uniqueness check
+  const planVersion = await db
+    .selectFrom("PlanVersion")
+    .where("id", "=", budget.planVersionId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (planVersion?.type === "BUDGET") {
+    // Check no other ACTIVE budget of type BUDGET exists for same cost object and fiscal year
+    const existingActive = await db
+      .selectFrom("Budget")
+      .where("costObjectType", "=", budget.costObjectType)
+      .where("costObjectId", "=", budget.costObjectId)
+      .where("fiscalYearId", "=", budget.fiscalYearId)
+      .where("status", "=", "ACTIVE")
+      .where("id", "!=", input.budgetId)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (existingActive) {
+      // Verify the existing active budget is also of type BUDGET
+      const existingPlanVersion = await db
+        .selectFrom("PlanVersion")
+        .where("id", "=", existingActive.planVersionId)
+        .selectAll()
+        .executeTakeFirst();
+
+      if (existingPlanVersion?.type === "BUDGET") {
+        return err(new DuplicateActiveBudgetError(input.budgetId));
+      }
+    }
+  }
+
+  // Transition to ACTIVE (which enables funds checking)
+  const updated = await db
+    .updateTable("Budget")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.budgetId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ budget: updated! });
+}

package/src/modules/accounting/command/activateCostElement.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateCostElement";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateCostElement = defineCommand(permissions.activateCostElement, run);

package/src/modules/accounting/command/activateCostElement.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CostElementNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { baseCostElement, activeCostElement, inactiveCostElement } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./activateCostElement";
+
+describe("activateCostElement", () => {
+  it("activates a DRAFT cost element transitioning it to ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    const updated = { ...baseCostElement, status: "ACTIVE" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.costElement.status).toBe("ACTIVE");
+  });
+
+  it("returns error when cost element does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { costElementId: "missing" }, commandCtx);
+
+    expectErr(result, CostElementNotFoundError);
+  });
+
+  it("returns error when cost element is already ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCostElement);
+
+    const result = await run(db, { costElementId: activeCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when cost element is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCostElement);
+
+    const result = await run(db, { costElementId: inactiveCostElement.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCostElement);
+    spies.update.mockReturnValueOnce({ ...baseCostElement, status: "ACTIVE" });
+
+    const result = await run(db, { costElementId: baseCostElement.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});