gorig-cli 1.0.23 → 1.0.25

package/templates/skills/gorig-backend/references/persistent-crud.md

@@ -0,0 +1,332 @@
+# Persistent CRUD Module
+
+Use this reference when the user asks to add a business CRUD module, persistent resource, management capability, or storage-backed service.
+
+CRUD is not inherently HTTP. Treat persistence and business behavior as the core capability. Add HTTP routes/controllers only when the user asks for an HTTP API, when the existing project exposes similar modules through HTTP, or when the delivery contract explicitly requires route-level smoke verification.
+
+## Storage Selection
+
+The verified persistent CRUD workflow currently supports only:
+
+- MySQL through `domainx/dx`
+- MongoDB through `domainx/dx`
+
+Before implementation:
+
+1. If the user explicitly specifies MySQL, use MySQL.
+2. If the user explicitly specifies MongoDB or Mongo, use MongoDB.
+3. If the user specifies another persistence backend such as PostgreSQL, SQLite, Redis, files, or an external API, state that the verified persistent CRUD workflow supports only MySQL and MongoDB, then ask whether to use one of those two or proceed as custom unverified work.
+4. If the user does not specify storage, inspect the target project first:
+   - Reuse the existing database kind when the project has clear existing models/configuration for only one of MySQL or MongoDB.
+   - If both exist, ask which one this module should use.
+   - If neither is clear, ask the user to choose MySQL or MongoDB before coding.
+
+Do not silently default to MySQL or MongoDB when the project context does not make the choice obvious.
+
+## Configuration Discovery and Setup
+
+Persistent CRUD requires a matching database connection. Before writing code:
+
+1. Inspect `_bin/local.yaml`, `_bin/dev.yaml`, `_bin/prod.yaml`, test config under `test/_bin/`, and existing model `DConfig()` values.
+2. Determine whether the selected database key already exists:
+   - MySQL connection names are configured under `Mysql.<name>`, and models return that same `<name>` from `DConfig()`.
+   - MongoDB connection names are configured under `mongo.<name>`, and models return that same `<name>` from `DConfig()`.
+3. If configuration is missing, ask the user whether to:
+   - add non-secret skeleton keys to the environment YAML files, or
+   - provide values through environment variables.
+4. Never invent or commit real credentials. Prefer environment variables for passwords and private connection strings.
+
+When the user explicitly runs or approves `gorig-cli create <module> --crud --db ...`, the generator adds an idempotent non-secret connection skeleton to `_bin/local.yaml`, `_bin/dev.yaml`, `_bin/prod.yaml`, and `test/_bin/local.yaml`. Existing connection blocks with the same name are preserved.
+
+Gorig uses Viper with prefix `GORIG` and `.` -> `_` key replacement. For example:
+
+- `Mysql.Main.Write.Host` can be overridden with `GORIG_MYSQL_MAIN_WRITE_HOST`
+- `Mysql.Main.Write.Pass` can be overridden with `GORIG_MYSQL_MAIN_WRITE_PASS`
+- `mongo.main.uri` can be overridden with `GORIG_MONGO_MAIN_URI`
+- `mongo.main.auth.password` can be overridden with `GORIG_MONGO_MAIN_AUTH_PASSWORD`
+
+### MySQL skeleton
+
+Add this shape when the selected backend is MySQL and the project has no existing MySQL config. Keep secrets empty unless the user explicitly provides development credentials.
+
+```yaml
+Mysql:
+  Main:
+    GormInit: 1
+    IsOpenReadDb: 0
+    Write:
+      Host: 127.0.0.1
+      Port: 3306
+      DataBase: demo_api
+      User: root
+      Pass: ""
+      Charset: utf8mb4
+      SetConnMaxLifetime: 60
+      SetMaxIdleConns: 10
+      SetMaxOpenConns: 100
+```
+
+Required model config:
+
+```go
+func (*D) DConfig() (domainx.ConType, string, string) {
+    return domainx.Mysql, "Main", Table
+}
+```
+
+### MongoDB skeleton
+
+Add this shape when the selected backend is MongoDB and the project has no existing Mongo config. Keep credentials empty unless the user explicitly provides development credentials.
+
+```yaml
+mongo:
+  main:
+    uri: mongodb://127.0.0.1:27017
+    db:
+      name: demo_api
+    auth:
+      need: false
+      source: admin
+      user: ""
+      password: ""
+    retry:
+      writes: true
+      reads: true
+    pool:
+      max: 10
+      min: 1
+    conn:
+      idle:
+        time:
+          max: 10
+```
+
+Required model config:
+
+```go
+func (*D) DConfig() (domainx.ConType, string, string) {
+    return domainx.Mongo, "main", Table
+}
+```
+
+If the user cannot provide a reachable database during implementation, generate and compile the code but report DB integration as skipped. Do not claim create/list/page/update/delete behavior is verified until the selected database is reachable.
+
+## Core Module Layout
+
+For a persistent business module, generate or maintain:
+
+```text
+domain/<module>/
+├── service.go
+├── dto.go
+├── README.md
+└── model/
+    └── <module>.go
+test/
+└── <module>_test.go
+```
+
+Use this additional HTTP adapter only when HTTP is in scope:
+
+```text
+domain/<module>/
+├── router.go
+└── controller.go
+doc/
+└── <module>.md
+```
+
+Keep request/response DTOs in `dto.go`. Keep persistent data structures and `DConfig()` in `model/<module>.go`. Do not put response DTOs under `model/`.
+
+## Service Capability
+
+Services must expose the business CRUD behavior independently of HTTP:
+
+- create
+- get/info by ID
+- list with optional filters
+- page with optional filters
+- update by ID
+- delete by ID
+
+Services must:
+
+- Accept `context.Context` and propagate it into `dx` and logs.
+- Validate required fields and supported enum/filter values.
+- Return `utils/errors` errors.
+- Use `utils/logger` structured logs.
+- Guard empty update/delete conditions.
+- Treat not-found and duplicate cases explicitly.
+
+## Query and Pagination Safety
+
+List and page behavior must be database-backed.
+
+Rules:
+
+- Use `dx.Page(page, size, lastID)` for paginated API responses. Do not call `Find()`, convert the full result to `List()`, and slice it in memory.
+- Push optional filters into the `dx` query before `Find()` or `Page()`. Do not fetch all records and filter in Go.
+- Push sort order into `Sort(...)`. Do not sort an unbounded in-memory slice for API responses.
+- Use `Count`, `Sum`, `Exists`, and projection APIs when only aggregate or existence data is needed. Do not fetch full rows to count, sum, or check existence in Go.
+- Put a conservative maximum page size in DTO validation or service validation when the project has no existing convention.
+- For background jobs that must inspect many records, use restrictive matches plus `FindEach` or `AllEach`; do not load an entire table into memory.
+- If a requirement cannot be expressed through `dx`, use a direct driver escape hatch with equivalent database-side filtering, pagination, and limits.
+
+The only acceptable in-memory post-processing is bounded processing after the database already applied the main filter/page/limit, and it must not change pagination semantics.
+
+## Optional HTTP Adapter
+
+When HTTP is in scope, use clear resource routes unless the existing project has a stricter convention:
+
+| Method | Path | Purpose |
+|---|---|---|
+| POST | `/<module>/create` | Create a record |
+| GET | `/<module>/info?id=` | Load one record |
+| GET | `/<module>/list` | List records with optional filters |
+| GET | `/<module>/page` | Page records with optional filters |
+| POST | `/<module>/update` | Update a record |
+| DELETE | `/<module>/delete?id=` | Delete a record |
+
+Controllers must:
+
+- `defer apix.HandlePanic(ctx)`
+- Bind body/query parameters with the resolved `apix` signatures.
+- Return through `apix.HandleData` with the project's established business code shape.
+- Keep transport logic only; call service functions for business behavior.
+
+## MySQL Model Pattern
+
+Use MySQL when the user chooses MySQL or the project clearly uses MySQL for similar modules.
+
+```go
+package model
+
+import "github.com/jom-io/gorig/domainx"
+
+const Table = "order"
+
+type D struct {
+    Name   string `gorm:"column:name;type:varchar(128);not null;uniqueIndex:uk_name" json:"name"`
+    Status string `gorm:"column:status;type:varchar(32);not null;index:idx_status" json:"status"`
+}
+
+func (*D) DConfig() (domainx.ConType, string, string) {
+    return domainx.Mysql, "Main", Table
+}
+```
+
+Confirm the database name from existing project config or user input. Do not invent production database names.
+
+## MongoDB Model Pattern
+
+Use MongoDB when the user chooses MongoDB or the project clearly uses MongoDB for similar modules.
+
+```go
+package model
+
+import "github.com/jom-io/gorig/domainx"
+
+const Table = "order"
+
+type D struct {
+    Name   string `bson:"name" json:"name"`
+    Status string `bson:"status" json:"status"`
+}
+
+func (*D) DConfig() (domainx.ConType, string, string) {
+    return domainx.Mongo, "main", Table
+}
+```
+
+Confirm collection and database naming with existing project conventions or user input.
+
+## Migration and Indexes
+
+Register indexes in `service.go`:
+
+```go
+func init() {
+    domainx.AutoMigrate(
+        func() domainx.ConTable {
+            return dx.On[model.D](context.Background()).Complex()
+        },
+        domainx.CtIdx(domainx.Unique, "name"),
+        domainx.CtIdx(domainx.Idx, "status"),
+    )
+}
+```
+
+Pass bare field names to `CtIdx`; the framework handles its own field path mapping. Verify this against the resolved Gorig source before implementation.
+
+## Standard Service Operations
+
+Use `domainx/dx` for baseline CRUD:
+
+```go
+id, err := dx.On[model.D](ctx, &d).Save()
+item, err := dx.On[model.D](ctx).WithID(id).Get()
+list, err := dx.On[model.D](ctx).Eq("status", status).Sort("id").Find()
+page, err := dx.On[model.D](ctx).Eq("status", status).Sort("id").Page(page, size, lastID)
+err = dx.On[model.D](ctx).WithID(id).Updates(fields)
+err = dx.On[model.D](ctx).WithID(id).Delete()
+```
+
+Check the exact `dx` signatures in the resolved project version before coding.
+
+For API pagination, prefer the `Page` call above. Use `Find` only for intentionally bounded lists, such as small lookup sets or internal logic with a restrictive match.
+
+In the verified Gorig implementation, omitted/`false` trailing booleans enable the normal zero-value check, so empty optional filters are skipped. Passing `true` disables that check and forces an empty/zero condition into the query. Do not use `value == ""` as the third argument for optional filters.
+
+## Documentation
+
+Always update:
+
+- `domain/<module>/README.md`: module purpose, storage choice, indexes, service operations, tests, limitations.
+
+When HTTP is in scope, also update:
+
+- `doc/<module>.md`: public API contract, request/response examples, error cases.
+
+## Verification
+
+Always run compile-level checks:
+
+```sh
+go fmt ./...
+go vet ./...
+go build ./...
+go test ./... -v
+```
+
+The generated test layout separates validation tests from live-database tests:
+
+- `test/<module>_test.go` runs with ordinary `go test` and does not require a database.
+- `test/init_<backend>_integration_test.go` starts the selected Gorig database service.
+- `test/<module>_integration_test.go` exercises the real CRUD lifecycle.
+- `test/_bin/local.yaml` is the normal database configuration source for tests because the test package runs with `test/` as its working directory.
+
+After filling the local connection values or exporting the documented environment variables, run:
+
+```sh
+go test -tags=integration,mysql ./test/... -v
+go test -tags=integration,mongo ./test/... -v
+```
+
+Run only the command for the selected backend. If both backends are intentionally configured, run both commands separately so failures identify the affected connection.
+
+When the selected database is available, verify effect-level service behavior:
+
+- create success
+- duplicate/invalid create
+- get/info success
+- get/info not found
+- list filter
+- page filter
+- update success
+- update invalid/not found
+- delete success
+- delete not found
+
+When HTTP is in scope, also verify route-level smoke checks and confirm generated API docs match actual routes and response shapes.
+
+If MySQL or MongoDB is not available, do not claim integration verification. Report the missing connection/configuration and mark DB integration as skipped.

package/templates/skills/gorig-backend/references/project-bootstrap.md

@@ -0,0 +1,128 @@
+# Basic Project Bootstrap
+
+Use this workflow when creating a new locally runnable Gorig backend.
+
+## Confirm Before Creation
+
+Confirm or infer safely:
+
+- Project directory and Go module name.
+- Gorig version: preserve a requested version; otherwise use the selected stable version and report the resolution.
+- Whether an existing non-empty directory may be replaced. Never pass `--force` without explicit authorization.
+- Local base port.
+- Git initialization is a post-generation skill step. Ask after generation and verification; do not let the CLI initialize Git implicitly.
+
+The basic profile must not require MySQL, MongoDB, or Redis.
+
+## Generate
+
+Choose the generator before executing:
+
+1. When validating an unreleased sibling `gorig-cli` checkout, and `../gorig-cli/bin/cli.js` exists, use `node ../gorig-cli/bin/cli.js` so the test does not accidentally invoke an older global npm package.
+2. Otherwise use the installed `gorig-cli` command.
+3. Report which generator path and version are being used.
+
+When `gorig-cli` is installed:
+
+```sh
+gorig-cli init demo-api \
+  --module example.com/demo-api \
+  --gorig-version v0.0.52 \
+  --port 9527 \
+  --no-start \
+  --no-git
+```
+
+Unreleased sibling-checkout validation:
+
+```sh
+node ../gorig-cli/bin/cli.js init demo-api \
+  --module example.com/demo-api \
+  --gorig-version v0.0.52 \
+  --port 9527 \
+  --no-start \
+  --no-git
+```
+
+During framework development, use a verified local checkout without downloading another version:
+
+```sh
+gorig-cli init demo-api \
+  --module example.com/demo-api \
+  --gorig-replace ../gorig \
+  --port 9527 \
+  --no-start \
+  --no-git
+```
+
+Supported automation flags:
+
+- `--module <path>`: Go module name; defaults to the project directory name.
+- `--gorig-version <version>`: release, commit, branch, or `latest`.
+- `--gorig-replace <path>`: local Gorig checkout; records a Go `replace` directive.
+- `--port <port>`: local port; dev and prod use the next two ports.
+- `--force`: replace a non-empty destination; requires explicit authorization.
+- `--start`: start after generation; the default is not to start.
+- `--no-start`: explicit non-interactive behavior.
+- `--no-git`: skip `git init`.
+
+## Expected Structure
+
+```text
+demo-api/
+├── _bin/
+│   ├── local.yaml
+│   ├── dev.yaml
+│   └── prod.yaml
+├── _cmd/main.go
+├── domain/
+│   ├── init.go
+│   └── hello/
+│       ├── router.go
+│       ├── controller.go
+│       └── service.go
+├── global/config.go
+├── test/
+│   ├── _bin/local.yaml
+│   └── hello_test.go
+├── .gitignore
+├── README.md
+├── go.mod
+└── go.sum
+```
+
+`bootstrap.StartUp()` owns the built-in HTTP registration. The generated domain registers routes only; it must not register `httpx.Startup` a second time.
+
+## Verify
+
+Run from the generated project:
+
+```sh
+go fmt ./...
+go vet ./...
+go build ./...
+go test ./... -v
+```
+
+For repeatable behavior verification:
+
+```sh
+<skill-dir>/scripts/verify-basic-project.sh . local
+<skill-dir>/scripts/verify-basic-project.sh . dev
+```
+
+The verification script builds the binary, starts the selected environment, checks `/ping` and `/hello`, sends `SIGINT`, and requires a clean graceful shutdown.
+
+## Optional Git Initialization
+
+This is owned by the skill workflow, not by a new CLI command or flag.
+
+After project generation and verification pass, ask the user whether to initialize Git and create the first commit. If the user says yes:
+
+1. Copy the skill asset `assets/gorig.gitignore` to the project root as `.gitignore`. For a freshly generated project, replacing the generated `.gitignore` is expected. If the project already has user edits, merge instead of overwriting.
+2. Run `git init` from the project root when `.git/` does not already exist.
+3. Run `git add .`.
+4. Run `git commit -m "chore: initialize gorig project"`.
+5. Run `git status --short` and report whether the worktree is clean.
+
+Do not initialize Git or create a commit without explicit user confirmation. Do not commit files excluded by `assets/gorig.gitignore`, especially runtime logs, caches, local secrets, private certificates, or machine-specific override configuration.

package/templates/skills/gorig-backend/references/scheduled-tasks.md

@@ -0,0 +1,231 @@
+# Scheduled Tasks
+
+Use this reference when a task needs cron jobs, delayed jobs, one-shot jobs, task timeout, panic recovery, deduplication, or graceful cron shutdown.
+
+Always inspect the target project's resolved Gorig source first. The examples below reflect the locally inspected Gorig `master` commits through `0af68e8`.
+
+## Supported APIs
+
+Use `github.com/jom-io/gorig/cronx`.
+
+```go
+cronx.AddCronTask("0 */5 * * * *", func(ctx context.Context) {
+    logger.Info(ctx, "scheduled sync")
+}, 30*time.Second)
+
+cronx.AddDelayTask(10*time.Second, func(ctx context.Context) {
+    logger.Info(ctx, "delayed sync")
+}, 30*time.Second)
+
+cronx.AddOnceTask(time.Now().Add(time.Hour), func(ctx context.Context) {
+    logger.Info(ctx, "one-shot sync")
+}, 30*time.Second)
+```
+
+Supported in the inspected baseline:
+
+| API | Status | Notes |
+|---|---|---|
+| `AddCronTask` | verified | Accepts cron specs with seconds, including `@every` specs. Supports optional timeout context. |
+| `AddDelayTask` | verified | Runs once after a delay. Internally schedules a one-shot task and starts cron. |
+| `AddOnceTask` | verified | Runs once around the requested time and removes itself after execution. |
+| `AddTask` | deprecated | No context support; do not use for new work. |
+| `AddEveryTask` | verified | Convenience wrapper for `AddCronTask("@every <interval>")` in local Gorig commit `92c28b5` and later. |
+| `RegisterPersistTask` | source-verified | Registers a named Redis-backed persistent task handler. Requires Gorig commit `0af68e8` or later. |
+| `AddPersistDelayTask` | source-verified | Stores a JSON payload in Redis and runs once after a delay. Runtime verification requires Redis. |
+| `AddPersistOnceTask` | source-verified | Stores a JSON payload in Redis and runs once at the requested time. Runtime verification requires Redis. |
+
+## Registration and Lifecycle
+
+`cronx` registers the `CRON` service from package init. In ordinary applications, importing the package and calling `bootstrap.StartUp()` is enough:
+
+```go
+package order
+
+import (
+    "context"
+    "time"
+
+    "github.com/jom-io/gorig/cronx"
+    "github.com/jom-io/gorig/utils/logger"
+    "go.uber.org/zap"
+)
+
+func init() {
+    cronx.AddCronTask("0 */10 * * * *", syncExpiredOrders, 2*time.Minute)
+}
+
+func syncExpiredOrders(ctx context.Context) {
+    logger.Info(ctx, "expired order sync started")
+    count, err := cancelExpiredOrders(ctx)
+    if err != nil {
+        logger.Error(ctx, "expired order sync failed", zap.Error(err))
+        return
+    }
+    logger.Info(ctx, "expired order sync finished", zap.Int64("count", count))
+}
+```
+
+Manual lifecycle is useful only in tests or custom hosts:
+
+```go
+_ = cronx.Startup("CRON", "")
+// ...
+_ = cronx.Shutdown("CRON", context.Background())
+```
+
+Do not depend on startup ordering relative to unrelated services unless the resolved framework version provides explicit ordering.
+
+## Interval Tasks
+
+Use `AddEveryTask` for simple fixed intervals when the target Gorig version includes commit `92c28b5` or an equivalent fix. Older inspected versions recursively locked the task mutex and must not use this helper.
+
+```go
+func init() {
+    cronx.AddEveryTask(5*time.Minute, refreshCacheWarmup, 30*time.Second)
+}
+
+func refreshCacheWarmup(ctx context.Context) {
+    logger.Info(ctx, "cache warmup started")
+    if err := warmupHotKeys(ctx); err != nil {
+        logger.Error(ctx, "cache warmup failed", zap.Error(err))
+    }
+}
+```
+
+Rules:
+
+- Reject intervals at or below one millisecond; the framework logs and skips them.
+- Use `AddCronTask` directly when the schedule needs wall-clock alignment.
+- Verify `AddEveryTask` returns promptly and the task executes at least once in the target version.
+- Keep the same timeout and cancellation rules as `AddCronTask`.
+
+## Timeout and Cancellation
+
+When a timeout is supplied, the wrapper creates a context with that timeout. Long tasks must observe `ctx.Done()`:
+
+```go
+cronx.AddCronTask("@every 30s", func(ctx context.Context) {
+    select {
+    case <-ctx.Done():
+        logger.Warn(ctx, "job canceled before completion", zap.Error(ctx.Err()))
+        return
+    case item := <-work:
+        process(ctx, item)
+    }
+}, 5*time.Second)
+```
+
+The framework logs timeout expiration. It does not forcibly stop goroutines that ignore the context, so every long-running job must check cancellation.
+
+## Persistent Delay Tasks
+
+Use persistent delay tasks only when delayed work must survive process restarts and Redis is available. The inspected implementation stores task metadata and JSON payloads in Redis under the `gorig:cronx:persist:*` namespace, claims due tasks with Redis scripts, and keeps completed or failed task records for 24 hours.
+
+Persistent task APIs require Gorig commit `0af68e8` or a later equivalent implementation.
+
+```go
+type OrderDelayPayload struct {
+    OrderID int64 `json:"order_id"`
+}
+
+func (OrderDelayPayload) PersistPayload() {}
+
+func handleOrderDelay(ctx context.Context, payload OrderDelayPayload) error {
+    logger.Info(ctx, "delayed order task", zap.Int64("order_id", payload.OrderID))
+    return processDelayedOrder(ctx, payload.OrderID)
+}
+
+func init() {
+    if err := cronx.RegisterPersistTask(handleOrderDelay); err != nil {
+        logger.Error(nil, "register persistent cron task failed", zap.Error(err))
+    }
+}
+
+func scheduleOrderDelay(orderID int64) (string, error) {
+    return cronx.AddPersistDelayTask(
+        5*time.Minute,
+        handleOrderDelay,
+        OrderDelayPayload{OrderID: orderID},
+        30*time.Second,
+    )
+}
+```
+
+For absolute run times:
+
+```go
+taskID, err := cronx.AddPersistOnceTask(
+    time.Now().Add(time.Hour),
+    handleOrderDelay,
+    OrderDelayPayload{OrderID: orderID},
+    30*time.Second,
+)
+```
+
+Rules:
+
+- Register every persistent handler during application startup with `RegisterPersistTask`.
+- Handlers must be named functions. Closures and anonymous functions are rejected because Redis stores only the handler name.
+- Payload types must implement `PersistPayload` and must be JSON serializable. Keep JSON tags stable across deployments.
+- Redis must be configured and reachable before scheduling persistent tasks.
+- Use ordinary `AddDelayTask` or `AddOnceTask` when restart persistence is not required.
+- Treat task handlers as at-least-once work. Make handlers idempotent because a task can be recovered from the processing set after a worker lease expires.
+- Use task IDs returned by `AddPersistDelayTask` or `AddPersistOnceTask` for logs and operational troubleshooting.
+
+Redis configuration follows the same keys used by cache and Redis messaging:
+
+```yaml
+redis:
+  addr: 127.0.0.1:6379
+  password: ""
+  db: 0
+```
+
+Environment overrides:
+
+- `GORIG_REDIS_ADDR`
+- `GORIG_REDIS_PASSWORD`
+- `GORIG_REDIS_DB`
+
+Do not commit real Redis passwords or shared production addresses in examples or fixtures.
+
+## Panic Recovery
+
+`AddCronTask`, `AddDelayTask`, and `AddOnceTask` wrap handlers with panic recovery. A panic is logged and sent through the configured DingTalk panic notifier. Treat recovery as a safety net, not control flow.
+
+Rules:
+
+- Keep job handlers idempotent.
+- Log useful identifiers before risky work.
+- Avoid panics for ordinary business failures; return/log structured errors instead.
+- Never use `fmt.Println` for cron diagnostics.
+
+## Deduplication
+
+Duplicate detection uses the pair of schedule spec and function name. Register a stable named function when deduplication matters:
+
+```go
+func init() {
+    cronx.AddCronTask("@every 1m", syncInventory)
+    cronx.AddCronTask("@every 1m", syncInventory) // ignored as duplicate
+}
+
+func syncInventory(ctx context.Context) {}
+```
+
+Anonymous closures with different generated names may not deduplicate the way a reader expects.
+
+## Verification Checklist
+
+- Compile against the target project's resolved Gorig version.
+- Run a short deterministic job and assert execution count.
+- Register the same named function twice and verify duplicate registration does not double executions.
+- Verify timeout by asserting the handler observes `ctx.Done()`.
+- Verify panic recovery does not terminate the test process.
+- Verify delay or once jobs run exactly once.
+- Call shutdown and assert no verification process is left running.
+- Verify `AddEveryTask` returns promptly, does not deadlock during registration, and executes on the expected interval.
+- Verify persistent task registration rejects anonymous handlers.
+- Verify persistent task scheduling rejects unregistered handlers and non-JSON payloads.
+- Verify persistent delay/once runtime behavior only with disposable or explicitly supplied Redis: schedule a task, start or restart the worker, assert the payload is handled, and clean up `gorig:cronx:persist:*` keys.