# Naming-shift prompt — Sibyla module → Argus, Apollo platform → Sibyla, Hermes agent → Apollo

*Written 2026-09-02. Hand the fenced block below to the agent, one phase at a time. Everything
above and below it is context for you, not for the agent.*

## The shift in one table

| Thing | Name today | Name after the shift |
|---|---|---|
| The financial-documents module inside this platform (`Apollo.Modules.Sibyla.*`, `/sibyla/*`, module key `sibyla`) | Sibyla | **Argus** |
| The legacy applications and database (`C:\SibylaApps`, `gott_sibyla`, `*.sibyla.gottsolutions.net`) | Sibyla | **Sibyla Legacy** |
| This platform (repo GOTT.Apollo, `Apollo.Platform.*`, `Apollo.Web`, brand "Apollo") | Apollo | **Sibyla** |
| GOTT's gateway agent (the Hermes Agent instance that handles email, WhatsApp, Telegram and answers with licence data from the database) | Hermes | **Apollo** |

## Why it must be phased, and in this order

Four facts, verified in the repo on 2026-09-02, force the order:

1. **"Sibyla" is overloaded today.** It names the module (4,306 occurrences across 184 source
   files) and the legacy app at the same time, and it is about to name the platform. The platform
   can only take the name after the module has released it (Phase 1) and the legacy app is
   qualified everywhere as "Sibyla Legacy" (Phase 2). Otherwise `SibylaDbContext`,
   `Apollo.Tests.Sibyla`, the `/sibyla/*` routes and the label "Sibyla" would each mean two things
   for the duration of the work.
2. **"Apollo" is overloaded tomorrow.** The platform and the agent cannot both be Apollo, so the
   agent takes the name only after the platform has given it up (Phase 4 after Phase 3).
3. **Live identifiers collide with the target names.** The legacy database is `gott_sibyla`; the
   legacy IIS sites own `sibyla.gottsolutions.net` and `api.sibyla.gottsolutions.net`, and the
   latter is live-consumed by the Hermes plugin. `gott_apollo` cannot become `gott_sibyla`, and
   `apollo.gottsolutions.net` cannot become `sibyla.gottsolutions.net`, until the legacy stack is
   frozen and renamed. These are **infrastructure identifiers**, not labels: the prompt keeps them
   out of the label and architecture phases and puts them on the owner's decision list.
4. **The module key is data, and the memory index is keyed by path.** The string `sibyla` is
   stored in licence entitlements (`Licence.cs`), module-scoped roles (`PlatformUser.cs`) and
   every tenant's `ActiveModules`; renaming it is a data migration plus redirects, not a
   find-and-replace. The agent's memory lives under
   `…\projects\D--fileStorage-repos-GOTT-Apollo\memory`, derived from the repo folder, so renaming
   the folder orphans the index. Repo folder and GitLab project names stay until you decide (Done 2026-09-08: the directory was moved with the folder, and the legacy repo's own project directory renamed aside first so the two indexes did not merge.)
   otherwise.

## Owner decisions the prompt asks for before Phase 3

Give these answers to the agent with the Phase 3 prompt, or accept the defaults in the block.

| # | Decision | Default in the prompt |
|---|---|---|
| N1 | Database names `gott_apollo` / `gott_apollo_preview` and the PG roles `apollo_app`, `apollo_migrator`, `apollo_worker`, `apollo_preview*`, `apollo_ai_reader` | **Ruled 2026-09-02: last, and only after `gott_sibyla` has been eliminated.** The database rename is a step of the legacy decommissioning (Phase D below), not of Phases 1–4. Until then every phase keeps these names and lists them as kept-on-purpose. `apollo_ai_reader` happens to read correctly after the shift (it is the role Apollo, the agent, reads with), so it may stay even then. |
| N2 | Hostnames: platform stays `apollo.gottsolutions.net` or moves to `sibyla.gottsolutions.net`; intake API `api.apollo.gottsolutions.net` or `api.sibyla.gottsolutions.net` | **Ruled 2026-09-02: the legacy sites move first to `legacy.gottsolutions.net` and `api.legacy.gottsolutions.net`; then the platform targets `sibyla.gottsolutions.net` and `api.sibyla.gottsolutions.net` from the start.** Phase 3 writes the sibyla.\* names into config and documents and drops `apollo.gottsolutions.net` (decision D16 superseded). The legacy move is owner-run and precedes the platform's deployment: repoint the Hermes plugin `sibyla-channel-intake` to `api.legacy.gottsolutions.net` (it is the live consumer), rebind the IIS sites `Sibyla.Web`, `Sibyla.Api` (and `Sibyla.Docs` if kept) to the legacy.\* names with certificates, update DNS, verify the plugin still registers, then free the sibyla.\* names for the platform. |
| N3 | Repo folder `GOTT.Apollo` and GitLab project `gott-apollo` | **Ruled 2026-09-02: keep both for now.** Rename the folder only together with the memory directory, later or never. | **Superseded 2026-09-08:** both renamed - folder `GOTT.Sibyla`, GitLab project `GOTT.Sibyla`, the memory directory moved with them and the legacy stack archived as `GOTT.Sibyla.Legacy`. Record in `repo-rename-260908.md`.
| N4 | Channel-intake contract id `apollo.channel-intake.v1` and host project `src/Apollo.Api` (spec in `docs/apollo-channel-intake-api-spec.md`, not yet built) | **Ruled 2026-09-02: contract `sibyla.channel-intake.v1`, host project `src/Sibyla.Api` at `api.sibyla.gottsolutions.net`, scope `sibyla.channel-intake.write`, IdP client `sibyla-channel-intake`; the Hermes plugin keeps the name `apollo-channel-intake`** (Apollo, the agent, posting into Sibyla). Phase 3 rewrites the spec accordingly. |
| N5 | Cookie `apollo.auth` and config key `ConnectionStrings:ApolloDb` | **Ruled 2026-09-02: rename both** (`sibyla.auth`, `ConnectionStrings:SibylaDb`). One re-login for every user; appsettings and `local/*.ps1` change in Phase 3; the IIS environment variable goes on the owner checklist. |
| N6 | EF migrations history table for the module (`ArgusDesignTimeFactory.MigrationsHistoryTable`) and the applied migration ids `2026…_Sibyla*` | **Ruled 2026-09-02: keep both.** Applied history is never rewritten. Only the C# class and file names of *future* migrations use the new prefix. |
| N7 | Provenance sentences already stored in rows (e.g. LearnedEvidence "declared by … (Apollo association form)", ITGLOG observations "Raised by Apollo capture") | **Ruled 2026-09-02: keep as written.** They are history. New rows use the new names. |
| N8 | Harness display name for the runtime in AI Projects (`AiHome.razor` shows "Hermes") | **Ruled 2026-09-02: the runtime stays "Hermes"** (the product name of the CLI at `AppData\Local\hermes`); "Apollo" is the name of GOTT's agent instance, shown where the agent is addressed. Screens read "Apollo, on Hermes". |

## Phase map

| Phase | Rename | Frees | Blocked by | Status |
|---|---|---|---|---|
| 0 | Nothing. Glossary + inventory + decision list committed. | — | — | **Done 2026-09-02** (`naming-glossary.md`, inventory below) |
| 1 | Module Sibyla → Argus (labels, routes, key, namespaces, projects, DbContext, tests) | `Sibyla*` type names, `/sibyla` routes, the word "Sibyla" inside the platform | — | **Done 2026-09-02** (gate below) |
| 2 | Legacy app → "Sibyla Legacy" in every doc, label and memory that refers to it | The unqualified word "Sibyla" | 1 | **Done 2026-09-02** (gate below) |
| 3 | Platform Apollo → Sibyla (brand, labels, refusal sentences, namespaces, projects, config keys per N4/N5) | The word "Apollo" | 1, 2, decisions N1–N7 | **Done 2026-09-02** (gate and Phase L checklist below) |
| 4 | Agent Hermes → Apollo (persona, plugin/cron names, docs, AI-area labels per N8) | — | 3 | **Done 2026-09-02** (gate below). The naming shift's code and document phases are complete; L and D remain owner-run. |
| L | Legacy hostname move (N2): the Hermes plugin repointed to `api.legacy.gottsolutions.net`, the legacy IIS sites rebound to `legacy.gottsolutions.net` / `api.legacy.gottsolutions.net`, DNS updated, `sibyla.*` freed for the platform. Owner-run; checklist below. It precedes the platform's production deployment, not Phase 3's code. | `sibyla.gottsolutions.net`, `api.sibyla.gottsolutions.net` | — | **Done 2026-09-02** (run from an agent session at the owner's instruction; run record under the checklist) |
| D | Decommissioning of Sibyla Legacy: after `gott_sibyla` is dropped, rename `gott_apollo` → `gott_sibyla`, `gott_apollo_preview` → `gott_sibyla_preview`, the `apollo_*` roles, `local/secrets/apollo-db.json`, the connection guards, `local/*.ps1`, the design-time factories and the IIS environment. Owner-run, with an agent-written checklist. | — | 4, and the legacy freeze (cutover C6) | Ruled 2026-09-02: last |
| R | Repo folder and GitLab project (N3): `GOTT.Apollo` -> `GOTT.Sibyla`, the legacy project renamed `gott-sibyla-legacy` and archived, its source archived under `legacy/`, the memory directory moved, and the stored paths that named the folder followed. | the name `GOTT.Sibyla` for this repository | 4, D | **Done 2026-09-08** (record in `repo-rename-260908.md`) |

## Phase 0 inventory (2026-09-02, working tree at 5b1bd56)

Case-insensitive occurrences of each word, `bin`/`obj` excluded. "Files" is the number of files
holding at least one hit, S/A/H for Sibyla/Apollo/Hermes.

| Root | Project | Kind | Sibyla | Apollo | Hermes | Files S/A/H |
|---|---|---|---:|---:|---:|---|
| . | root (README, Apollo.slnx) | md, slnx | 13 | 44 | 0 | 2/2/0 |
| db | rls-policies, seed | sql | 3 | 6 | 0 | 1/2/0 |
| docs | all | md | 410 | 1233 | 195 | 16/21/9 |
| local | scripts, tools | ps1, cs, json, py, csproj | 7 | 131 | 0 | 3/18/0 |
| src | Apollo.Modules.Sibyla.Domain | cs, csproj | 26 | 63 | 0 | 21/22/0 |
| src | Apollo.Modules.Sibyla.Infrastructure | cs, csproj | 3732 | 3677 | 0 | 81/81/0 |
| src | Apollo.Platform.Contracts | cs | 0 | 4 | 1 | 0/3/1 |
| src | Apollo.Platform.Domain | cs | 22 | 26 | 4 | 5/19/2 |
| src | Apollo.Platform.Infrastructure | cs, csproj | 5 | 902 | 1 | 2/66/1 |
| src | Apollo.Sync | cs, csproj | 19 | 62 | 0 | 9/10/0 |
| src | Apollo.Web | razor, cs, css, js, json, csproj | 286 | 343 | 6 | 42/64/2 |
| src | Apollo.Worker.Documents | cs, json, csproj | 2 | 30 | 0 | 1/9/0 |
| tests | Apollo.Tests.Browser | cs, csproj | 69 | 67 | 0 | 2/5/0 |
| tests | Apollo.Tests.Platform | cs, csproj | 3 | 130 | 0 | 2/13/0 |
| tests | Apollo.Tests.Sibyla | cs, csproj | 136 | 224 | 0 | 16/16/0 |
| tests | Apollo.Tests.TenantIsolation | cs, csproj | 6 | 44 | 0 | 3/11/0 |
| **total** | | | **4739** | **6986** | **207** | |

File and folder names carrying a word: Sibyla 81 (48 of them applied module migrations, which
stay), Apollo 37 (13 project folders and csproj files, the solution, scripts).

### Classification of the hits

| Class | What it covers | Phase | Evidence |
|---|---|---|---|
| **Label** | Module display name and description in `ApolloModuleDescriptor`; `L.cs` keys naming a product (6 keys); PageTitle suffixes (19 "— Sibyla", 11 "— Apollo", 2 bare); brand and brandmark in `MainLayout`; 46 refusal / provenance / problem sentences in the module and platform Infrastructure that say "Apollo"; README. | 1 (Sibyla → Argus), 3 (Apollo → Sibyla) | grep of `"…Apollo…"` string literals outside Migrations |
| **Route or key** | 20 `@page "/sibyla…"` directives and 119 route strings in Razor/C#; the module key `"sibyla"` in 30 code sites (descriptor catalogue, MainLayout, Home, Licences `_orgModules`, Documents gate, tenant `ActiveModules` checks); the key stored in `licence` entitlements and `platform_user` module-scoped roles (data, migrated in Phase 1); `ConnectionStrings:ApolloDb`, cookie `apollo.auth`, `ApolloEnvironments`, scope `apollo-api` and client `apollo-web` in `Program.cs` (93 config-key hits across src and local). | 1 (routes, module key), 3 (config keys per N4/N5; IdP client and scope stay per N1) | |
| **Architecture** | 9 src and 4 test projects, `Apollo.slnx`, namespaces, `SibylaDbContext`/`ApolloDbContext`, `SibylaDesignTimeFactory`, `AddSibylaModule`/`AddApolloPlatform`, `Components/Pages/Sibyla`, `DataProtection` application name "Apollo". The bulk of the counts: 3,732 Sibyla hits in the module Infrastructure are namespaces, `using`s and the model snapshot. | 1 (module projects), 3 (platform projects) | `Apollo.slnx`, `DependencyInjection.cs` |
| **Infrastructure** | Databases `gott_apollo`/`gott_apollo_preview`; PG roles `apollo_*` (7); hostnames; IIS; IdP clients `apollo-web`, `apollo-worker`, scope `apollo-api` (`local/tools/RegisterIdpClients`); `local/secrets/apollo-db.json`; the repo folder; GitLab; the memory directory path. Referenced in 11 `local/*.ps1` scripts, two connection guards and the design-time factories. | Owner's hand only, per N1–N3, after the legacy freeze | `SyncConnectionGuard.cs`, `PreviewConnectionGuard.cs`, `local/setup-db.ps1` |
| **History** | 48 applied module migrations and 30 platform migrations (file, class and `MigrationId` strings), `__EFMigrationsHistory_Sibyla`, the model snapshot's `[DbContext(typeof(SibylaDbContext))]` attribute (changes with the type name; the snapshot content must not), stored provenance sentences, git history. | Never rewritten | `SibylaDesignTimeFactory.MigrationsHistoryTable` |
| **Legacy** | 17 `SibylaApps`, 16 `sibyla.gottsolutions.net`, 13 `Sibyla.Api`, 12 `gott_sibyla`, 9 `sibyla-email-graph-gateway`, 9 `sibyla-channel-intake`, 5 `Sibyla.Web` mentions in docs; one in code (`RegisterIdpClients` reads the IdP password from the legacy appsettings path); the memory files `legacy-sibyla-retirement`, `apollo-intake-plugin`, `sibyla-no-document-carryover`. | 2 (qualified as "Sibyla Legacy") | |
| **External** | 12 `sibyla-registry-web` mentions (the FDR's own repo path) in docs, 1 in code; the workbook and FDR commit stamps. | Never renamed | |
| **Runtime** | `appsettings.json` `Hermes.ExecutablePath`, `HarnessCliOptions.Hermes`, harness key `HERMES` in the AI Projects seed, `AiHome` display. 207 Hermes hits in total, 195 of them in docs (the harness plan and the intake spec), where most mean the runtime and some mean GOTT's instance. | 4 separates persona from runtime per N8 | |

### Phase 1 grep gate (2026-09-02)

Occurrences of "Sibyla" in src, tests, local, db and the repo root went from 4,329 to 140. Every
survivor is in one of the three headings.

**Renamed.** Projects `Apollo.Modules.Sibyla.{Contracts,Domain,Infrastructure}` →
`Apollo.Modules.Argus.*`, `tests/Apollo.Tests.Sibyla` → `Apollo.Tests.Argus`, `Components/Pages/Sibyla`
→ `Components/Pages/Argus` with the twenty `Sibyla*.razor` pages → `Argus*.razor`, `SibylaDbContext` →
`ArgusDbContext`, `SibylaDesignTimeFactory` → `ArgusDesignTimeFactory`, `AddSibylaModule` →
`AddArgusModule`, the model snapshot class, `SibylaFailClosedTests` → `ArgusFailClosedTests`; routes
`/sibyla/*` → `/argus/*` (20 `@page` directives, the layout, the descriptor's nav items, Home,
Documents, the Browser routes table); module key `"sibyla"` → `"argus"` in code and in
`db/seed/tenant1.sql`, plus the platform migration `20260902152750_ArgusModuleKey` (LICMOD and
USRROL rows) applied to Main and Preview; labels: descriptor display name and description, the
Medusa description's "integração Argus", `module.inactive` in PT and EN, the Documents page's inline
copy, 19 PageTitle suffixes and the Overview eyebrow, README; comments that meant the module.
Added: permanent redirects `/sibyla` and `/sibyla/{**rest}` → `/argus/...` in `Program.cs` (query
string kept, PathBase-aware), the Browser theory `OldModuleRoutesRedirectPermanently`, and
`ArgusModuleKeyTests` (Up and Down of the migration on a synthetic owner inside a rolled-back
transaction; tenant #1 carries `argus` and no `sibyla`). `local/migrate.ps1` and `run-preview.ps1`
follow the new project path.

**Kept on purpose.**
- History: the 48 applied module migrations keep their `2026…_Sibyla*` file names, class names and
  ids, and the comments that cite them by name (`Documents.cs`, `HumanDecision.cs`,
  `SyncEngineWave5.cs`); `__EFMigrationsHistory_Sibyla` per N6 (`ArgusDesignTimeFactory`,
  `ArgusDbContext` comment, `PreviewParityTests`, `run-preview.ps1`); the applied `AiProjects`
  migration, whose AI project `sibyla` is the platform's own development project and whose skill
  text cites the FDR path `Interface/sibyla-registry-web`. Neither database context has pending
  model changes.
- External: the FDR column `SibylaValue` / `sibyla_value` (`IntegrationLayer.cs`, the snapshot,
  `SyncEngineWave8.cs`); the Share prototype in `tokens.css`; the workbook name in
  `DesignTokenTests`; the IdP service account `sibyla@` in the seed comment.
- By design: the redirect endpoints and their test, and the migration and its test, name the old
  key and route because that is what they translate.

**Left for Phase 2.** The legacy references in code comments (`IErpProvider.cs` "legacy Sibyla",
`IzibiziErpProvider.cs` "GOTT.Sibyla/…", `RegisterIdpClients` `C:\SibylaApps`); every document
except README (`apollo-discovery-and-plan-260826.md` entries, `discovery/*`,
`ai-projects-harness-plan-260831.md`, the intake spec); the memory files.

### Phase 2 grep gate (2026-09-02)

The phase's promise was that the bare word "Sibyla" stops meaning two things. It now means
exactly one of: the legacy stack, written "Sibyla Legacy" or as a concrete identifier; the FDR's own
names, which are external; the platform's future name where it is already used that way (the AI
project `sibyla`); or history under a naming note.

**Renamed / qualified.**
- Legacy stack → "Sibyla Legacy": the deployment prompt's title and goal, the harness plan's
  channel-intake references and the retirement sentence, discovery 08's two legacy-client
  sentences, the code comments in `IErpProvider.cs` and `IzibiziErpProvider.cs`, the memory files
  `legacy-sibyla-retirement` and `sibyla-no-document-carryover`.
- Module → Argus in the current-state documents: the harness plan (solution table, routes
  `/argus/**`, module key and `argus:*` role keys, the module-only user's landing and access
  statements, Preview's migration lists, the open questions), the deployment prompt's screen
  statements, discovery 08 (processing, push-eligible state), 12 (rule services), 14 (rules,
  entitlement, seam criterion) and 15 (diagram node, project names, module key examples).
- FDR meaning made explicit: `tokens.css` ("the FDR interface prototype"), discovery 08 ("the
  FDR's purchase-side corpus"), the seed comment ("the IdP service account sibyla@").
- A naming note under the title of every dated document that still uses the word: the living
  plan, the harness plan, the deployment prompt, the intake spec and its review, and discovery
  01, 03, 05, 07, 08, 10, 11, 12, 14, 15. Memory: `apollo-poc-server-environment` (module key
  history) and `apollo-deployment-slice1-effort` (suite name history).

**Kept on purpose.**
- History under the note: the living plan's dated entries (78 lines: routes, suite counts,
  migration names, the 2026-09-01 naming memo that first wrote "Sibyla Argus"); Phase 1's
  redirect, migration and tests, which name the old key and route because they translate it.
- The platform's future name already in use: the AI project `sibyla` ("Sibyla · Codex", "New
  Sibyla Session", "Sibyla project folder") in the harness plan and the AiProjects seed; the
  licence tier example "Sibyla Pro" in discovery 10.
- External: the FDR's `sibyla_api_server.py`, `window.SIBYLA_DATA`, `sibyla-gott-2026-share`,
  `Sibyla_SNCACC_Input.xlsx`, the Supabase project name, the GitLab group path
  `gottsolutions.dev/sibyla`, the workbook name in `DesignTokenTests`.
- Concrete legacy identifiers, which the glossary allows unqualified: `gott_sibyla`,
  `Sibyla.Web/Api/Worker/Docs`, `GottSibylaWorker`, `C:\SibylaApps`, `*.sibyla.gottsolutions.net`,
  `sibyla-channel-intake`, `sibyla-email-graph-gateway`, the legacy contract ids and env names in
  the intake spec, `GOTT.Sibyla`.
- Quotes: the owner's own words in Portuguese ("entre o Sibyla e o Apollo", "acesso ao Sibyla")
  stay verbatim.
- The discovery file name `05-sibyla-workflow-summary.md` is referenced from other documents and
  keeps its name; its note says the word means the FDR.

**Left for Phase 3.** Nothing of Phase 2's. Phase 3 needs decisions N2–N7.

### Phase 3 grep gate (2026-09-02)

The word "Apollo" no longer names the platform anywhere in code, scripts, seeds or the
current-state documents. Every survivor is an infrastructure identifier, stored data, an applied
migration, the agent's own name, or history under a naming note.

**Renamed.** Projects `Apollo.Platform.{Contracts,Domain,Infrastructure}`, `Apollo.Web`,
`Apollo.Sync`, `Apollo.Worker.Documents`, `Apollo.Modules.Argus.*` → `Sibyla.*`; tests
`Apollo.Tests.*` → `Sibyla.Tests.*`; `Apollo.slnx` → `Sibyla.slnx`; every namespace; `ApolloDbContext`
→ `SibylaDbContext` (free since Phase 1), `ApolloModuleDescriptor`, `ApolloPolicies`, `ApolloRoles`,
`ApolloRoleRequirement/Handler`, `ApolloEnvironments`, `IApolloModule`, `AddApolloPlatform`,
`ApolloDetection`/`ApolloDetects` (the checklist's "Sibyla detection"), `ApolloFactory`,
`Get-ApolloDatabaseTarget`, test names. Config keys per N5: cookie `apollo.auth` → `sibyla.auth`,
`ConnectionStrings:ApolloDb` → `SibylaDb` (appsettings, `run-web/worker/preview.ps1`, the design-time
factories' env `APOLLO_DB` → `SIBYLA_DB`, tests' `APOLLO_TEST_DB_SECRETS`), the owner and scope
cookies `apollo.owner`/`apollo.scope` → `sibyla.*`, the nav-state key `apollo.nav.sections`, the
`Apollo:PathBase` setting → `Sibyla:PathBase`, the worker's Windows service name (not yet installed).
Labels: brand and brandmark "S" in `MainLayout`, `Home`, PageTitles ("— Sibyla"), the four `L.cs`
keys with Portuguese gender corrected ("pela própria Sibyla", "da Sibyla", "A Sibyla ainda…"),
every refusal, provenance and problem sentence in the module and platform services (new rows say
Sibyla), the worker's log lines, the harness "Sibyla host stopped" messages, README. Hostnames
per N2 in `RegisterIdpClients` (`https://sibyla.gottsolutions.net`), the deployment prompt and the
intake spec. Intake spec per N4: contract `sibyla.channel-intake.v1`, host `src/Sibyla.Api`,
scope `sibyla.channel-intake.write`, IdP client `sibyla-channel-intake`; the plugin keeps
`apollo-channel-intake`. Data: migration `20260902162350_SibylaPlatformNames` moved the AI project's
stored preview target from `src/Apollo.Web/Apollo.Web.csproj` to `src/Sibyla.Web/Sibyla.Web.csproj`
on Main and Preview. Plan decision D16 marked superseded. Neither context has pending model
changes; suites TenantIsolation 43, Argus 136, Browser 121, Platform 96.

**Kept on purpose.**
- Infrastructure (N1, N3, Phase D): `gott_apollo`, `gott_apollo_preview`, the `apollo_*` roles and
  the secrets keys named after them, `local/secrets/apollo-db.json` and `apollo-preview-db.json`,
  the IdP clients `apollo-web`, `apollo-worker` and scope `apollo-api` (`RegisterIdpClients`,
  `Program.cs`), the repo folder `GOTT.Apollo` and GitLab `gott-apollo`, the data folders
  `D:\ApolloData\{ai,staging,work,preview}` (moving them moves data; owner's call, Phase D).
- Stored identifiers that live in rows and must keep matching them: the code-ledger issuer and
  document source system `"apollo"` (`CodeIssuer`, `DocumentEntryService`, `SyncBase`), the
  gap-detector tag `apollo:gap-detector`, the extraction contract id `apollo.extract.v0` (a
  versioned contract; a rename is a new version), the Nextcloud folder prefix `Apollo/{company}`
  (files already live there), the data-protection application name "Apollo" and purpose
  `Apollo.CredentialStore.v1` (changing either makes every stored credential unreadable).
- Applied migrations: their ids, namespaces aside; the AiProjects seed (project `apollo` is the
  agent, correctly named).
- The agent: the AI project `apollo` and every place that means the gateway agent (Phase 4 makes
  the rest of those explicit).
- Documents: `docs/apollo-*.md` file names (referenced from memory and commits), and the prose
  of dated documents under their naming note; the owner's quotes ("API deve viver no Apollo.Api").
- The extraction contract `apollo.extract.v0` is worth a ruling of its own when the next contract
  version is cut: `sibyla.extract.v1` would be the natural name. **Cut 2026-09-02 as `sibyla.extract.v1`**
  (recipient fields, owner ruling on company assignment); v0 survives in stored evidence only.

**Left for Phase 4.** The persona/runtime split (N8): AI-area labels that address the agent, the
plugin and cron names in the intake spec's cutover order, `DocumentIntake`'s channel comment,
`HarnessExecutionOptions` comments, the memory file `apollo-intake-plugin`.

### Phase 4 grep gate (2026-09-02)

"Hermes" now means the runtime only; "Apollo" means the agent (and the protected infrastructure
identifiers listed in the Phase 3 gate). Nothing user-visible changed: per N8 the harness
selector keeps "Hermes", and the agent is addressed as Apollo where it already was (the seeded AI
project `apollo`, the plugin `apollo-channel-intake`).

**Qualified / renamed.** The instance-meaning sentences: the harness plan's ruling paraphrase
("the agent Apollo (on Hermes)"), its "Apollo/Hermes project" and "Hermes answers" acceptance
steps, its open question on the intake plugin (Sibyla exposes the API, Apollo's plugin posts to
`api.sibyla.gottsolutions.net`, order starts with Phase L); the living plan's channel-adapter
sentence and discovery 13, 14 and 15, which had listed "Hermes" as if it were a medium beside
WhatsApp and email (it is the carrier; the medium names the channel); the intake spec's title
and its plugin definition ("Apollo's plugin, a Hermes-runtime plugin") and its cutover order,
which now names the new cron `apollo-email-gateway`; the deployment prompt's retirement line
(Apollo's plugin repointed at Sibyla's ingestion). Code: the `DocumentIntake.Channel` comment
(medium, never carrier; delivered by Apollo), a summary on `HarnessExecutionOptions.Hermes` and a
remark beside the "Hermes" display label, both citing N8. The naming note on the fifteen dated
documents gained the Phase 4 sentence. Memory `apollo-intake-plugin` rewritten with the N2/N4/N8
names. The glossary is declared final.

**Kept on purpose.** Everything that is the runtime: the harness key `HERMES` and
`HarnessCliOptions.Hermes`, `appsettings` `Hermes.ExecutablePath`, the "Hermes" display label
(N8), every `hermes …` CLI command, profile, gateway, cron, plugin folder and path in the harness
plan and the intake spec, the Hermes skills and `.env`; the legacy cron `sibyla-email-graph-gateway`
and plugin `sibyla-channel-intake` (concrete legacy identifiers); the owner's quoted words ("the
Apollo Hermes agent", "o plugin do Hermes"); the applied AiProjects seed.

**Left.** Nothing in code or documents. Phase L ran on 2026-09-02 (record below). Owner-run:
Phase D (databases and roles at decommissioning), the optional N3 folder rename, and the IdP
display names (re-run `RegisterIdpClients` when convenient).

### Phase L — the legacy hostname move (owner-run, before production deployment)

Ruling N2. Nothing in this list is run by an agent; each line is one verifiable step.

1. **Freeze the plugin's traffic window.** Pause the Hermes cron `sibyla-email-graph-gateway`
   (it is paused today; confirm).
2. **DNS.** Create `legacy.gottsolutions.net` and `api.legacy.gottsolutions.net` pointing at the
   POC server (same address as today's `sibyla.*`). Leave `sibyla.*` in place for the moment.
3. **Certificates.** Issue or extend a certificate covering `legacy.gottsolutions.net` and
   `api.legacy.gottsolutions.net` (and `docs.legacy.gottsolutions.net` if `Sibyla.Docs` is kept).
4. **IIS bindings.** On the sites `Sibyla.Web` (`C:\SibylaApps\Sibyla`) and `Sibyla.Api`
   (`C:\SibylaApps\Sibyla.Api`), add the `legacy.*` HTTPS bindings beside the existing ones. Do
   not remove the `sibyla.*` bindings yet.
5. **IdP.** In GOTT.IdentityServer, add the `legacy.*` redirect and post-logout URIs to the legacy
   `Sibyla.Web` client; the legacy API's audience does not change.
6. **Plugin.** Point the legacy plugin `sibyla-channel-intake` at
   `https://api.legacy.gottsolutions.net` (its base-URL env), run its status tool once, and
   confirm a registration round-trips. Un-pause the cron only if the legacy path is still meant
   to receive mail before the Sibyla intake API exists.
7. **Verify** `https://legacy.gottsolutions.net` signs in and shows data; `https://api.legacy…`
   answers the health route.
8. **Release the names.** Remove the `sibyla.gottsolutions.net` and `api.sibyla.gottsolutions.net`
   bindings from the legacy sites. They are now free for the platform's sites; the deployment
   prompt takes over from here with `sibyla.*` as its target.
9. **Record** the date in this document's phase map (Phase L: done) and in the living plan.

**Run record (2026-09-02, agent session on the owner's instruction).** Steps 1–9 done; what
differed from the list as written:

- Step 1: `sibyla-email-graph-gateway` was already paused (since 2026-09-01) and stays paused;
  the legacy plugin `sibyla-channel-intake` is listed under `plugins.disabled` in the Hermes
  `config.yaml` since the intake cutover (steps 2–4 of the intake spec), so nothing consumed the
  legacy API during the move.
- Step 2: `legacy.gottsolutions.net` and `api.legacy.gottsolutions.net` already resolved to the
  POC server (35.180.180.52, no wildcard) — DNS needed no change.
- Step 3: two Let's Encrypt certificates issued with win-acme (`--source manual`, self-hosted
  http-01, store `WebHosting`, IIS installation on sites 6 and 7) as new renewals
  `[Phase L] legacy.gottsolutions.net` and `[Phase L] api.legacy.gottsolutions.net`. The old
  renewals for the released names were retired: `api.sibyla…` cancelled with `--cancel`; the
  site-6 "(any host)" renewal's id starts with `-` and cannot be passed on the command line, so
  its file was moved to `C:\ProgramData\win-acme\acme-v02.api.letsencrypt.org\PhaseL-cancelled\`.
  A friendly-name pattern cancel matched `docs.sibyla.gottsolutions.net` by mistake; that renewal
  was recreated at once (`--source iis --siteid 5`), the docs site got a fresh certificate and its
  renewal schedule is back (`[IIS] Sibyla.Docs, docs.sibyla.gottsolutions.net`).
- Step 4: IIS backup `PhaseL-20260902235011` taken first. Both sites now bind only the
  `legacy.*` names (http 80 and https 443, SNI). `Sibyla.Web`'s `AllowedHosts` went to
  `legacy.gottsolutions.net;sibyla.gottsolutions.net` during the move and to
  `legacy.gottsolutions.net` at release (`appsettings.Production.json`, backup beside it).
- Step 5: the `sibyla-web` OpenIddict application in `gott_identity` gained the
  `https://legacy.gottsolutions.net/signin-oidc` and `…/signout-callback-oidc` URIs (SQL on
  `OpenIddictApplications`), and at release lost the `sibyla.gottsolutions.net` pair, so the
  legacy client no longer claims the platform's host. Verified: an authorize request with the
  legacy redirect URI reaches the login page; a bogus one is refused with `invalid_request`.
- Step 6: `SIBYLA_CHANNEL_INTAKE_API_BASE_URL` in the Hermes `.env` now reads
  `https://api.legacy.gottsolutions.net` (backup `.env.pre-phase-l-*.bak`), and the helper
  `C:\SibylaApps\Apolo-agent\ps1\Set-ChannelIntakeSecret.ps1` carries the same default so a
  rerun cannot revert it. The plugin is disabled in Hermes, so its status tool was run directly
  (`client.handle_status` under the `.env` values): a token was minted at the IdP and the legacy
  API answered `404 channel_intake_not_found` for a random id through the new host — the round
  trip without writing a registration into the retired database. The cron stays paused. The
  running Hermes gateway was not restarted; it loads the `.env` at its next start.
- Step 7: `https://legacy.gottsolutions.net/pt` redirects to the IdP with
  `redirect_uri=https://legacy.gottsolutions.net/signin-oidc`; `https://api.legacy…/health/live`
  and `/health/ready` answer 200; TLS verifies.
- Step 8: `sibyla.gottsolutions.net` and `api.sibyla.gottsolutions.net` no longer answer on 443
  (no binding, no http.sys certificate entry); the old certificates stay in the `WebHosting`
  store until they expire. Apollo's `apollo-channel-intake` plugin targets `api.sibyla…` by
  design and has no site to talk to until the platform's API deploys (intake spec §10 order).
- `Sibyla.Docs` moved too, on the owner's instruction the same evening: certificate and
  renewal `[Phase L] docs.legacy.gottsolutions.net` (site 5), old bindings, http.sys entry and
  renewal removed; `https://docs.legacy.gottsolutions.net/` answers 200 and
  `docs.sibyla.gottsolutions.net` no longer answers. Hermes skill references under
  `skills/devops/windows-iis-application-deployment/references/` still quote the old hostnames
  as historical deploy notes.
- 2026-09-03: the freed `docs.sibyla.gottsolutions.net` is planned as the platform's documentation
  site over this repository's `docs\` folder (living plan entry of that date, deployment prompt,
  Slice 2 section of the deployment spec).
- 2026-09-03: the platform deployed on the freed names (`docs/apollo-deployment-run-260903.md`). The
  legacy IIS sites and pools were renamed `Sibyla.Legacy.Web`, `Sibyla.Legacy.Api`,
  `Sibyla.Legacy.Docs` (IIS names only; hostnames, paths, bindings and renewals unchanged — the
  win-acme renewals address sites by id) so the platform's sites could take `Sibyla.Web`,
  `Sibyla.Api`, `Sibyla.Docs`.

### Recommendations on N1–N8 where the default deserves a second look

- **N2 hostnames.** The deployment prompt of 2026-09-01 targets `apollo.gottsolutions.net`. If the
  platform is to be reached as `sibyla.gottsolutions.net` in the end, that hostname is the legacy
  `Sibyla.Web` site's today, so the swap is a legacy-freeze step, not a naming step. Recommendation:
  deploy to `apollo.gottsolutions.net` now as planned, and add `sibyla.gottsolutions.net` as a
  second binding on the same site the day the legacy site stops, so no user ever bookmarks a name
  that will change again.
- **N4 intake contract id.** The spec is unbuilt, so renaming it costs nothing now and avoids a
  v2 later. Recommendation: apply the rename in Phase 3 as the default says, and keep the host
  question inside N2 (`api.apollo.gottsolutions.net` today, since `api.sibyla.gottsolutions.net` is
  live-consumed by the legacy plugin until the cutover order in the intake spec is run).
- **N5 cookie and connection-string key.** Cheap, but each is a production checklist line (IIS
  environment variable, re-login). Recommendation: do both in Phase 3 and put them on the same
  checklist as the deployment, so production is touched once.
- **N6 module migrations history table.** Keeping `__EFMigrationsHistory_Sibyla` under a context
  called `ArgusDbContext` is the one place the old name stays visible to an operator. It is safe
  and reversible later with a single `ALTER TABLE … RENAME` plus the factory constant.
  Recommendation: keep, and record it in the glossary's "does not change" table (done).
- **N8 runtime display.** The AI Projects seed already names the Hermes-harness project `apollo`.
  Recommendation: confirm the default; the screen then reads "Apollo, on Hermes", which is the
  ruling in five words.
- **Not in the list, worth a ruling: the AI Projects seed rows.** Project `sibyla` today means
  "development of this repository" and runs on Codex. After Phase 3 that key is right (the
  platform is Sibyla), but its description says "GOTT.Apollo repository", which stays true only
  while N3 keeps the folder name. No action; noted so the Phase 3 grep gate classifies it as
  infrastructure per N3.

Each phase is one session and one commit series on `main`, with a dated entry in the living plan,
all three test suites green, and a grep gate that proves the old name only survives where the
prompt allows it.

## The prompt

Replace `<PHASE>` with the phase number. Give the agent decisions N1–N8 with Phase 3.

```text
You are working in D:\fileStorage\repos\GOTT.Apollo on branch main. Read
docs/apollo-naming-shift-prompt-260902.md first: it holds the naming table, the reasons the
work is phased, the owner decisions N1–N8 and the phase map. Execute PHASE <PHASE> only.

The shift, in one line each:
- The module today called Sibyla (Apollo.Modules.Sibyla.*, /sibyla/*, module key "sibyla") becomes Argus.
- The legacy applications and database (C:\SibylaApps, gott_sibyla, *.sibyla.gottsolutions.net) become "Sibyla Legacy".
- This platform (Apollo.Platform.*, Apollo.Web, brand "Apollo") becomes Sibyla.
- GOTT's gateway agent (the Hermes Agent instance for email, WhatsApp, Telegram, answering with
  licence data from the database) becomes Apollo.
The phases run strictly 0 → 1 → 2 → 3 → 4 because each frees a name the next one needs. Do not
start a phase whose predecessor is not committed.

Rules that hold in every phase
1. Three layers, renamed in this order inside the phase: labels (what users read: L.cs, brand in
   MainLayout, ApolloModuleDescriptor display names, PageTitle, notices, refusal sentences,
   provenance strings written from now on), then routes and keys (URLs, module keys, config keys,
   cookie names), then architecture (folders, .csproj, Apollo.slnx, namespaces, type names,
   DbContext names, test projects). Build and run the suites after each layer, not only at the end.
2. Infrastructure identifiers are not labels. Database names, PostgreSQL roles, hostnames, IIS
   site names, the repo folder, the GitLab project, local/secrets/*.json and the IdP client
   registrations change only where a decision in N1–N8 says so, and never by you: you write the
   change into a checklist the owner runs. You never touch the legacy stack, the live IIS sites,
   DNS, or gott_sibyla.
3. History is never rewritten. Applied EF migration ids and the migrations-history table names
   stay; existing rows keep their provenance sentences; git history is untouched; the FDR's own
   names (Interface/sibyla-registry-web, the workbook, the FDR commit stamps) are external and stay.
   Only the C# class/file names of migrations created after the phase use the new prefix. The
   model snapshot must not change from a rename alone: prove it with `dotnet ef migrations has-pending-model-changes`
   (or an empty `migrations add` that you then delete) for both contexts.
4. Module key rename (Phase 1) is a data migration: a platform migration rewrites "sibyla" to
   "argus" in licence entitlements, module-scoped roles and every tenant's ActiveModules, and
   the old routes /sibyla/* answer with a permanent redirect to /argus/* for one release. Tests
   cover both the migration on a synthetic owner and the redirect.
5. The sync-era rule is untouched: an owner with sync_run rows is the FDR's until cutover C6 and
   every writer still refuses with a sentence. Renaming the sentence's words is allowed; changing
   its meaning is not.
6. The CSS prefix `sib-` stays in every phase. After Phase 3 it reads as Sibyla, which is the
   point.
7. Grep gate at the end of the phase: run a case-insensitive search for the old name over src,
   tests, docs, local and the memory directory, and list every hit in the plan entry under one of
   three headings: "renamed", "kept on purpose (history / external / infrastructure per Nx)",
   "left for phase N". A hit outside those headings means the phase is not done.
8. Delivery per phase: the code, a dated entry in docs/apollo-discovery-and-plan-260826.md
   inserted newest-first, an update to the naming document's phase map (status column), memory
   updated (the glossary memory and apollo-poc-server-environment), one commit series on main
   staging only your paths, with the trailers
   Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
   Claude-Session: <this session's URL>
   Do not push unless told. Migrations are applied to Main and Preview with
   & "D:\fileStorage\repos\GOTT.Apollo\local\migrate.ps1" (PowerShell, absolute path). Write
   source files with the Write tool, not Bash heredocs.
9. Report at the end: what was renamed, counts before/after, the kept-on-purpose list, the owner
   checklist (infrastructure steps you did not run), and which decisions N1–N8 you applied with
   their defaults.

PHASE 0 — glossary and inventory (no rename)
- Write docs/naming-glossary.md: the four-row table, the definition of each name, and the
  forbidden usages after the shift (e.g. "Sibyla" alone never means the legacy app; "Apollo"
  alone never means the platform). Every later doc links to it.
- Produce the inventory: per project, per file kind (cs, razor, csproj, slnx, json, ps1, md), the
  counts of Sibyla, Apollo and Hermes, with the classification each hit will get (label / route
  or key / architecture / infrastructure / history / external). Put it in the naming document.
- List the decisions N1–N8 with your recommendation where the default is questionable.
- Add a glossary memory file and a MEMORY.md pointer.

PHASE 1 — module Sibyla → Argus
- Labels: module display name and description in ApolloModuleDescriptor, "module.inactive" and
  every L.cs key that names the module, PageTitle suffixes ("— Sibyla" → "— Argus"), the sidebar
  brandmark letter, the nav section headers.
- Routes and key: /sibyla/* → /argus/*, module key "sibyla" → "argus" (data migration + redirect
  per rule 4), MainLayout's key checks, Home.razor's module landing, Licences.razor's
  _orgModules, Documents.razor's gate.
- Architecture: Apollo.Modules.Sibyla.{Contracts,Domain,Infrastructure} →
  Apollo.Modules.Argus.*, tests/Apollo.Tests.Sibyla → Apollo.Tests.Argus, Components/Pages/Sibyla
  → Components/Pages/Argus, SibylaDbContext → ArgusDbContext, SibylaDesignTimeFactory →
  ArgusDesignTimeFactory (history table name kept per N6), AddSibylaModule → AddArgusModule,
  SyncConnectionGuard and Apollo.Sync references, the Sib* shared components stay (rule 6 logic:
  "Sib" is the platform prefix, not the module's).
- Leave every reference to the legacy app alone in this phase; Phase 2 qualifies them.

PHASE 2 — legacy → "Sibyla Legacy"
- Docs: apollo-discovery-and-plan-260826.md, discovery/*, apollo-deployment-prompt-260901.md,
  apollo-channel-intake-api-spec*.md, ai-projects-harness-plan-260831.md: every mention of the
  legacy apps, database, IIS sites, plugin and cron becomes "Sibyla Legacy" or the concrete
  identifier (gott_sibyla, Sibyla.Api). Do not edit files another session is editing without
  checking git status first.
- Memory: legacy-sibyla-retirement, apollo-intake-plugin, apollo-poc-server-environment,
  sibyla-no-document-carryover, share-labels-parity: same qualification.
- Code: comments and label text that mention the legacy stack (e.g. MainLayout comment "Uploads is
  Apollo's intake and has no prototype counterpart") are qualified; no identifiers change.
- Gate: after this phase the unqualified word "Sibyla" appears nowhere in the repo or memory.

PHASE 3 — platform Apollo → Sibyla (needs N1–N7)
- Labels: brand "Apollo" in MainLayout (brandmark "A" → "S", app description), every L.cs key
  that says Apollo ("Apollo intake", "A financial document Apollo issues itself", the file-endpoint
  notices), refusal sentences in DocumentCaptureService, DocumentEntryService, ErpPushEngine,
  IntegrationRequirementEvaluator, LearningStore, MasterDataService, AssociationService,
  CatalogueService, SettlementEventService, ManualMatchService, ReviewDecisionEngine; provenance
  strings for new rows ("Apollo association form" → "Sibyla association form"); PageTitles.
- Routes and keys per N4/N5: ConnectionStrings:ApolloDb → SibylaDb (appsettings, local/*.ps1,
  the owner's IIS checklist), cookie apollo.auth → sibyla.auth, the intake spec's contract id and
  host project name; ApolloEnvironments → SibylaEnvironments.
- Architecture: Apollo.Platform.{Contracts,Domain,Infrastructure} → Sibyla.Platform.*, Apollo.Web
  → Sibyla.Web, Apollo.Sync → Sibyla.Sync, Apollo.Worker.Documents → Sibyla.Worker.Documents,
  Apollo.Modules.Argus.* → Sibyla.Modules.Argus.*, tests Apollo.Tests.* → Sibyla.Tests.*,
  Apollo.slnx → Sibyla.slnx, ApolloDbContext → SibylaDbContext (free since Phase 1),
  ApolloModuleDescriptor → SibylaModuleDescriptor, AddApolloPlatform → AddSibylaPlatform,
  PreviewConnectionGuard messages. Infrastructure names per N1–N3 stay and are listed as kept.
- Owner checklist: IIS environment variable rename, IdP client display names, the future
  hostname swap, the database/role renames deferred to the legacy freeze.

PHASE 4 — agent Hermes → Apollo (needs N8)
- The agent persona is Apollo; the runtime stays Hermes Agent. Rename: the plugin and cron names
  the platform documents (sibyla-email-graph-gateway → apollo-email-gateway in docs and the intake
  spec's cutover order), the harness option comments, DocumentIntake's channel comment
  ("hermes/whatsapp/buzz/email" → "apollo/whatsapp/buzz/email" only if the stored channel value
  changes: decide and record), AI-area labels that address the agent, the memory files
  apollo-intake-plugin (now: Apollo is the agent that owns the plugin into Sibyla) and
  ai-projects-harness-plan-260831.md.
- Keep: appsettings "Hermes" harness key and ExecutablePath (runtime), HarnessCliOptions.Hermes,
  AiHome's "Hermes" runtime display (N8), the hermes.exe path.
- Gate: "Hermes" survives only as the runtime; "Apollo" survives only as the agent. State the
  glossary as final in docs/naming-glossary.md.
```

## After the four phases

Two steps are yours, outside any agent session. Phase L, the legacy hostname move (N2), comes
before the platform's production deployment: the legacy sites go to `legacy.gottsolutions.net`
and `api.legacy.gottsolutions.net`, and the platform takes the sibyla.\* names. Phase D is last by
ruling (2026-09-02): the database and role renames happen during the decommissioning of Sibyla
Legacy, after `gott_sibyla` has been eliminated. The renaming of the repo folder and GitLab
project together with the memory directory (N3) is separate and optional. Everything in the app
will already read Sibyla / Argus / Apollo by then, so both can wait indefinitely without a user
seeing the old names. When Phase D comes, ask the agent for the checklist: it names every file
that carries a database or role name (the Phase 0 inventory's infrastructure class), and the
order is: stop the legacy sites, drop `gott_sibyla`, rename the databases and roles, update the
secrets file and the IIS environment, run the connection guards' tests, then swap the hostnames.

### Phase D — run record (2026-09-03, on the owner's word, ahead of the decommissioning)

Ruling N1 placed this step after `gott_sibyla` had been eliminated; the owner asked for it on
2026-09-03 while `Sibyla.Legacy.Api` still serves the intake plugin, so the legacy database was
moved aside instead of dropped. Checklist and script: `apollo-naming-shift-phase-d-260903.md`,
`local\phase-d\Invoke-PhaseD.ps1` (dry run by default; the owner ran `-Execute` in an elevated
console with the superuser password prompted there, never through an agent session).

- Renamed: `gott_sibyla` → `gott_sibyla_legacy` (owner `gott`, kept until intake cutover step 8),
  `gott_apollo` → `gott_sibyla`, `gott_apollo_preview` → `gott_sibyla_preview`; roles
  `apollo_migrator/app/worker/api/preview_migrator/preview_app` → `sibyla_*`. `apollo_ai_reader`
  stays (N1). Passwords survived (SCRAM); the RLS policies (`worker_access` → `sibyla_worker`,
  `channel_binding_*` → `sibyla_api`), the table ownership (`sibyla_migrator`) and the CONNECT
  privileges (preview roles still refused on `gott_sibyla`) followed the OIDs.
- Carriers rewritten by blind substitution with `.pre-phase-d.bak` beside each: the three
  platform secrets files under `C:\ProgramData\Sibyla\secrets`, the repository secrets
  (`apollo-db.json` → `sibyla-db.json`, `apollo-preview-db.json` → `sibyla-preview-db.json`), the
  `ConnectionStrings__SibylaDb` variable of the `Sibyla.Legacy.Web` and `Sibyla.Legacy.Api` pools
  and of the `GottSibylaWorker` service (`Database=gott_sibyla_legacy`).
- Window: the `Sibyla.Web`, `Sibyla.Api` and `Sibyla.Legacy.Api` pools and the
  `Sibyla.Worker.Documents` service were stopped for the renames and started again from the
  agent session; after the restart `sibyla.gottsolutions.net` 200, `api.sibyla…/health` and
  `/health/ready` 200, `docs.sibyla…` 200, `api.legacy…/health/live` 200 (on `gott_sibyla_legacy`),
  `login.gottsolutions.net` 302; `pg_stat_activity` shows `sibyla_app`, `sibyla_api`,
  `sibyla_worker` on `gott_sibyla` and `gott` on `gott_sibyla_legacy`; no Application-log errors.
- Repository: branch `ops/naming-phase-d` renames every name in code, tests, scripts and SQL
  (50 files; the name table `local\tools\DatabaseTarget.ps1`, `setup-db.ps1`, the connection
  guards and their tests, the helpers that read `sibyla-db.json`, the run scripts, README, the
  glossary). Applied migrations keep their text (history); their guarded `DO` blocks name
  `apollo_api`, which on a fresh database after Phase D means they skip with a notice and
  `setup-db.ps1` applies the renamed `db\channel-intake-api-role.sql`, as designed.
- Untouched: `gott_identity` and the role `gott`, the IdP clients and scopes (N4), the
  `D:\ApolloData` folders, the data-protection application name, the code-ledger issuer, the
  extraction contract id, the Nextcloud prefix, the repo folder and GitLab project (N3), the
  login-less role `sibyla_piece_c_executor` (origin unknown, not ours).