@eventmodelers/cli 0.0.1

package/stacks/cratis-csharp/templates/.claude/skills/load-slice/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: load-slice
+description: Load all slices from the board via the slicedata API and persist them to the .build-kit/.slices/ directory hierarchy (index.json with full definitions, per-slice folders). Returns data for a specific slice by ID or title.
+---
+
+# Load Slice
+
+> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+
+---
+
+## Step 1 — Parse arguments
+
+From `$ARGUMENTS`, extract:
+
+| Field | How to find it | Default |
+|-------|---------------|---------|
+| `sliceId` | UUID of the slice (SLICE_BORDER node ID) | optional — prefer over title |
+| `sliceTitle` | slice title (case-insensitive match) | optional — used if sliceId missing |
+
+If neither is provided, load and persist all slices without filtering.
+
+---
+
+## Step 2 — Fetch all slices from the slicedata API
+
+```bash
+curl -s \
+  -H "x-token: <TOKEN>" \
+  -H "x-board-id: <BOARD_ID>" \
+  -H "x-user-id: load-slice-skill" \
+  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
+```
+
+Response shape: `{ "slices": [ { "id": "...", "title": "...", "status": "...", "context": "...", "comments": ["..."], ... } ] }`
+
+Save the full array as `ALL_SLICES`.
+
+---
+
+## Step 3 — Persist slices to .build-kit/.slices/ directory
+
+Apply the following logic for every slice in `ALL_SLICES`.
+
+### Derive paths
+
+- `contextName` = `slice.context` if present, otherwise `"default"` — **preserve original casing** (e.g. `"Beta"`, not `"beta"`)
+- `sliceFolder` = `slice.title` lowercased, with all spaces removed and the prefix `"slice:"` stripped  
+  e.g. `"Beta Enable User for Beta Test"` → `"betaenableuserforbetatest"`
+- `baseFolder` = `.build-kit/.slices/<contextName>/`
+- `sliceDir`   = `.build-kit/.slices/<contextName>/<sliceFolder>/`
+
+### Write files
+
+```bash
+mkdir -p ".build-kit/.slices/<contextName>/<sliceFolder>"
+```
+
+**`.build-kit/.slices/current_context.json`** — always overwrite:
+
+```json
+{ "name": "Beta" }
+```
+
+**`.build-kit/.slices/<contextName>/context.json`** — write once per context:
+
+```json
+{ "name": "Beta" }
+```
+
+**`.build-kit/.slices/<contextName>/<sliceFolder>/slice.json`** — the full slice object with the `index` field removed.
+
+### Maintain `.build-kit/.slices/<contextName>/index.json`
+
+Read the file if it exists, otherwise start with `{ "slices": [] }`.
+
+Each entry in `index.json` contains the index metadata **plus** the complete slice definition fetched from the API:
+
+```json
+{
+  "slices": [
+    {
+      "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
+      "slice": "Beta Enable User for Beta Test",
+      "index": 0,
+      "context": "Beta",
+      "folder": "betaenableuserforbetatest",
+      "status": "Created",
+      "definition": {
+        "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
+        "title": "Beta Enable User for Beta Test",
+        "status": "Created",
+        "context": "Beta"
+      }
+    }
+  ]
+}
+```
+
+The `definition` field holds the full object returned by the API for that slice (all fields as-is).
+
+**Merge rules:**
+- If an entry with the same `id` already exists: update all fields and refresh `definition`; preserve any existing `assigned` field.
+- If not found: append the new entry.
+
+Write the updated object back to `.build-kit/.slices/<contextName>/index.json`.
+
+---
+
+## Step 4 — Return the requested slice
+
+If `sliceId` was given: find the entry in `ALL_SLICES` where `id === sliceId`.  
+If `sliceTitle` was given: find the entry where `title` matches case-insensitively.  
+If neither: return all slices.
+
+If a specific slice was requested but not found, stop and list the available titles.
+
+---
+
+## Step 5 — Output
+
+```
+Slices loaded: <count> total
+Persisted to: .build-kit/.slices/<contextName>/
+
+Requested slice:
+  Title:  <title>
+  ID:     <id>
+  Status: <status>
+  Folder: .build-kit/.slices/<contextName>/<sliceFolder>/slice.json
+```
+
+Or if no filter was given:
+
+```
+All slices (<count>) — context: <contextName>:
+  - <title> [<status>] → .build-kit/.slices/<contextName>/<sliceFolder>/
+  - ...
+```
+
+Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.

package/stacks/cratis-csharp/templates/.claude/skills/update-slice-status/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: update-slice-status
+description: Update the status of a single slice on an eventmodelers board by changing the SLICE_BORDER node's sliceStatus field
+---
+
+# Update Slice Status
+
+> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+
+---
+
+## Step 1 — Parse arguments
+
+From `$ARGUMENTS`, extract:
+
+| Field | How to find it | Default |
+|-------|---------------|---------|
+| `sliceName` | the slice title to update (case-insensitive match) | **required** |
+| `newStatus` | the target status value | **required** |
+
+Valid status values (case-sensitive):
+
+| Value | Meaning |
+|-------|---------|
+| `Created` | Default — slice has been created but not started |
+| `Planned` | Work is planned |
+| `InProgress` | Work is actively in progress |
+| `Review` | Ready for review |
+| `Done` | Completed |
+| `Blocked` | Blocked by something |
+| `Assigned` | Assigned to someone |
+| `Informational` | Informational / reference slice |
+
+If `newStatus` is not one of these exact values, stop and tell the user the valid options.
+
+---
+
+## Step 2 — List all slices
+
+Fetch all slices on the board:
+
+```bash
+curl -s \
+  -H "x-token: <TOKEN>" \
+  -H "x-board-id: <BOARD_ID>" \
+  -H "x-user-id: update-slice-status-skill" \
+  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
+```
+
+Response: `{ "slices": [{ "id": "<nodeId>", "title": "<title>", "status": "<status>" }] }`
+
+The `id` here is the `SLICE_BORDER` node ID — use it directly in Step 3.
+
+Find the slice whose `title` matches `sliceName` (case-insensitive). If no match is found, stop and list the available slice titles so the user can pick one.
+
+Save the matched slice as:
+- `SLICE_NODE_ID` — the node ID of the SLICE_BORDER
+- `CURRENT_STATUS` — the current status value
+
+---
+
+## Step 3 — Update the slice status
+
+Send a `node:changed` event to update the `sliceStatus` field in the SLICE_BORDER node's meta:
+
+```bash
+curl -s -X POST "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-token: <TOKEN>" \
+  -H "x-board-id: <BOARD_ID>" \
+  -H "x-user-id: update-slice-status-skill" \
+  -d '[{
+    "id": "<new-random-uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<SLICE_NODE_ID>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": <Date.now()>,
+    "changedAttributes": ["sliceStatus"],
+    "meta": {
+      "sliceStatus": "<newStatus>"
+    }
+  }]'
+```
+
+Response: `{ "hashes": { "<eventId>": "<hash>" } }`
+
+---
+
+## Step 4 — Report back
+
+Tell the user:
+
+- **Slice**: the title that was updated
+- **Previous status**: `CURRENT_STATUS`
+- **New status**: `newStatus`
+- **Node ID**: `SLICE_NODE_ID`
+- **Any errors**: raw API message if something failed
+
+Example success output:
+```
+Updated: "Order Placed" slice
+  Before: InProgress
+  After:  Done
+Node ID: a1b2c3d4-…
+```

package/stacks/cratis-csharp/templates/build-kit/lib/AGENT.md

@@ -0,0 +1,58 @@
+# Agent Learnings
+
+Patterns and gotchas discovered during task processing. Update this file whenever you encounter something reusable.
+
+## Cratis non-negotiables (seed — full detail in `.claude/skills/_shared/cratis-conventions.md`)
+
+- ALL backend artifacts for a slice go in ONE `.cs` file under the project's slice folder (the shipped starter uses `<Module>/<Feature>/<Slice>/<Slice>.cs` — discover the real top-level folder from an existing slice). Never split into `Commands/`, `Handlers/`, `Events/`.
+- `[Command]` records define `Handle()` directly on the record — never a separate handler class.
+- `[EventType]` takes NO attribute arguments (the type name is the id); events are past-tense and never nullable.
+- Use `ConceptAs<T>` for every identity/value — no raw `Guid`/`string` in the domain.
+- Read models: `[ReadModel]` record with `public static` query methods on it; observable queries return `ISubject<T>` directly (never `Task<ISubject<T>>`). Projections join events, never read models.
+- Reactors implement the marker `IReactor`; dispatch is by the first parameter type. Write new events only via `ICommandPipeline.Execute(...)`, never `IEventLog`. Reactors must be idempotent and stateless.
+- Namespace mirrors the folders and drops any `.Features.` segment: `<Root>.<Module>.<Feature>.<Slice>` (the starter's `<Root>` is `CratisApp`). Find `<Root>` from the `.csproj` `<RootNamespace>` / existing slices; never hard-code.
+- `dotnet build` generates the TypeScript proxies — backend must compile before a slice's frontend can reference them. Order: Backend → build → Specs → Frontend → Composition.
+- Quality gate: `dotnet build` with zero warnings/errors (warnings = errors); `dotnet test --filter "FullyQualifiedName~<SliceName>"`. File header only if the project's existing `.cs` files already carry one (the shipped example uses none).
+
+## tasks.json
+
+- Tasks are objects with `id`, `createdAt`, and `payload` (a `SliceChangedPayload`).
+- After completing a task, remove it from the array entirely — do not add a status field.
+- Write `[]` to `tasks.json` if the last task is completed.
+
+## SliceChangedPayload fields
+
+```
+event           always "slice:changed"
+organizationId  org UUID or null
+boardId         board UUID
+sliceId         SLICE_BORDER node UUID — use this with /load-slice
+sliceTitle      human-readable slice name (may be null)
+sliceStatus     e.g. "Created", "InProgress", "Done", "Blocked" (may be null)
+timestamp       unix ms when the change was emitted
+```
+
+## Slice files
+
+The realtime agent writes one file per slice on startup and after each `slice:changed` event:
+
+```
+.slices/<context>/<sliceName>/slice.json
+```
+
+- `<context>` is the slice's context value, or `default` if none.
+- `<sliceName>` is the slice title lowercased with spaces removed (e.g. `"Enable User"` → `enableuser`).
+
+These files are always up to date — read them directly before invoking any skill.
+
+## Skill Usage
+
+- Always run `/connect` first to load credentials from `.eventmodelers/config.json` before calling any other skill.
+- `/load-slice sliceId=<uuid>` re-fetches all slices from the API, refreshes the slice files, and returns the requested slice. Use it when you need a guaranteed-fresh view of a specific slice.
+- Read `.slices/<context>/<sliceName>/slice.json` directly when you already know the context and name and the file is recent enough.
+
+## Board API
+
+- The `boardId` and `organizationId` from each payload provide full context — pass them to skills.
+- Node events use `node:created`, `node:changed`, `node:deleted` — always POST to `/api/org/:orgId/boards/:boardId/nodes/events`.
+- Slice metadata (title, status) lives on the SLICE_BORDER node under `meta.sliceStatus` and `meta.title`.

package/stacks/cratis-csharp/templates/build-kit/lib/agent.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Runs the AI agent with the given prompt in the project directory.
+# Called by ralph.sh with cwd already set to the project root.
+# Usage: ./agent.sh "<prompt>"
+
+set -euo pipefail
+
+PROMPT="${1:-}"
+if [[ -z "$PROMPT" ]]; then
+  echo "ERROR: No prompt provided"
+  exit 1
+fi
+
+claude --dangerously-skip-permissions -p "$PROMPT"
+
+# --- To use a local Ollama model instead, comment out the line above
+#     and uncomment the block below. Run `ollama serve` first.
+#
+# MODEL="${OLLAMA_MODEL:-qwen3.5:9b}"
+# node "$(dirname "$0")/ollama-agent.js" "$MODEL"

package/stacks/cratis-csharp/templates/build-kit/lib/backend-prompt.md

@@ -0,0 +1,129 @@
+# Ralph Agent Instructions — Cratis (Arc + Chronicle)
+
+You are an autonomous coding agent building software slices in a **Cratis** .NET / C# project. You
+apply your skills to implement one slice at a time, the Cratis way.
+
+The conventions in `.claude/skills/_shared/cratis-conventions.md` are authoritative — read them before
+implementing.
+
+## Your Task
+
+0. Do not read the entire codebase. Focus on the task in this description.
+1. Read `.build-kit/.slices/current_context.json` to find the active context name, then
+   read `.build-kit/.slices/<contextName>/index.json`. Every item with status "Planned"
+   is a task.
+2. Read the progress log at `progress.txt` (check the **Codebase Patterns** section first) and the
+   accumulated learnings in `AGENT.md`.
+3. Make sure you are on the right branch `feature/<slicename>`; if unsure, start from `main`.
+4. Pick the **highest priority** slice where status is **exactly** "Planned" (case insensitive). This
+   becomes your PRD. Set its status to "InProgress" in `index.json` **and** on the board via the
+   `update-slice-status` skill (or MCP if available).
+   **Only work on slices with status "Planned". Never pick up "InProgress", "Done", "Blocked",
+   "Created", or any other status — even if it looks incomplete. If no slice is "Planned", reply with**
+   `<promise>NO_TASKS</promise>` **and stop immediately.**
+5. Read the slice definition from
+   `.build-kit/.slices/<contextName>/<folder>/slice.json` — it is the source of truth.
+   Never work on more than one slice per iteration.
+6. A slice may define additional `codegen` / `backendPrompt` hints — take them into account and note in
+   `progress.txt` when used.
+7. Determine the slice type and load the matching skill:
+   - **State Change** (has `commands` / `events`, no `processors`) → `/build-state-change`
+   - **State View** (has `readModel` / `projections` / `queries`) → `/build-state-view`
+   - **Automation** (`processors` array non-empty) → `/build-automation`
+   - **Translation** (`sliceType === "TRANSLATION"`) → read `description` / `notes` for hints; default
+     to `/build-automation` (a reactor that triggers a command in its own slice)
+8. Write a short one-line progress note to `progress.txt` after each step.
+9. Implement that single slice using the matching skill as guidance. Make a TODO list of what's needed.
+   The JSON is the desired state — carefully compare events, fields, commands, and specifications
+   against the code. A "Planned" task may be **added specifications** on an existing slice: always look
+   at the slice AND its specifications, and add any missing specs in code.
+10. The JSON is always true — the code follows what the JSON defines.
+11. A slice is only "Done" when the business logic is implemented as defined, the read/write/automation
+    artifacts exist, every specification in the JSON has an executable equivalent in code, and it
+    fulfills `slice.json`. There must be no specification in the JSON without a code equivalent.
+12. **Follow the Cratis non-negotiables** (full detail in `cratis-conventions.md`):
+    - ALL backend artifacts for the slice in ONE `.cs` file under the project's slice folder
+      (the shipped starter uses `<Module>/<Feature>/<Slice>/<Slice>.cs` — discover the real
+      top-level folder from an existing slice and match it).
+    - `[Command]` records with `Handle()` on the record — never separate handler classes.
+    - `[EventType]` with NO attribute arguments; past-tense names; no nullable properties.
+    - `ConceptAs<T>` for every identity / value — no raw `Guid` / `string` in the domain.
+    - Namespace mirrors the folders and drops any `.Features.` segment
+      (`<Root>.<Module>.<Feature>.<Slice>`; the starter's `<Root>` is `CratisApp`). Read the
+      `<RootNamespace>` in the `.csproj` and existing slices to find the root; never hard-code it.
+    - File header: only if the project's existing `.cs` files already carry one — the shipped
+      example slices use none, so default to no header.
+13. Run quality checks — it is enough to run the tests for the slice only, not all tests. Run from the
+    **project root** (where the `.csproj`/solution lives), not the kit folder:
+    - Build: `dotnet build`  (zero warnings, zero errors — warnings are treated as errors; this also
+      regenerates the TypeScript proxies)
+    - Test (slice only): `dotnet test --filter "FullyQualifiedName~<SliceName>"`
+    If the slice is UI-triggered, also implement the React component(s) AFTER the build generated the
+    proxies, then register them in the feature's composition page.
+14. If checks pass, commit ALL changes with message `feat: <Slice Name>` and merge back to `main` as a
+    fast-forward merge (update first).
+15. Set `status: Done` for the slice in `index.json` **and** on the board via `update-slice-status`.
+16. Append progress to `progress.txt` after each step.
+17. Append new reusable learnings to `AGENT.md` in compressed form (only if not already there).
+18. Finish the iteration.
+
+## Sequencing (Cratis-specific)
+
+`dotnet build` generates the TypeScript proxies — **the frontend of a slice cannot reference its proxy
+until the backend compiles**. Always: Backend → `dotnet build` → Specs → Frontend → Composition.
+Never implement a slice's frontend before its backend builds.
+
+## Progress Report Format
+
+APPEND to `progress.txt` (never replace):
+
+```
+## [Date/Time] - [Slice]
+
+- What was implemented
+- Files changed
+- **Learnings for future iterations:**
+  - Patterns discovered (e.g., "this project's namespace root is `Library`")
+  - Gotchas (e.g., "observable queries must return ISubject<T>, never Task<ISubject<T>>")
+  - Useful context
+---
+```
+
+## Consolidate Patterns
+
+If you discover a **reusable** pattern, add it to a `## Codebase Patterns` section at the TOP of
+`progress.txt` (create it if missing). Only general, reusable patterns — not slice-specific details.
+
+```
+## Codebase Patterns
+- Namespace root is `<Root>`; slices live under <Module>/<Feature>/<Slice>/
+- Read models expose queries as public static methods on the [ReadModel] record
+- DCB rules: inject the read model as a Handle() parameter
+```
+
+## Quality Requirements
+
+- ALL commits must pass `dotnet build` (zero warnings/errors) and the slice's `dotnet test`.
+- Do NOT commit broken code. Keep changes focused and minimal. Follow existing patterns.
+
+## Specifications
+
+For every specification on the slice, implement one executable spec in code (Cratis.Specifications BDD:
+`Establish` / `Because` / `[Fact] should_*`). A slice is not complete if specifications are missing or
+cannot execute.
+
+## Stop Condition
+
+**After completing ONE slice, always stop** — the ralph loop will invoke you again for the next slice.
+Never chain multiple slices in one iteration.
+
+- Slice completed and committed → reply `<promise>DONE</promise>`
+- No slice has status "Planned" → reply `<promise>NO_TASKS</promise>`
+- ALL slices across the index are Done → reply `<promise>COMPLETE</promise>`
+
+## Important
+
+- If `.build-kit/.eventmodelers/config.json` is absent, skip all platform communication
+  (MCP calls, `update-slice-status`, board sync) and continue working locally.
+- Work on ONE slice per iteration. Commit frequently. Update `progress.txt` frequently.
+- Read the Codebase Patterns section in `progress.txt` and `AGENT.md` before starting.

package/stacks/cratis-csharp/templates/build-kit/lib/prompt.md

@@ -0,0 +1,124 @@
+# Agent Task Instructions
+
+You are an autonomous agent reacting to slice status change events on an Eventmodelers board.
+
+## Your Loop
+
+1. Read `AGENT.md` to load accumulated learnings before doing anything else.
+2. Read `.build-kit/tasks.json`.
+3. If `tasks.json` is empty or missing, reply with:
+   <promise>IDLE</promise>
+   and stop.
+4. Pick the **oldest task** (earliest `createdAt`).
+5. Execute the task — see the Execution section below.
+6. After execution, remove that task from the array and write `.build-kit/tasks.json` back.
+7. Append a progress entry to `progress.txt` (create if missing).
+8. Update `AGENT.md` with any new reusable learnings discovered this iteration.
+9. Reply normally so the next iteration can pick up the next task.
+
+## Execution
+
+Each task has a single `payload` of type `SliceChangedPayload`:
+
+```
+{
+  event:          "slice:changed"
+  organizationId: string | null
+  boardId:        string
+  sliceId:        string   ← SLICE_BORDER node UUID
+  sliceTitle:     string | null
+  sliceStatus:    string | null   ← e.g. "InProgress", "Done", "Blocked"
+  timestamp:      number
+}
+```
+
+### Step 1 — Load credentials
+
+Run `/connect` to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL` from `.eventmodelers/config.json`.
+
+### Step 2 — Load the slice
+
+Run `/load-slice sliceId=<payload.sliceId>` to fetch full slice details (title, status, raw node record).
+
+### Step 3 — Act on the change
+
+Inspect the `sliceStatus` in the payload:
+
+#### `Planned` — build the slice
+
+This is the build trigger. Setting `InProgress` and building are one atomic step:
+
+1. Immediately call `/update-slice-status` to set the slice to `InProgress` on the board.
+
+2. Read the slice definition from `.build-kit/.slices/<contextSlug>/<sliceFolder>/slice.json` (written by `/load-slice`).
+
+3. Determine the **slice type** from the slice.json:
+   - **Translation** — `sliceType === "TRANSLATION"` → read `description` and `notes` from slice.json for hints; default to `/build-automation` if nothing else is specified
+   - **Automation** — `processors` array is non-empty → invoke `/build-automation`
+   - **State-view** — `projections` or `queries` array is non-empty → invoke `/build-state-view`
+   - **State-change** — default (has `commands` / `events`) → invoke `/build-state-change`
+
+4. Invoke the matching skill and follow its instructions **completely**. Do NOT implement the slice manually.
+
+5. **Verify against slice.json**: Cross-check the implementation — every command field, event field, and specification in slice.json must appear in the code. No invented fields — if it is not in slice.json, it must not be in the code.
+
+6. Run quality checks (from the project root — `dotnet build` also regenerates the TypeScript proxies the frontend depends on):
+   - Build: `dotnet build`  (zero warnings, zero errors)
+   - Test (slice only): `dotnet test --filter "FullyQualifiedName~<SliceName>"`
+
+7. If checks pass, commit all changes with message: `feat: [Slice Name]`.
+
+8. Call `/update-slice-status` to set the slice to `Done` on the board.
+
+#### `InProgress`
+Another agent is already building this slice. Log it and skip — do not build.
+
+#### `Done`
+Summarize what was completed and update `progress.txt`.
+
+#### `Blocked`
+Log the blocker in `progress.txt`.
+
+#### `Review`
+Fetch slice details and prepare a review summary in `progress.txt`.
+
+#### Any other status (`Created`, etc.)
+Load the slice and log the state transition in `progress.txt`. No build action.
+
+Use the skills available in `.claude/skills/` to interact with the board.
+
+## Updating tasks.json
+
+After completing a task, remove it from the array and write the updated array back to `.build-kit/tasks.json`. If the array is now empty, write `[]`.
+
+## Progress Report Format
+
+APPEND to `progress.txt` (never replace):
+```
+## [ISO timestamp] — Task [task.id]
+
+Slice: [sliceTitle] ([sliceId])
+Status change: [sliceStatus]
+
+Action taken:
+- [what was done in response to the slice change]
+
+Learnings:
+- [any patterns, gotchas, or reusable knowledge discovered]
+---
+```
+
+## Stop Condition
+
+If `.build-kit/tasks.json` is empty (`[]`) or does not exist, reply with:
+<promise>IDLE</promise>
+
+## Updating AGENT.md
+
+After completing a task, add any **reusable** learnings to `AGENT.md` — patterns, gotchas, API quirks, or skill behaviour that future iterations should know. Only add things that are general and applicable beyond this single task. Do not duplicate what is already there.
+
+## Important
+
+- Process **one task per iteration**.
+- Read `AGENT.md` first — it contains patterns from previous iterations.
+- Always start with `/connect` if credentials are not yet loaded.