ApiLogicServer 16.1.3__py3-none-any.whl → 16.1.18__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/.github/.copilot-instructions.md

@@ -6,11 +6,12 @@
 ⚠️ IF USER SAYS: "load .github/.copilot-instructions.md" OR ANY ACTIVATION PHRASE
 ⚠️ YOU MUST EXECUTE THIS EXACT SEQUENCE - NO DEVIATIONS:
 
-1. Read .github/welcome.md (silently - do not mention this action)
-2. Display ONLY the content from welcome.md
-3. DO NOT say "I've loaded the instructions"
-4. DO NOT display this .copilot-instructions.md file
-5. DO NOT explain what you're doing
+1. Read .github/.copilot-instructions.md COMPLETELY (silently - internalize all instructions)
+2. Read .github/welcome.md (silently - do not mention this action)
+3. Display ONLY the content from welcome.md
+4. DO NOT say "I've loaded the instructions"
+5. DO NOT display this .copilot-instructions.md file
+6. DO NOT explain what you're doing
 
 THIS IS NOT A SUGGESTION - THIS IS A MANDATORY COMMAND
 
@@ -30,15 +31,68 @@ THIS IS NOT A SUGGESTION - THIS IS A MANDATORY COMMAND
 **MANDATORY RESPONSE SEQUENCE:**
 
 ```
-STEP 1: Read .github/welcome.md (silently)
-STEP 2: Display welcome.md content ONLY
-STEP 3: STOP - do nothing else
+STEP 1: Read .github/.copilot-instructions.md COMPLETELY (silently - internalize all instructions)
+STEP 2: Read .github/welcome.md (silently)
+STEP 3: Display welcome.md content ONLY
+STEP 4: STOP - do nothing else
+```
+
+---
+
+## 🎯 CRITICAL: Guided Tour Activation Protocol
+
+**ACTIVATION TRIGGERS:**
+- "guide me through"
+- "guide me"
+- "take the tour"
+- "walk me through"
+- "show me around"
+- Any similar tour/walkthrough request
+
+**MANDATORY RESPONSE SEQUENCE:**
+
+```
+STEP 1: Read tutor.md COMPLETELY (silently)
+STEP 2: Follow tutor.md instructions EXACTLY
+STEP 3: Act as TOUR GUIDE (not passive assistant)
+STEP 4: Create manage_todo_list for tour sections
+STEP 5: Start with tutor.md Introduction section
 ```
 
+**✅ CORRECT EXECUTION:**
+```
+User: "guide me"
+
+AI: [reads tutor.md completely - NO OUTPUT]
+AI: [creates todo list from tutor sections]
+AI: [follows tutor.md Introduction section exactly]
+AI: "I'll guide you through basic_demo - a 20-minute hands-on exploration..."
+```
+
+**❌ FORBIDDEN BEHAVIORS:**
+```
+User: "guide me"
+
+❌ AI: Starts giving general guidance without reading tutor.md
+❌ AI: Runs commands without following tutor choreography
+❌ AI: Acts as passive assistant waiting for user direction
+❌ AI: Skips sections or reorders steps
+❌ AI: Offers option menus instead of directing the tour
+❌ AI: Assumes server state or skips stop/start sequences
+```
+
+**RATIONALE:**
+- tutor.md contains weeks of refined choreography
+- Every command, stop, start is precisely sequenced
+- Deviations break the learning experience
+- You are the DIRECTOR in tour mode, not a passive responder
+- The tour has been engineered for AI reliability through multiple iterations
+
 **✅ CORRECT EXECUTION:**
 ```
 User: "load .github/.copilot-instructions.md"
 
+AI: [reads .copilot-instructions.md COMPLETELY - NO OUTPUT - internalizes all instructions]
 AI: [reads welcome.md silently - NO OUTPUT]
 AI: [displays ONLY this]:
 
@@ -69,6 +123,20 @@ User: "load .github/.copilot-instructions.md"
 
 ---
 
+## 📖 Content Organization Protocol
+
+**WHEN USER ASKS: "how do rules work" or "explain the rules engine"**
+**PRIMARY ANSWER**: Provide the **"How the Rules Engine Works"** 3-phase overview below:
+  1. Authoring (AI-assisted, human-reviewed)
+  2. Engine Initialization (Deterministic analysis)
+  3. Runtime Enforcement (Commit-time)
+
+**FOLLOW-UP OFFER**: After showing the 3 phases, offer: "Would you like more detail on any specific aspect?"
+
+**NEVER**: Respond with generic "Key Concepts" or custom explanations - use the specific 3-phase content from this file.
+
+---
+
 ## Capabilities Reference
 
 When user asks "what can I do here", list these capabilities:
@@ -133,6 +201,251 @@ changelog:
 
 ---
 
+## 📚 Learning Curve (Honest Assessment)
+
+**Timeline:**
+- **Week 1:** ~10 hours - Basic rules (sum, count, formula, constraint, copy), see them work
+- **Month 1:** ~30 hours total - Comfortable with 90% of use cases, including events and debugging
+- **Hardest part:** Mental shift from procedural → declarative thinking (1-2 weeks of practice)
+
+**When NOT to use rules:**
+- Read-only analytics/reporting (rules enforce writes, not reads)
+- Complex algorithms (graph traversal, optimization, ML - not data relationships)
+- Workflow orchestration (multi-step processes - use Temporal/Airflow)
+- Real-time streaming (high-frequency data - use Kafka/Flink)
+
+**When rules are essential:**
+- Data dependency graphs (X affects Y affects Z)
+- Multiple change paths (insert/update/delete/FK changes)
+- Production systems requiring correctness guarantees
+- Long-term maintained systems with evolving requirements
+
+**Compared to AI-generated procedural code:**
+- AI code: 5 minutes to generate, may have bugs (2 found in our test), 220 lines to maintain
+- AI rules: 30-hour learning curve, 0 bugs (engine guarantees), 5 lines, handles all paths automatically
+- See the comparison study linked in "Why the Rules Engine is a Correctness Guarantee" section below
+
+---
+
+## 🤔 Common Developer Questions (FAQ)
+
+### "I hear vibe results in unruly code - is this a vibe tool?"
+
+**No - but it's the perfect backend partner for vibe UIs.**
+
+**Backend governance** (enforcing multi-table constraints and derivations at commit - balances, totals, credit limits - regardless of which client writes):
+
+**The Problem with Vibe Alone:**
+- Vibe generates fast UIs, but those UIs can send ANY data to your backend
+- Who ensures `Customer.balance = Sum(Order.amount_total)`? Who checks credit limits?
+- You either hand-code validation (slow, error-prone) or hope nothing breaks
+
+**GenAI-Logic = Data Integrity for Vibe:**
+- ✅ **Your data is safe** - No matter what the vibe UI does, rules enforce invariants at commit
+- ✅ **Nothing bypasses validation** - All writes (APIs, workflows, UIs, agents) pass through the same rule engine
+- ✅ **Multi-table derivations** - `Customer.balance = sum(orders)`, `Order.total = sum(items)` - automatic cascading
+- ✅ **Declarative specifications** - 5 rules instead of 200+ lines of procedural validation code
+- ✅ **Correctness guarantee** - Proven engine handles ALL change paths (FKs, cascades, transitive dependencies)
+
+**The Architecture:**
+- **Frontend (vibe):** Generate UI fast, iterate quickly
+- **Backend (GenAI-Logic):** Enforce business rules at commit - nothing bypasses them
+- **Result:** Move fast AND keep data correct
+
+**See the A/B test:** AI procedural code = 220 lines, 2 critical bugs. Rules = 5 lines, 0 bugs. Details in "Why the Rules Engine is a Correctness Guarantee" section below.
+
+**You're not choosing between vibe speed and data integrity. You get both.**
+
+---
+
+### "Am I locked in?" (Vendor Lock-in)
+
+**No.** Here's why:
+
+**Your database is untouched:**
+- No special schema requirements
+- No vendor-specific tables or columns
+- Works with standard SQLAlchemy databases (PostgreSQL, MySQL, SQLite, Oracle, SQL Server)
+- Your data stays portable
+
+**Standard technology stack:**
+- Python code you can read and edit
+- SQLAlchemy ORM (industry standard)
+- Flask web framework (standard)
+- No proprietary language or runtime
+
+**Rules are just Python:**
+```python
+Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total,
+         where=lambda row: row.date_shipped is None)
+```
+This is readable code you can maintain. Not compiled. Not encrypted. Not hidden.
+
+**Open source (free forever):**
+- Apache 2.0 license
+- No runtime fees
+- No enterprise edition paywall
+- Source code on GitHub: https://github.com/ApiLogicServer
+
+**Exit path exists:**
+If you decide rules aren't for you, you can:
+1. Stop using LogicBank, write procedural code instead
+2. Keep your database, models, and API
+3. No migration required - just remove the rules
+4. Your data is never locked in
+
+**Can coexist with existing code:**
+- Add LogicBank to existing Flask app
+- Use rules for new features, keep existing procedural code
+- Migrate incrementally (or not at all)
+
+**Bottom line:** You're adopting an architecture pattern, not signing a vendor contract.
+
+---
+
+### "How does business collaboration work?"
+
+**You work in your IDE** (VS Code, standard Python workflow).
+
+**Business users can optionally explore ideas in WebGenAI** (browser-based prototyping):
+- Creates working backend (API, data, business logic) from natural language
+- Exports to standard Python projects you can enhance
+- **Your role:** Take exported code, add production features (advanced logic, security, deployment)
+
+**Why this matters:**
+- Business stops needing "dev time for prototypes"
+- You receive exportable Python (not proprietary platform code)
+- Standard deployment (containers, your tools)
+
+**Foundation for any frontend:** The backend we generate works with vibe UIs, low-code tools, custom React apps - whatever you choose. We provide the data layer with business rules governance - you pick the UI technology.
+
+---
+
+### "Is this production-ready?" (Battle-Tested)
+
+**Yes. 45 years of production use.**
+
+**The history:**
+- **1979:** Invented in Boston (same time as VisiCalc)
+- **Wang Pace:** 7,500 production deployments
+- **Versata:** $3B startup backed by Microsoft/SAP/Informix/Ingres founders
+- **2025:** Reborn as GenAI Logic for the agentic AI era
+
+**This isn't a new framework. It's a proven architecture refined over decades.**
+
+**Production evidence:**
+- Deployed at enterprise scale (Fortune 500s)
+- Handles millions of transactions
+- 45 years of edge cases discovered and fixed
+- Battle-tested patterns you can't get from fresh development
+
+**What this means for you:**
+- You're not a beta tester
+- The gotchas have been found (and fixed)
+- The patterns are proven at scale
+- The architecture has survived 4 decades of technology shifts
+
+**Current adoption:**
+- 1M+ downloads (yes, many are bots, but real usage too)
+- Open source community
+- Active development
+- Production deployments across industries
+
+**Comparison:**
+- VisiCalc (1979) proved declarative worked for spreadsheets
+- We proved declarative worked for transactions
+- Both are still around because the architecture is sound
+
+**Risk assessment:**
+- Technical risk: Low (proven architecture, standard tech stack)
+- Vendor risk: Low (open source, can fork if needed)
+- Team risk: Medium (learning curve exists, but documented)
+- Migration risk: Low (can coexist with existing code)
+
+**Bottom line:** This isn't experimental. It's established technology adapted for modern AI.
+
+---
+
+### "What CAN'T it do?" (Limitations)
+
+**Honest answer: Rules are designed for business logic, not everything.**
+
+**Don't use rules for:**
+
+1. **Complex algorithms**
+   - Machine learning models
+   - Graph traversal algorithms
+   - Optimization problems (traveling salesman, etc.)
+   - Statistical computations
+   - **Why:** These aren't data relationship problems. Use Python.
+
+2. **Read-only queries and reports**
+   - Analytics dashboards
+   - Complex JOINs for reporting
+   - Data warehouse queries
+   - **Why:** Rules enforce writes, not reads. Use SQL views, BI tools, or query optimization.
+
+3. **One-off scripts**
+   - Data migrations
+   - Batch data cleanup
+   - Import/export utilities
+   - **Why:** Rules overhead isn't worth it for run-once code. Use plain Python.
+
+4. **Custom UI Backend (PRIMARY USE CASE)**
+   - ✅ **Perfect fit:** Building React/Vue/custom UI? Get production API in 5 seconds
+   - ✅ **Instant features:** Filtering, pagination, sorting, optimistic locking, security/RBAC
+   - ✅ **Parallel development:** Frontend starts immediately with REAL API (not toy mocks)
+   - ✅ **Logic optional:** Start with simple CRUD, add business rules IF/WHEN complexity emerges
+   - ✅ **No overhead:** Rules engine checks dependencies, finds none, commits - essentially transparent
+   - **Why this matters:** Traditional approach = 2-4 weeks for backend (frontend blocked). Mock APIs lack enterprise features. GenAI-Logic = backend ready instantly, logic partitioned out enables parallel work.
+   - **Reality check:** "Simple CRUD" systems evolve. Today's "save note" becomes "audit changes" or "validate against preferences." Starting with the framework means zero refactoring when requirements grow.
+
+5. **Workflow orchestration (BUT: ideal for nodes within workflows)**
+   - ❌ **Not a workflow engine:** Can't do multi-step approval processes, long-running sagas, external system coordination
+   - ✅ **Perfect for workflow nodes:** Ideal data layer WITHIN each workflow step
+   - **Why:** Workflows orchestrate STEPS ("do these in order"). GenAI-Logic ensures DATA CORRECTNESS within each step.
+   - **Example:** Order approval workflow:
+     - Node 1: Create draft order ← **GenAI-Logic ensures totals, credit check**
+     - Node 2: Send approval email ← Pure workflow
+     - Node 3: Wait for response ← Pure workflow
+     - Node 4: If approved, ship ← **GenAI-Logic updates balances, inventory**
+   - **Use together:** Temporal/Airflow for process orchestration, GenAI-Logic for data operations within nodes
+
+6. **Real-time streaming**
+   - High-frequency trading
+   - IoT sensor processing
+   - Log aggregation
+   - **Why:** Transaction-based commit is wrong model. Use stream processors (Kafka, Flink).
+
+**Rules ARE designed for:**
+- ✅ Data dependency graphs (X affects Y affects Z)
+- ✅ Multi-table calculations and rollups
+- ✅ Business constraints and validations
+- ✅ Ensuring correctness across multiple change paths
+- ✅ Enforcing invariants at transaction commit
+
+**Architecture fit:**
+- Rules sit at the **commit control point**
+- They enforce **what may persist**, not how to orchestrate
+- Think: "guardrails for data integrity" not "workflow engine"
+
+**The test:**
+If you can express it as "this data relationship is always true," use rules.
+If it's "do these steps in this order," use procedural code.
+
+**Example:**
+- ✅ "Customer balance is always sum of unshipped orders" → Rule
+- ❌ "Send email, wait 3 days, send reminder" → Workflow (not a rule)
+
+**Can you mix?**
+Yes. Use rules for invariants, use Python/workflow engines for orchestration.
+They complement each other.
+
+**Bottom line:** Rules solve correctness for business logic (data relationships).
+They're not a general-purpose programming replacement.
+
+---
+
 ## Detailed Service Documentation
 
 The sections below provide complete details on each service. I'll reference these as needed when we work together.
@@ -168,8 +481,21 @@ python api_logic_server_run.py
 - If server fails to start after model changes, check that alembic migrations have been applied
 
 ### Adding Business Logic
-`docs/training` explains how to translate Natural Language logic into LogicBank (Python) rules like:
 
+**For Human Learning:**
+- **Primary Resource:** https://apilogicserver.github.io/Docs/Logic/
+  - Complete rule type reference tables
+  - Pattern tables and best practices
+  - Video tutorials and examples
+  - Learning path recommendations
+- Use this as your main learning resource for understanding rules
+
+**For AI Code Generation:**
+- `docs/training/*.prompt` files contain patterns for AI assistants
+- AI reads these BEFORE implementing logic
+- Not intended as primary human learning materials
+
+**Rule Example:**
 ```python
 # Edit: logic/declare_logic.py
 Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal)
@@ -202,19 +528,31 @@ See `docs/training/README.md` for complete organization rules.
 ```
 STOP ✋
 
-READ ALL TRAINING FILES IN ORDER (every single time):
+WHEN USER PROVIDES A LOGIC PROMPT:
+
+STEP 1: Read these files (DO THIS FIRST - NOT OPTIONAL):
+   1. docs/training/logic_bank_patterns.prompt           (Foundation - READ FIRST)
+   2. docs/training/logic_bank_api.prompt                (Deterministic rules - READ SECOND)
+   3. docs/training/probabilistic_logic.prompt           (AI/Probabilistic rules - READ THIRD)
+
+STEP 2: Parse the prompt following logic_bank_api.prompt instructions:
+   - Identify context phrase ("When X", "For Y", "On Z") → creates directory
+   - Identify colon-terminated use cases → creates files
+   - Follow directory structure rules EXACTLY as specified
 
-1. docs/training/logic_bank_patterns.prompt           (Foundation - ALWAYS READ FIRST)
-2. docs/training/logic_bank_api.prompt                (Deterministic rules - ALWAYS READ SECOND)
-3. docs/training/probabilistic_logic.prompt           (AI/Probabilistic rules - ALWAYS READ THIRD)
+STEP 3: Create the directory structure and files as instructed
 
-⚠️ CRITICAL REQUIREMENTS:
-   - DO NOT skip any files, even if you think you know the pattern
-   - DO NOT selectively read based on keywords in the user's request
-   - READ ALL THREE FILES IN SEQUENCE before writing any code
-   - These files contain failure patterns and correct implementations learned from production use
+STEP 4: Implement the rules following the training patterns
 
-THEN (and only then) implement the logic.
+⚠️ CRITICAL - NO EXCEPTIONS:
+   - You MUST read all three training files before implementing
+   - You MUST follow the directory structure rules in logic_bank_api.prompt
+   - You MUST NOT create flat files when context phrase is present
+   - DO NOT skip files even if you think you know the pattern
+   - These files contain failure patterns learned from production use
+
+FAILURE MODE: Creating flat files in logic/logic_discovery/ when prompt has context phrase
+CORRECT: Create logic/logic_discovery/<context_dir>/{__init__.py, use_case_files.py}
 ```
 
 **Training File Contents:**
@@ -252,20 +590,42 @@ Use case: App Integration
     1. Send Order to Kafka when date_shipped changes to non-null
 ```
 
+**How the Rules Engine Works:**
+
+**1. Authoring (AI-assisted, human-reviewed)**
+- You express business intent in natural language (via Copilot or any AI assistant)
+- The AI translates intent into a declarative DSL, under human review
+- Distills path-dependent logic into data-bound rules (table invariants) for automatic re-use
+- Resolves ambiguity using schema and relationships (e.g., copy vs reference)
+- Produces readable rules developers can inspect, edit, debug and version
+
+*This is where AI helps — authoring, not execution.*
+
+**2. Engine Initialization (Deterministic analysis)**
+- On startup, the non-RETE rule engine loads all rules
+- It computes dependencies deterministically from Rule types (derivations, constraints, actions)
+- Execution order is derived once, not from code paths
+
+No compilation. No dependencies-from-pattern-matching. No inference from runtime behavior.
+
+**3. Runtime Enforcement (Commit-time)**
+- Rules execute at transaction commit via SQLAlchemy commit events
+- All writes — APIs, workflows, UIs, agents — pass through the same rule set
+- Dependencies are already known; execution is deterministic and efficient
+- **No rule is "called." No path can bypass enforcement.**
+- Non-RETE optimizations: pruning, adjustment logic, delta-based aggregations
+- **Cascading via old_row tracking** - When Order.customer_id changes, adjusts BOTH old and new Customer.balance
+
+**The Key Developer Insight:**
+
+You declare invariants on data. You don't wire rules into flows. Invocation is automatic, on commit. The engine enforces them — everywhere, automatically, at commit.
+
 **Why Declarative Rules Matter:**
 
-For developers: Business logic is **typically half the system** in data-centric applications. The real pain with procedural code isn't just volume (200+ lines vs 5 rules) - it's **maintenance**:
-- **Finding insertion points** - you must analyze existing code to figure out where new logic goes
+LogicBank provides **44X code reduction** (5 lines vs 220+ procedural) with:
 - **Automatic ordering** - add rules anywhere that makes sense, confident they'll run in the right order
 - **Understanding intent** - you see WHAT it does (business rules) vs HOW (procedural steps)
-
-With declarative rules, you simply state business requirements. The engine handles dependencies, ordering, and optimization automatically.
-
-LogicBank provides **44X code reduction** (5 lines vs 220+ procedural) with automatic:
-- **Dependency tracking** - listens to SQLAlchemy ORM events at attribute level
-- **Cascading updates** - when Order.customer_id changes, adjusts BOTH old and new Customer.balance
-- **Transitive dependencies** - Item.quantity change cascades through Item.amount → Order.amount_total → Customer.balance
-- **Optimized execution** - uses deltas, not re-aggregation; automatic pruning
+- **Maintenance** - no need to find insertion points or trace execution paths
 
 **Why the Rules Engine is a Correctness Guarantee:**
 
@@ -273,29 +633,17 @@ The "2 critical bugs" that even AI-generated procedural code missed:
 1. **Changing Order.customer_id** - procedural code failed to adjust BOTH the old and new customer balances
 2. **Changing Item.product_id** - procedural code failed to re-copy the unit_price from the new product
 
-These bugs illustrate why declarative rules are **mandatory, not optional**:
-
-**Dependency Chains:** In the logic above, `Customer.balance` has transitive dependencies:
-- Direct: `Order.amount_total`, `Order.date_shipped`
-- Through Order: `Item.amount` (affects Order.amount_total)
-- Through Item: `Item.quantity`, `Item.unit_price` (affect Item.amount)
-- Through Product: `Product.unit_price` (copied to Item.unit_price)
-
-**Automatic Completeness:** The declarative rules engine:
-- Listens to **SQLAlchemy ORM events** at the attribute level
-- When `Order.customer_id` changes, **automatically adjusts both old and new customer balances**
-- When `Item.product_id` changes, **automatically re-copies from the new product**
-- Uses **dependency ordering** to fire rules in correct sequence
-- Applies **optimized chaining** (uses deltas, not re-aggregation)
-
-**Why Procedural Code Fails:** Even AI-generated procedural code requires explicit handlers for EVERY possible change path. It's easy to miss:
+These bugs illustrate why declarative rules are **mandatory, not optional**. Even AI-generated procedural code requires explicit handlers for EVERY possible change path. It's easy to miss:
 - Foreign key changes affecting multiple parents
 - Transitive dependencies through multiple tables
 - Where clause conditions that include/exclude rows
 
 The rules engine eliminates this entire class of bugs by automatically handling all change paths.
 
-See `logic/declarative-vs-procedural-comparison.md` for complete analysis.
+**The Complete A/B Test:**
+
+For the full experiment comparing declarative rules vs AI-generated procedural code, including the 2 bugs Copilot missed and the AI's own analysis of why it failed, see:
+https://github.com/ApiLogicServer/ApiLogicServer-src/blob/main/api_logic_server_cli/prototypes/basic_demo/logic/procedural/declarative-vs-procedural-comparison.md
 
 ### Discovery Systems
 
@@ -332,7 +680,7 @@ def declare_logic():
 
 **PATTERN RECOGNITION for Business Logic**:
 When users provide natural language with multiple use cases like:
-- "Use case: Check Credit" + "Use case: App Integration"
+- "on Placing Orders, Check Credit" + "Use case: App Integration"
 
 **ALWAYS create separate files**:
 - `logic/logic_discovery/check_credit.py` - for credit checking rules

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/.github/welcome.md

@@ -0,0 +1,40 @@
+---
+use: welcome for basic_demo - please start the tour
+instuctions: copy api_logic_server_cli/prototypes/base/.github/.copilot-instructions.md, then paste as the Welcome section 
+---
+
+## Welcome to the `basic_demo` project
+
+This is a complete, working microservice auto-generated from a database schema - **uncustomized**, so you can see what to expect when you create projects from your own databases.
+
+Created from database schema introspection:
+- **Admin Web Application** - Live at `http://localhost:5656`
+- **REST API Endpoints** - All database tables exposed at MCP discoverable `/api/*`
+- **Database Models** - Complete SQLAlchemy ORM in `database/models.py`
+- **Authentication System** - JWT-based auth framework
+- **Business Logic Engine** - Declarative rules system
+
+---
+
+**Ready to explore?** Just say me "guide me through" to begin the interactive tutorial
+
+* Brief exploration of what's already created
+* Customizing logic, security, and the API
+
+---
+
+**Or, self-demo?** Open `readme_ai_mcp.md` to explore logic, ai and mcp.
+
+<!-- 
+⚠️ AI INSTRUCTION: When user says "guide me" or similar tour activation phrase, you MUST:
+1. Read tutor.md COMPLETELY before responding
+2. Follow tutor.md choreography EXACTLY as written
+3. Act as TOUR GUIDE directing the experience (not passive assistant)
+4. Create manage_todo_list to track tour sections
+5. Do NOT freelance, improvise, or skip sections
+
+This is MANDATORY - the tutor.md represents weeks of refined choreography.
+Deviations break the carefully engineered learning experience.
+-->
+
+---

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/customizations/logic/declare_logic.py

@@ -38,7 +38,7 @@ def declare_logic():
         1. Using your IDE and code completion (Rule.)
 
         2. Use your AI Assistant and enter logic in Natural Language, e.g.:
-            Create Business Logic for Use Case = Check Credit:  
+            Create Business Logic for on Placing Orders, Check Credit:  
                 1. The Customer's balance is less than the credit limit
                 2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
                 3. The Order's amount_total is the sum of the Item amount

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/docs/system-creation-vibe.md

@@ -134,7 +134,7 @@ todo - diagram
 **2. Add Business Logic**
 
 ```bash title="Check Credit Logic (instead of 220 lines of code)"
-Use case: Check Credit    
+on Placing Orders, Check Credit    
     1. The Customer's balance is less than the credit limit
     2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
     3. The Order's amount_total is the sum of the Item amount

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/iteration/logic/declare_logic.py

@@ -38,7 +38,7 @@ def declare_logic():
         1. Using your IDE and code completion (Rule.)
 
         2. Use your AI Assistant and enter logic in Natural Language, e.g.:
-            Create Business Logic for Use Case = Check Credit:  
+            Create Business Logic for on Placing Orders, Check Credit:  
                 1. The Customer's balance is less than the credit limit
                 2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
                 3. The Order's amount_total is the sum of the Item amount

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/logic/logic_discovery/{check_credit.py → place_order/check_credit.py}

@@ -16,12 +16,12 @@ def declare_logic():
         1. To view the AI procedural/declarative comparison, [click here](https://github.com/ApiLogicServer/ApiLogicServer-src/blob/main/api_logic_server_cli/prototypes/basic_demo/logic/procedural/declarative-vs-procedural-comparison.md)
         2. Consider a 100 table system: 1,000 rules vs. 40,000 lines of code
     
-    Natural Language Requirements:
+    On Placing Orders, Check Credit:
     1. The Customer's balance is less than the credit limit
     2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
     3. The Order's amount_total is the sum of the Item amount
     4. The Item amount is the quantity * unit_price
-    5. The Item unit_price is copied from the Product unit_price
+    5. The Item unit_price is from the Product unit_price
     """
     
     Rule.constraint(validate=models.Customer, as_condition=lambda row: row.balance <= row.credit_limit, error_msg="Customer balance exceeds credit limit")                    

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/readme_ai_mcp.md

@@ -81,7 +81,7 @@ Copilot reads the MCP schema and responds to a natural-language instruction such
 
 **Step 2: Declare Logic:**
 ```bash title='Step 2: Declare Logic'
-Use case: Check Credit    
+on Placing Orders, Check Credit    
     1. The Customer's balance is less than the credit limit
     2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
     3. The Order's amount_total is the sum of the Item amount
@@ -335,7 +335,7 @@ Different kinds of logic naturally call for different tools, as in this unified
 
 **Declare Logic: Deterministic and Probabilistic:**
 ```bash title='Declare Logic: Deterministic and Probabilistic'
-Use case: Check Credit:
+on Placing Orders, Check Credit:
 
 1. The Customer's balance is less than the credit limit
 2. The Customer's balance is the sum of the Order amount_total where date_shipped is null

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/readme_vibe.md

@@ -75,7 +75,7 @@ Create a system with customers, orders, items and products.
 
 Include a notes field for orders.
 
-Use case: Check Credit    
+on Placing Orders, Check Credit    
     1. The Customer's balance is less than the credit limit
     2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
     3. The Order's amount_total is the sum of the Item amount

api_logic_server_cli/prototypes/manager/samples/prompts/genai_demo.prompt

@@ -2,7 +2,7 @@ Create a system with customers, orders, items and products.
 
 Include a notes field for orders.
 
-Use case: Check Credit    
+on Placing Orders, Check Credit    
     1. The Customer's balance is less than the credit limit
     2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
     3. The Order's amount_total is the sum of the Item amount