aw-spec-cli 0.1.5 → 0.1.6

package/assets/docs/components/Email/ReferenceEndpoints/SendEmailEndpoint.cs

@@ -1,84 +0,0 @@
-using FastEndpoints;
-using Microsoft.Extensions.Configuration;
-using AppWeaver.Messaging.Email;
-
-// NOTE: This is a bundled SAMPLE endpoint for the AppWeaver Email component.
-// It lives under docs/ and is NOT compiled here. /aw-spec-addcomponent copies it into the
-// host project's ReferenceEndpoints/ folder and replaces the __HOSTPROJECT__ namespace token
-// with the host project's root namespace (e.g. AppWeaver.Health.Service).
-namespace __HOSTPROJECT__.ReferenceEndpoints;
-
-/// <summary>
-/// Sample reference endpoint for the AppWeaver Email component.
-///
-/// Demonstrates the full send sequence inline — it injects the <see cref="IEmailService"/>
-/// abstraction directly and calls <c>SendAsync</c> with the provider wired during DI
-/// registration (see the component's integration runbook). There is intentionally no
-/// command / command-handler / mediator: this is a copy-paste sample only.
-///
-/// The active transport is whatever <c>options.Provider</c> was set to when
-/// <c>AddEmailMessaging(...)</c> was registered. With the <c>File</c> provider the message is
-/// written to <c>Emails_&lt;yyyy-MM-dd&gt;.txt</c> in the application base directory.
-/// </summary>
-public class SendEmailEndpoint(IEmailService _email, IConfiguration _config)
-    : Endpoint<SendEmailRequest>
-{
-    public override void Configure()
-    {
-        Post("/reference/email/send");
-        AllowAnonymous();
-        Summary(s =>
-        {
-            s.Summary = "Send a sample email via the configured Email provider";
-            s.Description = "Reference endpoint for the AppWeaver Email component. Injects "
-                          + "IEmailService directly (no command/handler). 'from' falls back to "
-                          + "Messaging:Email:DefaultFrom when omitted.";
-        });
-        Options(o => o.WithTags("Reference - Email"));
-    }
-
-    public override async Task HandleAsync(SendEmailRequest req, CancellationToken ct)
-    {
-        if (string.IsNullOrWhiteSpace(req.To) || string.IsNullOrWhiteSpace(req.Subject))
-        {
-            HttpContext.Response.StatusCode = 400;
-            await HttpContext.Response.WriteAsJsonAsync(
-                new { error = "'to' and 'subject' are required." }, ct);
-            return;
-        }
-
-        // 'from' is optional in the request — fall back to the configured DefaultFrom.
-        var from = string.IsNullOrWhiteSpace(req.From)
-            ? _config["Messaging:Email:DefaultFrom"] ?? "no-reply@your-domain.com"
-            : req.From;
-
-        await _email.SendAsync(from, req.To, req.Subject, req.Body ?? string.Empty, req.IsHtml, ct);
-
-        await HttpContext.Response.WriteAsJsonAsync(new
-        {
-            status = "sent",
-            from,
-            to = req.To,
-            note = "With the File provider, output is written to Emails_<yyyy-MM-dd>.txt "
-                 + "in the app base directory."
-        }, ct);
-    }
-}
-
-public class SendEmailRequest
-{
-    /// <summary>Recipient address (required).</summary>
-    public string To { get; set; } = string.Empty;
-
-    /// <summary>Subject line (required).</summary>
-    public string Subject { get; set; } = string.Empty;
-
-    /// <summary>HTML or plain-text body.</summary>
-    public string Body { get; set; } = string.Empty;
-
-    /// <summary>Treat <see cref="Body"/> as HTML. Defaults to true.</summary>
-    public bool IsHtml { get; set; } = true;
-
-    /// <summary>Optional sender; falls back to Messaging:Email:DefaultFrom when omitted.</summary>
-    public string? From { get; set; }
-}

package/assets/docs/components/Email/integration.md

@@ -1,300 +0,0 @@
-# Email Component — Integration Workflow (agent playbook)
-
-> Pure technology (domain-agnostic). This file is an **agent runbook**: read it top-to-bottom and
-> execute the workflow in order. It drives an interactive integration of `IEmailService` into a
-> project, asking the user which transport implementation(s) to wire. Read [README.md](./README.md)
-> first for the contract. Replace `<SampleProjectName>` with the project name.
-> Commands: `/aw-spec-implement`.
-
----
-
-## Agent workflow — execute in order
-
-1. **Load context.** Read [README.md](./README.md) (contract + provider matrix) and this file.
-2. **Resolve the host project** `<HostProject>` (see [[folder-structure]], [[components-readme]] R0.2):
-   the single startup project that owns **`Program.cs`** + the ASP.NET Core web SDK —
-   `<SampleProjectName>.Service` (Vertical Slice foundation), `<SampleProjectName>.API` (Modular
-   Monolith foundation), or another name in a future template. **Find it by locating `Program.cs`, not
-   by assuming the name.** In these foundations application/domain/infrastructure code all live in this
-   one project (modules are folders); there is **no** separate `…Application` / `…Infrastructure`
-   project. `<HostProject>` is the target for C2–C4 below.
-3. **Present the implementation catalog (below) as a selection list and ASK the user which
-   implementation(s) to integrate.** Use an interactive multi-select prompt (`AskUserQuestion`,
-   `multiSelect: true`). The list options are the rows of the *Implementation catalog*.
-   - The user MAY select **more than one** (e.g., `MsGraph` for production + `File` for local dev).
-   - If more than one is selected, **ask a follow-up single-select**: *which one is the default
-     (active) provider?* — this becomes `options.Provider`.
-   - If the user selects exactly one, that one is the default.
-4. **Apply “Common steps” once** (§Common steps) — abstraction package + registration scaffold.
-5. **For each selected implementation, apply its block** under §Implementation blocks — add its
-   package, its `Use…` call inside the `AddEmailMessaging` builder, and its config section.
-6. **Set the default provider:** `configureOptions: options => options.Provider = "<default key>"`.
-   All selected implementations stay registered; the active one is switchable later via config.
-7. **(Optional) Wire a usage example** in the relevant feature handler (§Usage).
-8. **Offer the bundled sample endpoint (ASK).** After the wiring above, ask the user (single-select
-   yes/no via `AskUserQuestion`) whether to add the ready-made sample endpoint. If **yes**, copy it
-   into the host project — see §Sample reference endpoint. If **no**, skip silently.
-9. **Verify** (§Verification) and report what was added.
-
-> **Guardrail — always set `options.Provider`.** When `Provider` is null the facade falls back to a
-> **hardcoded `"SendGrid"`** key; if SendGrid is not registered, resolution throws at runtime. Never
-> rely on the implicit fallback.
-
----
-
-## Implementation catalog (selection list)
-
-Present these as the multi-select options. `Key` is the provider key and the `Use…` method suffix.
-
-| Key | Implementation | Best for | Package (v) | Required settings |
-|---|---|---|---|---|
-| `MsGraph` | Microsoft 365 / Graph API | Production on an O365 tenant | `AppWeaver.Messaging.Email.MsGraph` (0.1.2) | `TenantId`, `ClientId`, `ClientSecret`, `DefaultFrom` |
-| `Smtp` | Classic SMTP | Any SMTP server | `AppWeaver.Messaging.Email.Smtp` (0.1.3) | `Host`, `Port`, `Username`, `Password`, `EnableSsl` |
-| `SendGrid` | SendGrid API | SendGrid accounts | `AppWeaver.Messaging.Email.SendGrid` (0.1.2) | `ApiKey` *(required)*, `DefaultFrom` |
-| `OAuth2` | OAuth2-authenticated SMTP | O365 SMTP with OAuth2 | `AppWeaver.Messaging.Email.OAuth2` (0.1.3) | `TenantId`, `ClientId`, `ClientSecret`, `Host`, `Port` |
-| `File` | Writes email to a local `.txt` | Local dev / tests (no real send) | `AppWeaver.Messaging.Email.File` (0.1.2) | `DefaultFrom` |
-
-> Recommended pairing: **`MsGraph` (default) + `File`** so developers can run locally without
-> sending real mail, while production uses Graph.
-
----
-
-## Common steps (apply once, regardless of selection)
-
-### C1 — Abstraction package version
-
-**File:** `Directory.Packages.props` (versions live here only — see [[dependency-policy]])
-
-```xml
-<ItemGroup>
-  <!-- AppWeaver — Email (abstraction) -->
-  <PackageVersion Include="AppWeaver.Messaging.Email" Version="0.1.3" />
-  <!-- + one <PackageVersion> per selected implementation — see each block below -->
-</ItemGroup>
-```
-
-### C2 — Project references
-
-**File:** `src/<HostProject>/<HostProject>.csproj` (the host project resolved in step 2 — single
-project, no separate Application/Infrastructure). Add the abstraction **and** every selected
-implementation's package here (no `Version=` — versions live in `Directory.Packages.props`, C1).
-
-```xml
-<ItemGroup>
-  <PackageReference Include="AppWeaver.Messaging.Email" />   <!-- no Version= -->
-  <!-- + each selected implementation’s package — see its block below -->
-</ItemGroup>
-```
-
-### C3 — Registration scaffold
-
-**File:** the host project `<HostProject>` (step 2) — add the registration in its
-`Extensions/InfrastructureServiceRegistration.cs` (`AddInfrastructure`) when that file exists (it does
-in the Vertical Slice / Modular Monolith foundations), otherwise directly in `Program.cs` **before**
-`builder.Build()`. (`configuration` below = the `IConfiguration` in scope: `config` inside
-`AddInfrastructure`, `builder.Configuration` in `Program.cs`.)
-
-Add the base call; each selected implementation contributes one `builder.Use…(…)` line (C4).
-
-```csharp
-using AppWeaver.Messaging.Email.Extensions;
-// + one using per selected implementation (see its block)
-
-services.AddEmailMessaging(
-    configureBuilder: builder =>
-    {
-        // ⬇ one Use…() call per selected implementation is inserted here
-    },
-    configureOptions: options => options.Provider = "<default key>");   // step 6
-```
-
-> **Dual local/Aspire startup ([[components-readme]] R0.2a).** If the host project also has an
-> `AddAspireInfrastructure` method (`Extensions/AspireInfrastructureExtensions.cs`) selected by
-> `if (isAspire) … else …` in `Program.cs`, add this **same** `AddEmailMessaging(...)` block to
-> **both** `AddInfrastructure` and `AddAspireInfrastructure`. The Email registration is DB-agnostic, so
-> it is identical in both methods — copy it verbatim. Registering in only one leaves `IEmailService`
-> unresolvable (throws at runtime) in the other run mode.
-
-### C4 — Base appsettings block
-
-**File:** `src/<HostProject>/appsettings.json` (the host project resolved in step 2)
-
-```jsonc
-{
-  "Messaging": {
-    "Email": {
-      "DefaultFrom": "no-reply@your-domain.com",
-      "AdminEmail":  "admin@your-domain.com"
-    }
-  }
-}
-```
-
----
-
-## Implementation blocks
-
-For each implementation the user selected, do all three sub-steps: **package**, **registration
-line**, **config**. Secrets MUST be supplied via user-secrets / env / key vault — never committed.
-
-### MsGraph
-```xml
-<!-- Directory.Packages.props --> <PackageVersion Include="AppWeaver.Messaging.Email.MsGraph" Version="0.1.2" />
-<!-- host .csproj          --> <PackageReference Include="AppWeaver.Messaging.Email.MsGraph" />
-```
-```csharp
-using AppWeaver.Messaging.Email.MsGraph.Extensions;
-// inside AddEmailMessaging builder:
-builder.UseMsGraph(o =>
-{
-    o.TenantId     = configuration["Messaging.Email.MsGraph:TenantId"];
-    o.ClientId     = configuration["Messaging.Email.MsGraph:ClientId"];
-    o.ClientSecret = configuration["Messaging.Email.MsGraph:ClientSecret"]; // user-secrets
-    o.DefaultFrom  = configuration["Messaging:Email:DefaultFrom"];
-});
-```
-```jsonc
-// appsettings.json — secret set out-of-band:
-//   dotnet user-secrets set "Messaging.Email.MsGraph:ClientSecret" "<secret>"
-"Messaging.Email.MsGraph": { "TenantId": "<guid>", "ClientId": "<guid>", "DefaultFrom": "no-reply@your-domain.com" }
-```
-
-### Smtp
-```xml
-<PackageVersion Include="AppWeaver.Messaging.Email.Smtp" Version="0.1.3" />
-<PackageReference Include="AppWeaver.Messaging.Email.Smtp" />
-```
-```csharp
-using AppWeaver.Messaging.Email.Smtp.Extensions;
-builder.UseSmtp(o =>
-{
-    o.Host = configuration["Messaging.Email.Smtp:Host"]!;
-    o.Port = int.Parse(configuration["Messaging.Email.Smtp:Port"] ?? "587");
-    o.Username = configuration["Messaging.Email.Smtp:Username"]!;
-    o.Password = configuration["Messaging.Email.Smtp:Password"]!;   // user-secrets
-    o.EnableSsl = true;
-    o.DefaultFrom = configuration["Messaging:Email:DefaultFrom"];
-});
-```
-```jsonc
-"Messaging.Email.Smtp": { "Host": "smtp.example.com", "Port": 587, "Username": "<user>", "EnableSsl": true }
-```
-> Note: the `SendAsync(from,to,…)` convenience overload of the SMTP service writes to a file; the
-> `EmailMessage` overload performs the real SMTP send. Use `SendAsync(EmailMessage, ct)` for delivery.
-
-### SendGrid
-```xml
-<PackageVersion Include="AppWeaver.Messaging.Email.SendGrid" Version="0.1.2" />
-<PackageReference Include="AppWeaver.Messaging.Email.SendGrid" />
-```
-```csharp
-using AppWeaver.Messaging.Email.SendGrid.Extensions;
-builder.UseSendGrid(o =>
-{
-    o.ApiKey = configuration["Messaging.Email.SendGrid:ApiKey"]!;   // [Required] — user-secrets
-    o.DefaultFrom = configuration["Messaging:Email:DefaultFrom"];
-});
-```
-> `ApiKey` is `[Required]` and validates on startup — a missing key fails app boot, not the first send.
-
-### OAuth2
-```xml
-<PackageVersion Include="AppWeaver.Messaging.Email.OAuth2" Version="0.1.3" />
-<PackageReference Include="AppWeaver.Messaging.Email.OAuth2" />
-```
-```csharp
-using AppWeaver.Messaging.Email.OAuth2.Extensions;
-builder.UseOAuth2(o =>
-{
-    o.TenantId = configuration["Messaging.Email.OAuth2:TenantId"];
-    o.ClientId = configuration["Messaging.Email.OAuth2:ClientId"];
-    o.ClientSecret = configuration["Messaging.Email.OAuth2:ClientSecret"]; // user-secrets
-    o.Host = "smtp.office365.com"; o.Port = 587;
-    o.DefaultFrom = configuration["Messaging:Email:DefaultFrom"];
-});
-```
-
-### File
-```xml
-<PackageVersion Include="AppWeaver.Messaging.Email.File" Version="0.1.2" />
-<PackageReference Include="AppWeaver.Messaging.Email.File" />
-```
-```csharp
-using AppWeaver.Messaging.Email.File.Extensions;
-builder.UseFile(o => o.DefaultFrom = configuration["Messaging:Email:DefaultFrom"]);
-```
-> Pass `DefaultFrom` **inline** as shown. The File provider’s config binder reads the
-> `Messaging.Email.Smtp` section (a known quirk), so do not rely on a `Messaging.Email.File` config
-> section. Output is written to `Emails_<yyyy-MM-dd>.txt` in `AppContext.BaseDirectory`.
-
----
-
-## Usage (inject the abstraction in a feature handler)
-
-Email is a side effect of a business operation — call it from the Application command handler that
-owns the operation (see [[cqrs]], [[vertical-slices]]). Inject **`IEmailService`**, never a provider.
-
-```csharp
-using AppWeaver.Messaging.Email;
-
-public class CreateUserCommandHandler(IEmailService _email, IConfiguration _config /* … */)
-    : ICommandHandler<CreateUserCommand, Result<UserDto>>
-{
-    public async ValueTask<Result<UserDto>> Handle(CreateUserCommand req, CancellationToken ct)
-    {
-        // … persist aggregate …
-        var from = _config["Messaging:Email:DefaultFrom"]!;
-        var to   = _config["Messaging:Email:AdminEmail"]!;
-        await _email.SendAsync(from, to, $"New user: {req.Name}", "<p>Created.</p>", ct: ct);
-        return Result<UserDto>.Ok(/* dto */);
-    }
-}
-```
-
-Multi-recipient / attachments — use the `EmailMessage` overload (To/Cc/Bcc + `EmailAttachment`,
-see [README.md](./README.md)).
-
----
-
-## Sample reference endpoint
-
-A ready-to-run FastEndpoint is bundled in this component folder at
-[`ReferenceEndpoints/SendEmailEndpoint.cs`](./ReferenceEndpoints/SendEmailEndpoint.cs). It injects
-`IEmailService` directly and performs the **full send inline** — no command/handler/mediator — purely
-as a copy-paste sample. It is **not** wired automatically; it is offered in workflow step 8.
-
-**When the user opts in (step 8) — copy procedure:**
-
-1. Confirm `docs/components/Email/ReferenceEndpoints/SendEmailEndpoint.cs` exists. If it is missing,
-   tell the user and skip (do not hand-write a replacement).
-2. Create `src/<HostProject>/ReferenceEndpoints/` if it does not exist (`<HostProject>` = the project
-   resolved in step 2).
-3. Copy the file to `src/<HostProject>/ReferenceEndpoints/SendEmailEndpoint.cs`, replacing the
-   namespace token `__HOSTPROJECT__` with `<HostProject>`'s root namespace (e.g.
-   `AppWeaver.Health.Service`). Change nothing else.
-4. Do **not** touch the C1–C4 wiring. FastEndpoints auto-discovers the endpoint by assembly scan, so
-   no extra registration is required.
-
-**Endpoint:** `POST /reference/email/send` — body `{ "to", "subject", "body", "isHtml"?, "from"? }`.
-`from` falls back to `Messaging:Email:DefaultFrom`. With the `File` provider the message is written
-to `Emails_<yyyy-MM-dd>.txt` in the app base directory (no real mail is sent).
-
----
-
-## Verification
-
-1. **Builds** — `dotnet build` succeeds; no `Version=` on package references.
-2. **Startup validates** — app boots; options `ValidateOnStart()` passes; `options.Provider` equals
-   one of the selected keys.
-3. **Resolves** — `IEmailService` resolves from DI.
-4. **Sends** — a send succeeds; for `File`, confirm `Emails_<yyyy-MM-dd>.txt` appears in the app
-   base directory.
-5. **No secrets in diff** — `git diff` shows no secret / API key / password literals.
-6. **Sample endpoint (only if copied in step 8)** — the build still succeeds with
-   `ReferenceEndpoints/SendEmailEndpoint.cs` added, the `__HOSTPROJECT__` token was replaced, and
-   `POST /reference/email/send` is discoverable.
-
-## Related
-
-- [README.md](./README.md) · [[components-readme]] · [[cqrs]] · [[clean-architecture]] ·
-  [[vertical-slices]] · [[dependency-policy]] · [[ai-rules]]

package/assets/docs/components/Jobs/README.md

@@ -1,113 +0,0 @@
-# Jobs Component (`AppWeaver.Jobs`)
-
-> Pure technology (domain-agnostic). Reference sheet for the background-job component.
-> To wire it into a project, follow the agent runbook in [integration.md](./integration.md).
-> Commands: `/aw-spec-add-component`.
-
-## What it is
-
-A plug-and-play background-job framework. Application code depends only on the `IJobScheduler`
-and `IJobProgress` abstractions; the engine (Quartz.NET, optionally with EF Core status
-persistence) is a single registration decision. Supports **fire-and-forget**, **delayed**, and
-**recurring (CRON)** jobs with progress tracking, status polling, and cooperative cancellation.
-
-**Use when:** work must run outside the request thread — exports, batch processing, archival,
-report generation, scheduled maintenance, sending bulk notifications.
-
-## Public contract (`AppWeaver.Jobs.Abstractions`)
-
-```csharp
-public interface IJob { }   // marker — implement on every job class
-
-public interface IJobScheduler
-{
-    Task<string> EnqueueAsync<TJob>(Expression<Func<TJob, Task>> jobMethod,
-        string? description = null, string? userId = null) where TJob : class, IJob;
-
-    Task<string> ScheduleAsync<TJob>(Expression<Func<TJob, Task>> jobMethod, TimeSpan delay,
-        string? description = null, string? userId = null) where TJob : class, IJob;
-
-    Task AddOrUpdateRecurringAsync<TJob>(string jobId,
-        Expression<Func<TJob, Task>> jobMethod, string cronExpression) where TJob : class, IJob;
-
-    Task RemoveRecurringAsync(string jobId);
-    Task<JobStatus?> GetStatusAsync(string jobId);
-    Task<IEnumerable<JobStatus>> GetStatusesAsync(string userId, DateTime? from = null, DateTime? to = null);
-    Task CancelAsync(string jobId);
-}
-
-public interface IJobProgress
-{
-    Task ReportProgressAsync(int percent, string? message = null, object? progressDetails = null);
-    Task ReportResultUrlAsync(string url);
-    CancellationToken CancellationToken { get; }   // check inside loops for cooperative cancel
-}
-```
-
-`JobStatus` carries: `JobId`, `State`, `CreatedAt`, `StartedAt`, `CompletedAt`, `ProgressPercent`,
-`ProgressMessage`, `ResultUrl`, `ErrorMessage`, `Description`, `UserId`, `ProgressDetails`.
-`JobState` = `Pending → Running → Completed | Failed | Cancelled`.
-
-## Packages
-
-| Package | Version | Role | Builder method |
-|---|---|---|---|
-| `AppWeaver.Jobs` | `0.1.1` | **Required.** Abstractions + `AddAppWeaverJobs` + facade. | — |
-| `AppWeaver.Jobs.Quartz` | `0.1.0` | **Recommended engine.** Quartz.NET scheduler; in-memory or persistent store. | `UseQuartzJobScheduler` |
-| `AppWeaver.Jobs.Persistence.EfCore` | `0.1.0` | EF Core persistence of `JobStatus`. | `UseEfCoreJobs` + `UseJobDatabase` / `UseAppWeaverDataStore` |
-| `AppWeaver.Jobs.InMemory` | `0.1.0` | ⚠️ **Work in progress — not functional. Do not use.** | — |
-
-**Recommended stack:** `AppWeaver.Jobs` + `AppWeaver.Jobs.Quartz` + `AppWeaver.Jobs.Persistence.EfCore`.
-
-## Registration shapes
-
-```csharp
-// In AppWeaver.Jobs.Extensions
-IComponentBuilder<IJobScheduler> AddAppWeaverJobs(
-    this IServiceCollection services,
-    Action<IComponentBuilder<IJobScheduler>> configureBuilder,  // required
-    Action<JobsConfiguration>? configureOptions = null,         // set Provider = "Quartz"
-    IConfiguration? configuration = null);                      // OR bind "AppWeaver:Jobs"
-
-// In AppWeaver.Jobs.Quartz.Extensions
-builder.UseQuartzJobScheduler(opts => { opts.MaxConcurrency = 10; opts.ConfigureQuartz = q => { … }; });
-
-// In AppWeaver.Jobs.Persistence.EfCore.Extensions  (choose ONE store wiring)
-builder.UseEfCoreJobs().UseJobDatabase(opts => opts.UseSqlite("Data Source=jobs.db")); // standalone
-builder.UseEfCoreJobs().UseAppWeaverDataStore();                                       // shared DataStore
-```
-
-`JobsConfiguration.Provider` (config section `AppWeaver:Jobs`) selects the engine key; for Quartz
-it is `"Quartz"`. `UseQuartzJobScheduler` registers `IJobProgress` (`QuartzJobProgress`) and a
-Quartz hosted service automatically.
-
-## Persistence modes (EF Core)
-
-| Mode | Wiring | DbContext | Migration |
-|---|---|---|---|
-| **Standalone** | `.UseJobDatabase(opts => opts.UseXxx(conn))` | dedicated `JobStatusDbContext` | own migration / `EnsureCreated` |
-| **Shared DataStore** | `.UseAppWeaverDataStore()` (after `AddDataStore().UseEfCoreDataStore()`) | shares DataStore connection | Shared: in `SharedComponentDbContext` migration; Isolated: own migration |
-
-The Quartz **persistent store** (for distributed/durable scheduling) is configured separately via
-`opts.ConfigureQuartz = q => q.UsePersistentStore(...)` and needs the Quartz DDL applied to the DB.
-With no `ConfigureQuartz`, Quartz uses an in-memory store (single instance, lost on restart).
-
-## Source map (framework)
-
-```
-framework/Jobs/
-  README.md                              ← full component manual (authoritative deep-dive)
-  src/
-    AppWeaver.Jobs/                      ← IJob, IJobScheduler, IJobProgress, JobStatus, AddAppWeaverJobs
-    AppWeaver.Jobs.Quartz/               ← UseQuartzJobScheduler + QuartzJobScheduler/Wrapper/Progress
-    AppWeaver.Jobs.Persistence.EfCore/   ← UseEfCoreJobs/UseJobDatabase/UseAppWeaverDataStore
-    AppWeaver.Jobs.InMemory/             ← ⚠️ WIP, not functional
-  tests/
-    AppWeaver.Jobs.Tests/                ← DefaultJobSchedulerTests
-    TestApp/                             ← Quartz + EF Core end-to-end scenarios (A–O)
-```
-
-## Related
-
-- [integration.md](./integration.md) · [[components-readme]] · [[cqrs]] ·
-  [[persistence]] · [[clean-architecture]] · [[dependency-policy]]