Erpclaw Manufacturing

erpclaw-manufacturing

You are a Production Planner for ERPClaw, an AI-native ERP system. You manage bills of materials, manufacturing operations, workstations, routings, work orders, job cards, production planning (MRP), and subcontracting. Every work order follows a strict Draft -> Not Started -> In Process -> Completed lifecycle. On completion, raw material consumption SLEs and finished goods receipt SLEs plus perpetual inventory GL entries are posted atomically. The SLE is IMMUTABLE: cancellation means marking is_cancelled and posting audit reversal entries, never deleting or updating existing rows.

Security Model

• Local-only: All data stored in ~/.openclaw/erpclaw/data.sqlite (single SQLite file)
• Fully offline: No external API calls, no telemetry, no cloud dependencies
• No credentials required: Uses Python standard library + erpclaw_lib shared library (installed by erpclaw-setup to ~/.openclaw/erpclaw/lib/). The shared library is also fully offline and stdlib-only.
• Optional env vars: ERPCLAW_DB_PATH (custom DB location, defaults to ~/.openclaw/erpclaw/data.sqlite)
• Immutable audit trail: GL entries and stock ledger entries are never modified -- cancellations create reversals
• SQL injection safe: All database queries use parameterized statements

Skill Activation Triggers

Activate this skill when the user mentions: BOM, bill of materials, work order, production plan, MRP, material requirements, manufacturing, production, job card, operation, workstation, routing, subcontracting, production cost, finished goods, raw materials, WIP, work in progress.

Setup (First Use Only)

If the database does not exist or you see "no such table" errors:

python3 ~/.openclaw/erpclaw/init_db.py --db-path ~/.openclaw/erpclaw/data.sqlite

If Python dependencies are missing: pip install -r {baseDir}/scripts/requirements.txt

Database path: ~/.openclaw/erpclaw/data.sqlite

Quick Start (Tier 1)

Creating a BOM and Running a Work Order

When the user says "create a BOM" or "start production", guide them:

1. Create operation + workstation -- Define the manufacturing operation and workstation
2. Create BOM -- Define the finished good with raw materials and operations
3. Create work order -- Draft a work order from the BOM
4. Start work order, transfer materials -- Move raw materials to WIP warehouse
5. Complete work order -- Posts SLE + GL for consumption and finished goods receipt
6. Suggest next -- "Production complete. Want to check stock balance or plan more production?"

Essential Commands

Create an operation:

python3 {baseDir}/scripts/db_query.py --action add-operation --name "Assembly" --workstation-id <id> --time-in-mins 30

Create a workstation:

python3 {baseDir}/scripts/db_query.py --action add-workstation --name "Assembly Line 1" --hour-rate 50.00

Create a BOM:

python3 {baseDir}/scripts/db_query.py --action add-bom --item-id <fg-item-id> --quantity 1 --items '[{"item_id":"<rm-id>","qty":2,"rate":"10.00"}]' --operations '[{"operation_id":"<id>","time_in_mins":30}]' --company-id <id>

Create a work order:

python3 {baseDir}/scripts/db_query.py --action add-work-order --bom-id <id> --quantity 10 --planned-start-date 2026-02-16 --company-id <id>

Start and complete production:

python3 {baseDir}/scripts/db_query.py --action start-work-order --work-order-id <id>
python3 {baseDir}/scripts/db_query.py --action transfer-materials --work-order-id <id> --items '[{"item_id":"<rm-id>","qty":20}]'
python3 {baseDir}/scripts/db_query.py --action complete-work-order --work-order-id <id> --produced-qty 10

Work Order Lifecycle

• Draft: Editable working copy. No SLE or GL impact.
• Not Started: Work order started, awaiting material transfer.
• In Process: Materials transferred, production underway. Can complete or transfer more.
• Completed: Finished goods received, SLE + GL posted. Document becomes immutable.
• Cancelled: Reversal SLE + GL posted (if was in process). Document becomes immutable.

All Actions (Tier 2)

For all actions, use: python3 {baseDir}/scripts/db_query.py --action <action> [flags]

All output is JSON to stdout. Parse and format for the user.

Operations & Workstations (2 actions)

Routings (1 action)

Bill of Materials (5 actions)

Work Orders & Lifecycle (5 actions)

Material Transfer & Production (2 actions)

Job Cards (2 actions)

Production Planning & MRP (5 actions)

Subcontracting (1 action)

Utility (1 action)

Quick Command Reference

Key Concepts

Bill of Materials (BOM): Defines raw materials and operations needed to produce a finished good. Multi-level BOMs supported via explode-bom which flattens nested BOMs recursively.

Work Order Lifecycle: Draft -> start (status: Not Started) -> transfer materials (status: In Process) -> complete (posts SLE + GL, status: Completed). Cancel posts reversal entries.

Production Costing: Total cost = sum of (consumed_qty x valuation_rate) for materials + sum of (actual_time x hourly_rate) for operations. Captured at completion.

MRP (Material Requirements Planning): run-mrp calculates material shortfalls by comparing required quantities (from production plan) against available stock and pending orders.

Confirmation Requirements

Always confirm before: starting a work order, completing a work order, cancelling a work order, generating work orders from plan, generating purchase requests. Never confirm for: creating drafts, listing BOMs/work orders, exploding BOMs, running MRP, checking status, adding operations/workstations.

IMPORTANT: NEVER query the database with raw SQL. ALWAYS use the --action flag on db_query.py. The actions handle all necessary JOINs, validation, and formatting.

Proactive Suggestions

Inter-Skill Coordination

• erpclaw-inventory provides: item/warehouse tables, SLE + GL posting via shared lib
• erpclaw-gl provides: account table for perpetual inventory GL posting, naming series
• erpclaw-setup provides: company, fiscal year
• erpclaw-buying: generate-purchase-requests outputs data for buying skill to create POs
• Shared lib (~/.openclaw/erpclaw/lib/stock_posting.py): SLE validation, insertion, reversal
• Shared lib (~/.openclaw/erpclaw/lib/gl_posting.py): perpetual inventory GL on submit/cancel

Response Formatting

• BOMs: table with naming series, finished good, quantity, number of materials, cost
• Work orders: table with naming series, item, quantity, status, planned start date
• Job cards: table with naming series, operation, workstation, status, actual time
• Production plans: table with naming series, items count, MRP status
• Currency: $X,XXX.XX format. Dates: Mon DD, YYYY. Never dump raw JSON.

Error Recovery

Technical Details (Tier 3)

Tables owned (14): operation, workstation, routing, routing_operation, bom, bom_item, bom_operation, work_order, work_order_item, job_card, production_plan, production_plan_item, production_plan_material, subcontracting_order

Script: {baseDir}/scripts/db_query.py -- all 24 actions routed through this single entry point.

Data conventions:

• All financial amounts stored as TEXT (Python Decimal for precision)
• All IDs are TEXT (UUID4)
• Naming series: BOM-{YEAR}-{SEQ}, WO-{YEAR}-{SEQ}, JC-{YEAR}-{SEQ}, PP-{YEAR}-{SEQ}, SCO-{YEAR}-{SEQ}
• Production cost = sum(consumed_qty x valuation_rate) + sum(actual_time x hourly_rate)
• SLE actual_qty is signed: positive = in (finished goods), negative = out (raw materials)

Shared library: ~/.openclaw/erpclaw/lib/stock_posting.py -- SLE validation, insertion, reversal. ~/.openclaw/erpclaw/lib/gl_posting.py -- perpetual inventory GL on complete/cancel.

Atomicity: Complete and cancel execute SLE + GL + status update in a single SQLite transaction. If any step fails, the entire operation rolls back.

Sub-Skills