Add EF Core temporal tables demo (Demo 2)

Build EFCoreDemoFast .NET 8 console app demonstrating EF Core 8
temporal table support against Azure SQL:
- TemporalContext with IsTemporal() configuration
- EF migration generating temporal table + history table
- Program.cs with all 5 temporal LINQ extensions
- TemporalAll, TemporalAsOf, TemporalBetween, TemporalFromTo, TemporalContainedIn
- Uses TemporalEFDemo database (same server as Demo 1)
- Biff-approved ✅

Also: Terraform adds TemporalEFDemo database resource

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: chadgreen

.squad/agents/biff/history.md

@@ -68,3 +68,23 @@
 **Key Insight:** Doc's fixes were **surgical and precise** — they changed only what was broken, didn't refactor unnecessarily. Every fix matched my recommended solution exactly. This is ideal remediation.
 
 **Process Win:** The coordinator clarified that the Employee domain choice was actually Doc's decision as team lead, not a rogue deviation by Marty. This saved needless refactoring back to Product Pricing. Good escalation practice.
+
+### 2026-03-02: EFCoreDemoFast Review — APPROVED ✅
+
+**What I Reviewed:** Jennifer's .NET 8 EF Core demo project (`Demos/EFCoreDemoFast`) for correctness, demo quality, and readiness.
+
+**Review Verdict:** ✅ **APPROVED** — High-quality, correct, demo-ready.
+
+**Key Findings:**
+- ✅ **Correctness:** Temporal configuration (`IsTemporal()`) correctly maps to migration and history table
+- ✅ **Idempotency:** `ExecuteDeleteAsync()` + `MigrateAsync()` ensure repeatable runs
+- ✅ **Timing:** seedTime captured after SaveChangesAsync; 3-second delay ensures safe TemporalAsOf query window
+- ✅ **Temporal Queries:** All 5 extensions (TemporalAll, TemporalAsOf, TemporalBetween, TemporalFromTo, TemporalContainedIn) correctly implemented
+- ✅ **Demo Quality:** Console output formatting is audience-friendly; code comments link EF Core LINQ to Demo 1's T-SQL equivalents; runtime ~7–10 seconds
+- ✅ **Configuration:** Targets .NET 8; EF Core 8 SQL Server package correct; secrets properly gitignored with appsettings.example.json template
+
+**Minor Suggestion (Non-Blocking):** TemporalBetween and TemporalFromTo may return identical results due to "safe" timestamp boundaries outside transaction windows. Acceptable for the demo—showcasing both API methods is valuable for audience.
+
+**Status:** Ready for Chad to present.
+
+**Process Note:** This demo demonstrates excellent complementarity with Demo 1 (SQL)—same Employee domain narrative, both leverage Azure SQL temporal tables, all query patterns mapped between T-SQL and EF Core LINQ.

.squad/agents/jennifer/history.md

@@ -31,3 +31,49 @@ modelBuilder.Entity<MyEntity>().ToTable("MyTable", t => t.IsTemporal());
 - Supports: creating tables via migrations, converting existing tables, querying history, restoring data
 
 ## Learnings
+
+## EFCoreDemoFast — Completed
+
+**Date:** 2026-03-02  
+**Status:** ✅ Built and compiles successfully
+
+### Key File Paths
+- `Demos/EFCoreDemoFast/EFCoreDemoFast.csproj` — .NET 8 console app, EF Core 8 SQL Server
+- `Demos/EFCoreDemoFast/Program.cs` — main demo flow with all 5 temporal queries
+- `Demos/EFCoreDemoFast/Models/Employee.cs` — POCO, no period columns
+- `Demos/EFCoreDemoFast/Data/TemporalContext.cs` — DbContext with `IsTemporal()` config
+- `Demos/EFCoreDemoFast/Migrations/20240101000000_InitialCreate.cs` — temporal migration
+- `Demos/EFCoreDemoFast/Migrations/TemporalContextModelSnapshot.cs` — EF model snapshot
+- `Demos/EFCoreDemoFast/appsettings.json` — gitignored, holds real connection string
+- `Demos/EFCoreDemoFast/appsettings.example.json` — safe placeholder for source control
+- `Demos/EFCoreDemoFast/README.md` — presenter notes with 2-minute script
+
+### Architecture Decisions
+1. **No period columns on POCO** — EF manages PeriodStart/PeriodEnd as shadow properties; `EF.Property<DateTime>(e, "PeriodStart")` used in projections
+2. **C# DateTime capture** — seedTime and afterChanges captured as C# variables, not hardcoded SQL timestamps; demonstrates natural C# developer workflow
+3. **TemporalAsOf no-projection rule** — EF Core limitation: period columns not available in TemporalAsOf projections; only entity properties selected
+4. **Manual migration file** — used fake timestamp `20240101000000` in filename; valid for EF migration ordering
+5. **IsTemporal() fluent config** — single line in OnModelCreating; history table name defaults to `EmployeesHistory`
+6. **MigrateAsync() at startup** — idempotent, allows `dotnet run` to self-setup
+7. **ExecuteDeleteAsync() before seed** — ensures idempotent demo runs
+
+### Patterns Used
+- `entity.ToTable(tb => tb.IsTemporal())` — temporal table marker
+- `EF.Property<DateTime>(e, "PeriodStart")` — shadow property access in LINQ
+- `context.Employees.TemporalAll() / TemporalAsOf() / TemporalBetween() / TemporalFromTo() / TemporalContainedIn()` — all 5 temporal extensions demonstrated
+- `await context.Database.MigrateAsync()` — apply migrations at startup
+
+## EFCoreDemoFast — Biff Review Result
+
+**Date:** 2026-03-02  
+**Reviewer:** Biff  
+**Status:** ✅ APPROVED
+
+### Approval Feedback
+- Temporal configuration and migration are correct
+- Idempotency and timing logic are sound
+- All 5 temporal LINQ extensions correctly demonstrate Azure SQL temporal table support
+- Demo quality suitable for 8-minute conference presentation
+- Code comments effectively bridge EF Core to Demo 1's T-SQL patterns
+
+**Next Step:** Ready for Chad's presentation—Demo 2 (EF Core temporal) complements Demo 1 (SQL temporal) with identical Employee narrative across both platforms.

.squad/agents/marty/history.md

@@ -111,3 +111,23 @@ Create a focused SSMS demo that:
 - **Comments matter in live demos**: These aren't just code comments, they're presenter notes and audience reading material
 
 **Decisions Written To:** `.squad/decisions/inbox/marty-sqldemofast-decisions.md`
+
+## TemporalEFDemo Database Resource — Terraform Update
+
+**Date:** 2026-03-02  
+**Task:** Add TemporalEFDemo database to Terraform for Demo 2 (EF Core)
+
+### Changes Made
+- **main.tf:** Added `azurerm_mssql_database` resource for TemporalEFDemo
+  - Same Azure SQL Server as TemporalSQLDemo (Demo 1)
+  - Consistent SKU and configuration
+  - Follows naming and variable conventions
+- **outputs.tf:** Added `temporal_ef_demo_db_name` and `temporal_ef_demo_connection_string` outputs
+
+### Verification
+✅ Terraform configuration valid  
+✅ Database resource correctly integrated with existing server infrastructure  
+✅ Connection strings available for Jennifer's EF Core app configuration
+
+### Architecture Note
+Same-server strategy confirmed by Chad—both Demo 1 (SQL) and Demo 2 (EF Core) run independently on single Azure SQL server with separate databases (TemporalSQLDemo and TemporalEFDemo).

.squad/agents/scribe/history.md

@@ -4,4 +4,27 @@
 **Project:** Time Travelling Data — 20-minute conference presentation on SQL Server temporal tables
 **User:** Chad Green
 
+## Session: EF Core Demo Build (2026-03-02)
+
+**Team:** Jennifer (EF Core dev) + Marty (Infrastructure) + Biff (Reviewer)
+
+### Orchestration Summary
+1. **Jennifer:** Built EFCoreDemoFast .NET 8 console app with all 5 temporal LINQ extensions
+2. **Marty:** Added TemporalEFDemo database resource to Terraform (same server as Demo 1)
+3. **Biff:** Reviewed and approved EFCoreDemoFast—high quality, demo-ready
+4. **Scribe:** Wrote orchestration logs, session log, merged inbox decisions to decisions.md, updated agent history files
+
+### Key Decisions Documented
+- **Database Structure:** TemporalEFDemo separate from TemporalSQLDemo, same Azure SQL server
+- **Domain Consistency:** Employee narrative identical to Demo 1 (Alice, Bob, Carol, David)
+- **Temporal Extensions:** All 5 LINQ methods implemented with T-SQL equivalents in comments
+- **DateTime Handling:** C# variables (seedTime, afterChanges) captured at runtime; no hardcoded timestamps
+- **Architecture:** Shadow properties for period columns; POCO remains minimal
+
+### Status
+✅ Demo 2 approved and ready for Chad's presentation  
+✅ All team updates documented in agent history files  
+✅ Decisions merged and deduplicated  
+✅ Ready for git commit
+
 ## Learnings

.squad/decisions.md

@@ -1752,3 +1752,82 @@ ValidTo   DATETIME2 GENERATED ALWAYS AS ROW END   HIDDEN NOT NULL,
 ---
 
 
+
+
+---
+
+# Decision: EF Core Demo Structure
+
+**Author:** Jennifer  
+**Date:** 2026-03-02  
+**Status:** Proposed
+
+## Context
+
+Demo 2 (EFCoreDemoFast) needed an EF Core 8 project showing temporal table support for the "Time Travelling Data" 20-minute conference presentation.
+
+## Decisions Made
+
+### 1. Database: TemporalEFDemo (separate from Demo 1)
+Demo 2 uses a **different database** (`TemporalEFDemo`) on the same Azure SQL server as Demo 1 (`TemporalSQLDemo`). No cross-dependency between demos. Each demo is fully self-contained.
+
+### 2. Employee Domain — consistent with Demo 1
+Carried over Alice Hart, Bob Chen, Carol Reyes, David Kim with the same starting salaries and titles. Demo narrative is identical (Alice promoted, David terminated) so the audience sees the same story told in two different ways.
+
+### 3. C# DateTime capture (no hardcoded timestamps)
+Rather than hardcoding SQL timestamps like Demo 1 does for T-SQL demos, Demo 2 captures `DateTime seedTime` and `DateTime afterChanges` as C# variables during execution. This shows the natural C# developer workflow and avoids the "magic strings" problem in live demos.
+
+### 4. All 5 temporal LINQ extensions demonstrated
+- `TemporalAll()` → `FOR SYSTEM_TIME ALL`
+- `TemporalAsOf()` → `FOR SYSTEM_TIME AS OF`
+- `TemporalBetween()` → `FOR SYSTEM_TIME BETWEEN`
+- `TemporalFromTo()` → `FOR SYSTEM_TIME FROM ... TO`
+- `TemporalContainedIn()` → `FOR SYSTEM_TIME CONTAINED IN`
+
+Each LINQ call maps to its T-SQL equivalent (shown in comments) to bridge the two demos for the audience.
+
+### 5. No period columns on POCO
+PeriodStart/PeriodEnd are EF shadow properties only. The Employee POCO is intentionally minimal — demonstrates that temporal behavior is infrastructure, not domain model concern.
+
+### 6. Migration hand-crafted with fake timestamp
+The migration file uses `20240101000000` as a timestamp. This is fine — it just needs to be a valid date string for EF ordering. This avoids requiring `dotnet ef migrations add` at setup time.
+
+### 7. appsettings.json gitignored
+Connection string lives in `appsettings.json` (gitignored). `appsettings.example.json` committed with placeholder values. Presenter updates `appsettings.json` before the demo.
+
+
+---
+
+# Biff's Review of EF Core Demo (Demo 2)
+
+## Review Verdict: APPROVED ✅
+
+I have thoroughly reviewed the EF Core demo project (`Demos/EFCoreDemoFast`) and found it to be high-quality, correct, and demo-ready.
+
+### 1. Correctness & Logic
+- **Temporal Configuration:** The `IsTemporal()` configuration in `TemporalContext.cs` correctly maps to the `20240101000000_InitialCreate.cs` migration. The history table `EmployeesHistory` is correctly defined.
+- **Idempotency:** `ExecuteDeleteAsync()` at the start of `Program.cs` ensures the demo can be run repeatedly without duplicating data. `MigrateAsync()` ensures the database is created.
+- **Seeding & Timing:**
+    - `seedTime` is captured *after* `SaveChangesAsync()`, ensuring the seeded rows have `PeriodStart` timestamps <= `seedTime`.
+    - The 3-second delay (`Task.Delay(3000)`) provides a safe buffer ensuring `seedTime.AddSeconds(1)` falls strictly between the seed transaction and the update transaction.
+    - `afterChanges` is captured correctly after the second transaction.
+
+### 2. Temporal Query Validation
+- **TemporalAsOf:** `TemporalAsOf(seedTime.AddSeconds(1))` will correctly return all 4 original employees (Alice, Bob, Carol, David). The query time (T_seed + 1s) is guaranteed to be before the updates (T_seed + 3s). The expected output in README correctly shows all 4.
+- **TemporalContainedIn:** David's row is created at T_seed and deleted at T_update. The query window `(seedTime - 1s, afterChanges + 1s)` fully encompasses David's valid period `[T_seed, T_update)`. This is correct.
+- **TemporalBetween vs FromTo:** The distinction is subtle but the code uses them correctly. Given the timestamps are derived from execution time, the results will likely be identical in this specific run, but showcasing both API methods is valuable for the audience.
+
+### 3. Demo Quality
+- **Readability:** The console output (using `Console.WriteLine` with table formatting) is excellent and audience-friendly.
+- **Code Clarity:** The comments in `Program.cs` effectively link the EF Core LINQ methods to their T-SQL counterparts from Demo 1 (e.g., `// LINQ: ...TemporalAll()`, `// T-SQL: ...FOR SYSTEM_TIME ALL`).
+- **Timing:** The demo is concise. Migration check (~1s) + Seed (~1s) + Wait (3s) + Update (~1s) + Queries (~1s) = ~7-10 seconds runtime. The 2-minute script estimate allows ample time for the speaker to explain the code.
+
+### 4. Configuration
+- **Project File:** Correctly targets .NET 8 and uses `Microsoft.EntityFrameworkCore.SqlServer` 8.0.0.
+- **Secrets:** `appsettings.json` is correctly in `.gitignore`. `appsettings.example.json` provides a safe template.
+
+### Minor Suggestion (Non-Blocking)
+- The `TemporalBetween` and `TemporalFromTo` queries might return identical results in this specific scenario because the start/end points are "safe" timestamps outside the transaction boundaries. This is acceptable for the demo as it proves the API works, even if it doesn't highlight the edge-case boundary differences (which are hard to demo reliably with live execution timing).
+
+**Ready for Chad to present.**
+

.squad/orchestration-log/2026-03-02T02_14_55Z-biff.md

@@ -0,0 +1,39 @@
+# Orchestration — Biff
+
+**Session:** 2026-03-02T02:14:55Z  
+**Agent:** Biff  
+**Status:** Complete ✅
+
+## Mission
+Review EFCoreDemoFast .NET 8 console app for correctness, demo quality, and readiness.
+
+## Review Verdict
+**APPROVED ✅** — High-quality, correct, demo-ready.
+
+## Key Findings
+
+### Correctness & Logic
+- ✅ Temporal configuration (IsTemporal()) correctly maps to migration and history table
+- ✅ Idempotency: ExecuteDeleteAsync() + MigrateAsync() ensure repeatable runs
+- ✅ Seeding & timing: seedTime captured after SaveChangesAsync; 3-second delay ensures TemporalAsOf window is safe
+- ✅ afterChanges captured correctly after second transaction
+
+### Temporal Query Validation
+- ✅ TemporalAsOf(seedTime.AddSeconds(1)) returns all 4 original employees (before updates)
+- ✅ TemporalContainedIn correctly spans David's entire valid period
+- ✅ TemporalBetween vs FromTo both correctly implemented (may return identical results in this scenario, which is acceptable)
+
+### Demo Quality
+- ✅ Console output formatting is audience-friendly
+- ✅ Code comments effectively link EF Core LINQ to T-SQL equivalents from Demo 1
+- ✅ Runtime: ~7–10 seconds + ample time for speaker explanation
+
+### Configuration
+- ✅ Project targets .NET 8 with correct EF Core package versions
+- ✅ Secrets: appsettings.json gitignored, appsettings.example.json provided
+
+## Minor Suggestion (Non-Blocking)
+TemporalBetween and TemporalFromTo may return identical results due to "safe" timestamp boundaries outside transaction windows. Acceptable for the demo.
+
+## Status
+**Ready for Chad to present.**

.squad/orchestration-log/2026-03-02T02_14_55Z-jennifer.md

@@ -0,0 +1,33 @@
+# Orchestration — Jennifer
+
+**Session:** 2026-03-02T02:14:55Z  
+**Agent:** Jennifer  
+**Status:** Complete ✅
+
+## Mission
+Build EFCoreDemoFast .NET 8 console app demonstrating EF Core 8 temporal table support against Azure SQL.
+
+## Deliverables
+- `Demos/EFCoreDemoFast/` — Complete .NET 8 console application
+  - `EFCoreDemoFast.csproj` — project file
+  - `Program.cs` — main flow with all 5 temporal LINQ extensions
+  - `Models/Employee.cs` — domain model (POCO, no period columns)
+  - `Data/TemporalContext.cs` — DbContext with `IsTemporal()` configuration
+  - `Migrations/20240101000000_InitialCreate.cs` — temporal table migration
+  - `appsettings.json` — gitignored connection string
+  - `appsettings.example.json` — template for source control
+  - `README.md` — 2-minute presenter script and notes
+
+## Key Decisions
+1. **Database:** TemporalEFDemo (separate from Demo 1, same Azure SQL server)
+2. **Domain:** Employee (Alice Hart, Bob Chen, Carol Reyes, David Kim) — consistent with Demo 1 narrative
+3. **C# DateTime Capture:** seedTime and afterChanges captured as C# variables during execution; no hardcoded SQL timestamps
+4. **All 5 Temporal Extensions:** TemporalAll, TemporalAsOf, TemporalBetween, TemporalFromTo, TemporalContainedIn — each with T-SQL comment mapping
+5. **Shadow Properties:** PeriodStart/PeriodEnd managed by EF; POCO is intentionally minimal
+6. **Migration Timestamp:** Fake timestamp `20240101000000` in filename (valid for EF ordering)
+7. **Idempotency:** ExecuteDeleteAsync() before seed, MigrateAsync() at startup
+
+## Verification
+✅ Project compiles successfully  
+✅ All files created and structure correct  
+✅ Ready for Biff review

.squad/orchestration-log/2026-03-02T02_14_55Z-marty.md

@@ -0,0 +1,24 @@
+# Orchestration — Marty
+
+**Session:** 2026-03-02T02:14:55Z  
+**Agent:** Marty  
+**Status:** Complete ✅
+
+## Mission
+Add TemporalEFDemo database resource to Terraform configuration for Demo 2.
+
+## Deliverables
+- `Demos/SQLDemoFast/terraform/main.tf` — Updated with TemporalEFDemo database resource
+- `Demos/SQLDemoFast/terraform/outputs.tf` — Updated with TemporalEFDemo connection outputs
+
+## Changes Made
+1. **Database Resource:** Added `azurerm_mssql_database` for `TemporalEFDemo`
+   - Same Azure SQL Server as TemporalSQLDemo (Demo 1)
+   - Same SKU and configuration for consistency
+   - Follows naming convention and variable patterns
+2. **Outputs:** Added `temporal_ef_demo_db_name` and `temporal_ef_demo_connection_string`
+
+## Verification
+✅ Terraform configuration valid  
+✅ Database resource correctly integrated with existing server  
+✅ Connection string outputs available for Jennifer's connection setup

Demos/EFCoreDemoFast/.gitignore

@@ -0,0 +1,6 @@
+# appsettings.json contains your real connection string — never commit it
+appsettings.json
+
+# Build output
+bin/
+obj/

Demos/EFCoreDemoFast/Data/TemporalContext.cs

@@ -0,0 +1,36 @@
+using EFCoreDemoFast.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+
+namespace EFCoreDemoFast.Data;
+
+public class TemporalContext : DbContext
+{
+    public DbSet<Employee> Employees => Set<Employee>();
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        var config = new ConfigurationBuilder()
+            .AddJsonFile("appsettings.json", optional: false)
+            .AddEnvironmentVariables()
+            .Build();
+
+        optionsBuilder.UseSqlServer(config.GetConnectionString("DefaultConnection"));
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<Employee>(entity =>
+        {
+            entity.Property(e => e.Name).HasMaxLength(100);
+            entity.Property(e => e.Title).HasMaxLength(100);
+            entity.Property(e => e.Salary).HasColumnType("decimal(10,2)");
+            entity.Property(e => e.Department).HasMaxLength(100);
+
+            // ── This is the magic line ──────────────────────────────────────
+            // Tells EF Core to create this as a system-versioned temporal table.
+            // EF automatically creates the history table and period columns.
+            entity.ToTable(tb => tb.IsTemporal());
+        });
+    }
+}