ApiLogicServer 15.1.3__py3-none-any.whl → 15.2.3__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/test/api_logic_server_behave/reports/Behave Logic Report.md

@@ -0,0 +1,303 @@
+This report shows test results with embedded logic execution traces.
+
+**For complete documentation on using Behave:** See [Behave.md](https://apilogicserver.github.io/Docs/Behave/)
+
+**About This Project:**
+
+_**TODO:** [Describe your project here - what it does, key features tested, etc.]_
+
+ 
+
+This report combines:
+
+* Behave log (lists Features, test Scenarios, results), with embedded
+* Logic showing rules executed, and how they operated
+
+---
+
+# Behave Logic Report
+ 
+ 
+## Feature: About Sample  
+  
+ 
+ 
+### Scenario: Transaction Processing                           # features/about.feature:8
+
+   Scenario: Transaction Processing  
+      **Given** Sample Database  
+      **When** Transactions are submitted  
+      **Then** Enforce business policies with Logic (rules + code)  
+  
+ 
+ 
+## Feature: Order Processing with Business Logic  
+  
+ 
+ 
+### Scenario: Good Order Placed                                   # features/order_processing.feature:3
+
+   Scenario: Good Order Placed  
+      **Given** Customer "Alice" with balance 0 and credit limit 1000  
+      **When** B2B order placed for "Alice" with 5 Widget  
+      **Then** Customer "Alice" balance should be 450  
+      **And** Order amount_total should be 450  
+      **And** Item amount should be 450  
+  
+ 
+ 
+### Scenario: Increase Item Quantity                            # features/order_processing.feature:10
+
+   Scenario: Increase Item Quantity  
+      **Given** Customer "Bob" with balance 0 and credit limit 2000  
+      **And** Order exists for "Bob" with 5 Widget  
+      **When** Item quantity changed to 10  
+      **Then** Item amount should be 900  
+      **And** Order amount_total should be 900  
+      **And** Customer "Bob" balance should be 900  
+  
+ 
+ 
+### Scenario: Carbon Neutral Discount Applied                        # features/order_processing.feature:18
+
+   Scenario: Carbon Neutral Discount Applied  
+      **Given** Customer "Carol" with balance 0 and credit limit 2000  
+      **When** B2B order placed for "Carol" with 10 carbon neutral Green  
+      **Then** Item amount should be 981  
+      **And** Order amount_total should be 981  
+      **And** Customer "Carol" balance should be 981  
+<details markdown>
+<summary>Tests - and their logic - are transparent.. click to see Logic</summary>
+
+
+&nbsp;
+&nbsp;
+
+
+**Rules Used** in Scenario: Carbon Neutral Discount Applied            # features/order_processing.feature:18
+```
+  Customer  
+    1. Derive <class 'database.models.Customer'>.balance as Sum(Order.amount_total Where Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None) - <function declare_logic.<locals>.<lambda> at 0x10c5f8cc0>)  
+  Item  
+    2. Derive <class 'database.models.Item'>.amount as Formula (1): <function>  
+    3. Derive <class 'database.models.Item'>.unit_price as Copy(product.unit_price)  
+  Order  
+    4. Derive <class 'database.models.Order'>.amount_total as Sum(Item.amount Where  - None)  
+    5. RowEvent Order.send_order_to_shipping()   
+```
+**Logic Log** in Scenario: Carbon Neutral Discount Applied            # features/order_processing.feature:18
+```
+
+Carbon Neutral Discount Applie
+ - 2025-10-20 19:17:14,919 - logic_logger - INF
+
+Logic Phase:		ROW LOGIC		(session=0x10d61bbd0) (sqlalchemy before_flush)			 - 2025-10-20 19:17:14,921 - logic_logger - INF
+..Customer[43] {Update - client} id: 43, name: Carol 1761013034915, balance: 0E-10, credit_limit: 2000.0000000000, email: None, email_opt_out: None  row: 0x10d6e4250  session: 0x10d61bbd0  ins_upd_dlt: upd, initial: upd - 2025-10-20 19:17:14,921 - logic_logger - INF
+Logic Phase:		COMMIT LOGIC		(session=0x10d61bbd0)   										 - 2025-10-20 19:17:14,921 - logic_logger - INF
+Logic Phase:		AFTER_FLUSH LOGIC	(session=0x10d61bbd0)   										 - 2025-10-20 19:17:14,921 - logic_logger - INF
+
+```
+</details>
+  
+&nbsp;
+&nbsp;
+### Scenario: Change Order Customer                              # features/order_processing.feature:25
+
+&emsp;  Scenario: Change Order Customer  
+&emsp;&emsp;    **Given** Customer "Dave" with balance 0 and credit limit 1500  
+&emsp;&emsp;    **And** Customer "Eve" with balance 0 and credit limit 1500  
+&emsp;&emsp;    **And** Order exists for "Dave" with 5 Widget  
+&emsp;&emsp;    **When** Order customer changed to "Eve"  
+&emsp;&emsp;    **Then** Customer "Dave" balance should be 0  
+&emsp;&emsp;    **And** Customer "Eve" balance should be 450  
+  
+&nbsp;
+&nbsp;
+### Scenario: Delete Item Reduces Totals                          # features/order_processing.feature:33
+
+&emsp;  Scenario: Delete Item Reduces Totals  
+&emsp;&emsp;    **Given** Customer "Frank" with balance 0 and credit limit 1500  
+&emsp;&emsp;    **And** Order exists for "Frank" with 3 Widget and 2 Gadget  
+&emsp;&emsp;    **When** First item deleted  
+&emsp;&emsp;    **Then** Order amount_total should be 300  
+&emsp;&emsp;    **And** Customer "Frank" balance should be 300  
+<details markdown>
+<summary>Tests - and their logic - are transparent.. click to see Logic</summary>
+
+
+&nbsp;
+&nbsp;
+
+
+**Rules Used** in Scenario: Delete Item Reduces Totals             # features/order_processing.feature:33
+```
+  Customer  
+    1. Derive <class 'database.models.Customer'>.balance as Sum(Order.amount_total Where Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None) - <function declare_logic.<locals>.<lambda> at 0x10c5f8cc0>)  
+  Item  
+    2. Derive <class 'database.models.Item'>.amount as Formula (1): <function>  
+    3. Derive <class 'database.models.Item'>.unit_price as Copy(product.unit_price)  
+  Order  
+    4. Derive <class 'database.models.Order'>.amount_total as Sum(Item.amount Where  - None)  
+    5. RowEvent Order.send_order_to_shipping()   
+```
+**Logic Log** in Scenario: Delete Item Reduces Totals             # features/order_processing.feature:33
+```
+
+Delete Item Reduces Total
+ - 2025-10-20 19:17:14,965 - logic_logger - INF
+
+Logic Phase:		ROW LOGIC		(session=0x10d618af0) (sqlalchemy before_flush)			 - 2025-10-20 19:17:14,967 - logic_logger - INF
+..Customer[46] {Update - client} id: 46, name: Frank 1761013034961, balance: 0E-10, credit_limit: 1500.0000000000, email: None, email_opt_out: None  row: 0x10d8836d0  session: 0x10d618af0  ins_upd_dlt: upd, initial: upd - 2025-10-20 19:17:14,967 - logic_logger - INF
+Logic Phase:		COMMIT LOGIC		(session=0x10d618af0)   										 - 2025-10-20 19:17:14,967 - logic_logger - INF
+Logic Phase:		AFTER_FLUSH LOGIC	(session=0x10d618af0)   										 - 2025-10-20 19:17:14,967 - logic_logger - INF
+
+```
+</details>
+  
+&nbsp;
+&nbsp;
+### Scenario: Ship Order Excludes from Balance                    # features/order_processing.feature:40
+
+&emsp;  Scenario: Ship Order Excludes from Balance  
+&emsp;&emsp;    **Given** Customer "Grace" with balance 0 and credit limit 1000  
+&emsp;&emsp;    **And** Order exists for "Grace" with 5 Widget  
+&emsp;&emsp;    **When** Order shipped  
+&emsp;&emsp;    **Then** Customer "Grace" balance should be 0  
+<details markdown>
+<summary>Tests - and their logic - are transparent.. click to see Logic</summary>
+
+
+&nbsp;
+&nbsp;
+
+
+**Rules Used** in Scenario: Ship Order Excludes from Balance          # features/order_processing.feature:40
+```
+  Customer  
+    1. Derive <class 'database.models.Customer'>.balance as Sum(Order.amount_total Where Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None) - <function declare_logic.<locals>.<lambda> at 0x10c5f8cc0>)  
+  Item  
+    2. Derive <class 'database.models.Item'>.amount as Formula (1): <function>  
+    3. Derive <class 'database.models.Item'>.unit_price as Copy(product.unit_price)  
+  Order  
+    4. Derive <class 'database.models.Order'>.amount_total as Sum(Item.amount Where  - None)  
+    5. RowEvent Order.send_order_to_shipping()   
+```
+**Logic Log** in Scenario: Ship Order Excludes from Balance          # features/order_processing.feature:40
+```
+
+Ship Order Excludes from Balanc
+ - 2025-10-20 19:17:14,989 - logic_logger - INF
+
+Logic Phase:		ROW LOGIC		(session=0x10d618e20) (sqlalchemy before_flush)			 - 2025-10-20 19:17:14,991 - logic_logger - INF
+..Customer[47] {Update - client} id: 47, name: Grace 1761013034985, balance: 0E-10, credit_limit: 1000.0000000000, email: None, email_opt_out: None  row: 0x10d6e4ed0  session: 0x10d618e20  ins_upd_dlt: upd, initial: upd - 2025-10-20 19:17:14,991 - logic_logger - INF
+Logic Phase:		COMMIT LOGIC		(session=0x10d618e20)   										 - 2025-10-20 19:17:14,991 - logic_logger - INF
+Logic Phase:		AFTER_FLUSH LOGIC	(session=0x10d618e20)   										 - 2025-10-20 19:17:14,991 - logic_logger - INF
+
+```
+</details>
+  
+&nbsp;
+&nbsp;
+### Scenario: Unship Order Includes in Balance                    # features/order_processing.feature:46
+
+&emsp;  Scenario: Unship Order Includes in Balance  
+&emsp;&emsp;    **Given** Customer "Henry" with balance 0 and credit limit 1000  
+&emsp;&emsp;    **And** Shipped order exists for "Henry" with 5 Widget  
+&emsp;&emsp;    **When** Order unshipped  
+&emsp;&emsp;    **Then** Customer "Henry" balance should be 450  
+<details markdown>
+<summary>Tests - and their logic - are transparent.. click to see Logic</summary>
+
+
+&nbsp;
+&nbsp;
+
+
+**Rules Used** in Scenario: Unship Order Includes in Balance          # features/order_processing.feature:46
+```
+  Customer  
+    1. Derive <class 'database.models.Customer'>.balance as Sum(Order.amount_total Where Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None) - <function declare_logic.<locals>.<lambda> at 0x10c5f8cc0>)  
+  Order  
+    2. RowEvent Order.send_order_to_shipping()   
+```
+**Logic Log** in Scenario: Unship Order Includes in Balance          # features/order_processing.feature:46
+```
+
+Unship Order Includes in Balanc
+ - 2025-10-20 19:17:15,013 - logic_logger - INF
+
+Logic Phase:		ROW LOGIC		(session=0x10d61a7a0) (sqlalchemy before_flush)			 - 2025-10-20 19:17:15,015 - logic_logger - INF
+..Customer[48] {Update - client} id: 48, name: Henry 1761013035008, balance: 0E-10, credit_limit: 1000.0000000000, email: None, email_opt_out: None  row: 0x10d8a12d0  session: 0x10d61a7a0  ins_upd_dlt: upd, initial: upd - 2025-10-20 19:17:15,015 - logic_logger - INF
+Logic Phase:		COMMIT LOGIC		(session=0x10d61a7a0)   										 - 2025-10-20 19:17:15,015 - logic_logger - INF
+Logic Phase:		AFTER_FLUSH LOGIC	(session=0x10d61a7a0)   										 - 2025-10-20 19:17:15,015 - logic_logger - INF
+
+```
+</details>
+  
+&nbsp;
+&nbsp;
+### Scenario: Exceed Credit Limit                               # features/order_processing.feature:52
+
+&emsp;  Scenario: Exceed Credit Limit  
+&emsp;&emsp;    **Given** Customer "Ivan" with balance 0 and credit limit 100  
+&emsp;&emsp;    **When** B2B order placed for "Ivan" with 5 Widget  
+&emsp;&emsp;    **Then** Order creation should fail  
+&emsp;&emsp;    **And** Error message should contain "credit limit"  
+  
+&nbsp;
+&nbsp;
+### Scenario: Change Product ID Re-copies Price                  # features/order_processing.feature:58
+
+&emsp;  Scenario: Change Product ID Re-copies Price  
+&emsp;&emsp;    **Given** Customer "Jane" with balance 0 and credit limit 2000  
+&emsp;&emsp;    **And** Order exists for "Jane" with 5 Widget  
+&emsp;&emsp;    **When** Item product changed to "Gadget"  
+&emsp;&emsp;    **Then** Item unit_price should be 150  
+&emsp;&emsp;    **And** Item amount should be 750  
+&emsp;&emsp;    **And** Order amount_total should be 750  
+&emsp;&emsp;    **And** Customer "Jane" balance should be 750  
+<details markdown>
+<summary>Tests - and their logic - are transparent.. click to see Logic</summary>
+
+
+&nbsp;
+&nbsp;
+
+
+**Rules Used** in Scenario: Change Product ID Re-copies Price         # features/order_processing.feature:58
+```
+  Customer  
+    1. Derive <class 'database.models.Customer'>.balance as Sum(Order.amount_total Where Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None) - <function declare_logic.<locals>.<lambda> at 0x10c5f8cc0>)  
+  Item  
+    2. Derive <class 'database.models.Item'>.amount as Formula (1): <function>  
+    3. Derive <class 'database.models.Item'>.unit_price as Copy(product.unit_price)  
+  Order  
+    4. Derive <class 'database.models.Order'>.amount_total as Sum(Item.amount Where  - None)  
+    5. RowEvent Order.send_order_to_shipping()   
+```
+**Logic Log** in Scenario: Change Product ID Re-copies Price         # features/order_processing.feature:58
+```
+
+Change Product ID Re-copies Pric
+ - 2025-10-20 19:17:15,051 - logic_logger - INF
+
+Logic Phase:		ROW LOGIC		(session=0x10d61bac0) (sqlalchemy before_flush)			 - 2025-10-20 19:17:15,052 - logic_logger - INF
+..Customer[50] {Update - client} id: 50, name: Jane 1761013035046, balance: 0E-10, credit_limit: 2000.0000000000, email: None, email_opt_out: None  row: 0x10d8a1250  session: 0x10d61bac0  ins_upd_dlt: upd, initial: upd - 2025-10-20 19:17:15,052 - logic_logger - INF
+Logic Phase:		COMMIT LOGIC		(session=0x10d61bac0)   										 - 2025-10-20 19:17:15,052 - logic_logger - INF
+Logic Phase:		AFTER_FLUSH LOGIC	(session=0x10d61bac0)   										 - 2025-10-20 19:17:15,053 - logic_logger - INF
+
+```
+</details>
+  
+&nbsp;
+&nbsp;
+### Scenario: Multi-Item Order Total                               # features/order_processing.feature:67
+
+&emsp;  Scenario: Multi-Item Order Total  
+&emsp;&emsp;    **Given** Customer "Kevin" with balance 0 and credit limit 2000  
+&emsp;&emsp;    **When** B2B order placed for "Kevin" with 3 Widget and 2 Gadget  
+&emsp;&emsp;    **Then** Order amount_total should be 570  
+&emsp;&emsp;    **And** Customer "Kevin" balance should be 570  
+  
+&nbsp;&nbsp;  
+/Users/val/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer/basic_demo/test/api_logic_server_behave/behave_run.py completed at October 20, 2025 19:17:1  

api_logic_server_cli/prototypes/manager/samples/{basic_demo → basic_demo_sample}/test/readme_test.md

@@ -49,6 +49,26 @@ python behave_run.py
 # In Debug Console, select "Behave Run" from dropdown (not server log)
 ```
 
+### Running Specific Tests
+
+You can run specific features or scenarios using behave's command-line options:
+
+```bash
+# Run a specific feature file
+behave features/check_credit.feature
+
+# Run a specific scenario by name
+behave -n "Good Order - Basic Chain"
+
+# Run scenarios matching a pattern
+behave -n ".*credit.*"
+
+# Run with tags (if you've tagged scenarios with @smoke, @wip, etc.)
+behave --tags=smoke
+```
+
+**Note**: When using `behave` directly (not `behave_run.py`), logic logs still generate in `logs/scenario_logic_logs/`, but the wrapper provides additional error checking.
+
 ### Alternative: Basic Server Tests
 
 ```bash
@@ -205,6 +225,29 @@ def step_impl(context):
     assert final_state.calculated_field == expected_value
 ```
 
+**Understanding the `context` Object:**
+
+The `context` object in Behave is shared across all steps in a scenario, making it perfect for passing data between Given/When/Then steps:
+
+```python
+# Store values in GIVEN steps
+context.customer_id = 123
+context.initial_balance = 1000
+
+# Access in WHEN steps  
+order_data = {"customer_id": context.customer_id, "amount": 500}
+
+# Verify in THEN steps
+assert context.response.status_code == 200
+```
+
+**Common context patterns:**
+- `context.customer_id`, `context.order_id`, etc. - Store entity IDs
+- `context.initial_balance`, `context.before_amount` - Capture "before" state
+- `context.response` - Store API response for later assertions
+- `context.auth_header` - Store authentication token
+- `context.expected_error` - Store expected error for negative tests
+
 ## 🤖 For GitHub Copilot
 
 When generating tests for API Logic Server projects:
@@ -354,10 +397,35 @@ delete_url = f"{base_url}/{EntityName}/{entity_id}/"
 
 ## 📊 Test Reports and Logging
 
-- **Logic Reports**: Generated in `reports/` showing which rules executed
-- **Behave Output**: Standard BDD test results with pass/fail status
-- **Logic Logs**: Detailed rule execution in `logs/scenario_logic_logs/`
-- **Server Logs**: API request/response details and errors
+### Viewing Test Output
+
+After running tests, you can view results in multiple locations:
+
+- **Console Output**: Real-time pass/fail status during test execution
+- **Behave Log**: `logs/behave.log` - Detailed test execution output
+- **Scenario Logic Logs**: `logs/scenario_logic_logs/*.log` - One file per scenario showing rule execution
+- **Server Logs**: API request/response details and errors in server console
+
+### Generating Logic Reports
+
+To create a comprehensive markdown report showing which rules executed in each scenario:
+
+```bash
+# From test/api_logic_server_behave directory
+python behave_logic_report.py run
+```
+
+This generates `reports/Behave Logic Report.md` containing:
+- **Test Scenarios**: All executed scenarios with descriptions
+- **Logic Documentation**: Step docstrings explaining what each test validates
+- **Rules Fired**: Which business logic rules executed during each scenario
+- **Disclosure Areas**: Expandable sections showing detailed logic traces
+
+The report is useful for:
+- Understanding which rules are tested by which scenarios
+- Documenting test coverage for business stakeholders
+- Debugging rule execution order and dependencies
+- Verifying that expected rules actually fired
 
 ## 🔍 Debugging Tests
 

api_logic_server_cli/prototypes/manager/samples/readme_samples.md

@@ -6,7 +6,7 @@ See https://apilogicserver.github.io/Docs/Data-Model-Examples/.  The Manager con
 
 * `samples/nw_sample_nocust` is the same database, but without customizations.  With no customizations, the default nw example illustrates the **level of automation you should expect for your own projects.**
 
-* `samples/basic_demo` is the pre-built demo tutorial.  You can r**ebuild it using the readme's.**
+* `samples/basic_demo_sample` is the pre-built demo tutorial.  You can r**ebuild it using the readme's, either by cli (`README.md`) or natural language (`readme_vibe.md`).**
 
 <br>
 

api_logic_server_cli/prototypes/manager/system/ApiLogicServer-Internal-Dev/copilot-dev-context.md

@@ -0,0 +1,185 @@
+# Context Restoration: BLT Manager Workspace
+
+**Purpose:** This file re-establishes AI assistant context after BLT runs regenerate this workspace.
+
+ 
+
+## 🎯 YOU ARE HERE: BLT Manager (Nested Workspace)
+
+**Current Location:** `~/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer/`
+
+This is the **BLT Manager** - a nested workspace that gets regenerated by the Build-Load-Test process.
+
+**Directory Structure:**
+```
+~/dev/ApiLogicServer/ApiLogicServer-dev/          # Seminal Manager (stable)
+├── build_and_test/
+│   └── ApiLogicServer/                           # ← YOU ARE HERE (BLT Manager)
+│       ├── samples/                              # Sample/test projects
+│       ├── venv/                                 # Shared venv for test projects
+│       ├── .github/.copilot-profile.md           # This file
+│       └── docs/training/                        # Training materials
+└── org_git/
+    ├── ApiLogicServer-src/                       # Framework source (edit here)
+    └── Docs/                                     # Documentation project
+```
+
+**Key Facts:**
+- This workspace is **regenerated** with each BLT run
+- Sample projects live here for testing
+- Has its own venv shared by test projects
+- Framework changes happen in `org_git/ApiLogicServer-src/`
+
+ 
+
+## 📚 Complete Architecture Documentation
+
+**For comprehensive technical context, read:**
+
+### [Architecture-Internals.md](https://apilogicserver.github.io/Docs/Architecture-Internals/)
+
+This document contains **everything** you need to understand the system:
+
+1. **Technology Lineage** - 40+ years of proven history:
+   - Wang Labs PACE (6,000+ customers, 1980s-1990s)
+   - Versata ($3.4B startup, Fortune 500 deployments, 1990s-2010s)
+   - API Logic Server (modern cloud-native evolution, 2020s-present)
+
+2. **Declarative Architecture** - The NL → DSL → Engines pattern:
+   - Why rules are mandatory (correctness guarantee)
+   - Dependency chains and automatic completeness
+   - Database, API, UI, Logic engines
+
+3. **Nested Manager Architecture** - Critical development structure:
+   - Seminal Manager vs. BLT Manager (nested)
+   - Development workflow: edit → BLT → test
+   - Why this architecture exists
+
+4. **Installation & Development Procedures** - How to work with the system:
+   - Manager installation (`install-ApiLogicServer-dev.sh`)
+   - Running BLT (Build-Load-Test)
+   - Critical smoke test procedures
+   - Ongoing development workflows
+
+5. **Cross-References** - Complete navigation map to all documentation
+
+**👉 START HERE when establishing context in a new session.**
+
+ 
+
+## 🧭 Documentation Navigation Map
+
+### For AI Assistants Working on Framework Internals:
+- **[Architecture-Internals.md](https://apilogicserver.github.io/Docs/Architecture-Internals/)** - Complete technical architecture (read this first)
+- **[Medium Article](https://medium.com/@valjhuber/declarative-genai-the-architecture-behind-enterprise-vibe-automation-1b8a4fe4fbd7)** - Architectural rationale and NL→DSL→Engines pattern
+
+### For Creating New Projects:
+- **Manager-level `.copilot-instructions.md`** - How to CREATE projects (in workspace root)
+  - **Location:** `prototypes/manager/.github/.copilot-instructions.md`
+  - **Size:** ~86 lines
+  - **Scope:** Creating projects ONLY (3 methods: existing DB, GenAI, new DB)
+  - **Purpose:** Instructions for creating new projects with `genai-logic create` commands
+  - **Does NOT contain:** Project customization, logic patterns, testing, security, etc.
+
+### For Working Within Created Projects:
+- **Project-level `.copilot-instructions.md`** - How to EXTEND/CUSTOMIZE projects (auto-generated in each project)
+  - **Location:** `prototypes/base/.github/.copilot-instructions.md` (template)
+  - **Size:** ~740 lines
+  - **Scope:** Complete architecture guide for EACH created project
+  - **Purpose:** 13 Main Services (what AI can do in a project):
+    1. **Run Project** - F5 debug, `api_logic_server_run.py`
+    2. **Adding Business Logic** - Translate NL → LogicBank rules (sums, formulas, constraints, events)
+    3. **Discovery Systems** - Auto-load logic from `logic/logic_discovery/*.py`, APIs from `api/api_discovery/*.py`
+    4. **Automated Testing** - Behave tests with BLT reports (requirements traceability)
+    5. **Adding MCP** - Enable MCP client UI with `genai-logic genai-add-mcp-client`
+    6. **Configuring Admin UI** - Edit `ui/admin/admin.yaml` for customization
+    7. **Create React Apps** - `genai-logic genai-add-app` for custom UIs
+    8. **Security - RBAC** - `als add-auth` for SQL/Keycloak, `security/declare_security.py` for grants
+    9. **Custom API Endpoints** - Add routes in `api/customize_api.py`
+    10. **B2B Integration APIs** - Complex endpoints with Row Dict Mappers for partner integration
+    11. **Customize Models** - Add tables, attributes, derived fields
+    12. **Adding Events** - Row events for integrations (Kafka, webhooks, etc.)
+    13. **Critical Patterns** - React component best practices, null-safe constraints, test repeatability
+  - ⚠️ **CRITICAL:** These are TWO DIFFERENT FILES - never replace the per-project version with the manager version!
+  - 🚨 **PROPAGATION PROBLEM:** Changes to project-level instructions must be carefully copied to `prototypes/base/.github/.copilot-instructions.md`
+- **`docs/training/logic_bank_api.prompt`** - LogicBank API reference (Rosetta Stone for rules)
+- **`docs/training/testing.md`** - Behave testing guide (1755 lines, read BEFORE creating tests)
+
+### For End Users:
+- **[API Logic Server Documentation](https://apilogicserver.github.io/Docs/Doc-Home/)** - Complete user guide
+- **[Installation Guide](https://apilogicserver.github.io/Docs/Install/)** - Setup procedures
+- **[Tutorial](https://apilogicserver.github.io/Docs/Tutorial/)** - Step-by-step learning
+
+ 
+
+## 👤 Current Maintainer
+
+**Val Huber**
+- **Wang Labs PACE**: Designed and led the business rules architecture, co-invented (in parallel with Ron Ross) the declarative rules paradigm and execution engine
+- **Versata**: CTO, designed and lead scaling the rules technology to J2EE and the web
+- **API Logic Server**: Architect and lead developer, modernizing proven patterns for cloud-native Python/React stack, the use of GenAI, and current IDEs/deployment practices.
+
+**Expertise:** 40+ years leading business rules technology evolution - inventor of declarative multi-table derivations, constraint propagation, and rule execution engines.
+
+ 
+
+## 🤖 AI Assistant Quick Reference
+
+### Two Working Modes:
+- **Author-Val** (Developer/Maintainer) - Working on framework internals, debugging, testing
+- **User-Val** (Simulating End Users) - Testing product workflows, creating demos, validating UX
+
+### Context Establishment Protocol:
+1. **Read [Architecture-Internals.md](https://apilogicserver.github.io/Docs/Architecture-Internals/)** for complete technical context
+2. Identify which documentation to consult based on task:
+   - Framework development → Architecture-Internals.md
+   - Project creation → Manager-level `.copilot-instructions.md` (86 lines, in prototypes/manager/)
+   - Project customization → Project-level `.copilot-instructions.md` (740 lines, in prototypes/base/)
+   - Adding logic → `docs/training/logic_bank_api.prompt`
+   - Creating tests → `docs/training/testing.md`
+3. **CRITICAL:** Never confuse the two `.copilot-instructions.md` files:
+   - Manager version = how to CREATE projects (small, workspace-level)
+   - Project version = how to CUSTOMIZE projects (large, per-project with architecture details)
+4. When role unclear, ask: "Are you testing as a user or working on internals?"
+
+### Key Principles:
+- **Assume deep technical expertise** - Technology refined over 40+ years
+- **Focus on efficient execution** - Less explanation, more action
+- **Respect the architecture** - Patterns represent battle-tested solutions from thousands of deployments
+- **Check training materials** - `logic_bank_api.prompt` and `testing.md` prevent common AI mistakes
+
+### Communication Tone Guidelines:
+- **Confident but NEVER hyperbolic** - Make only claims backed by specific, measurable evidence
+- **Cite concrete metrics** - "200 lines → 5 rules (40X)" not "transforms years into days"
+- **Reference historical facts** - "40+ years, 6,000+ deployments" establishes credibility
+- **Avoid unfounded superlatives** - No "revolutionary", "game-changing", or time-compression claims without data
+- **Be specific** - "Creates working API in 5 seconds" vs "drastically reduces development time"
+- **NEVER claim** - Time compression like "30-40 years → 3-4 days" - these are unmeasurable and unfounded
+- **DO claim** - Specific productivity gains with evidence: "40X code reduction", "instant API from database"
+
+ 
+
+## 🔄 Development Workflow
+
+**Source Repository:** https://github.com/ApiLogicServer/ApiLogicServer-src
+
+**Local Dev Path:** `/Users/val/dev/ApiLogicServer/ApiLogicServer-dev/org_git/ApiLogicServer-src`
+
+**Workflow:**
+1. Edit framework code in `org_git/ApiLogicServer-src/`
+2. Run BLT from Seminal Manager (rebuilds, tests, regenerates this workspace)
+3. Test with sample projects in this workspace
+4. Sync templates back to `ApiLogicServer-src`
+5. Push to GitHub
+
+**BLT (Build-Load-Test):**
+- Rebuilds API Logic Server from dev source
+- Creates ~18 test projects with validation
+- Critical smoke test before pushing to GitHub
+- Results in `tests/results.txt` and `tests/failures.txt`
+
+ 
+
+---
+
+**📖 Remember:** This file provides orientation. For comprehensive technical understanding, read **[Architecture-Internals.md](https://apilogicserver.github.io/Docs/Architecture-Internals/)** - it's written for both AI assistants and human collaborators.