coulomb/railiance-infra
0
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

Refresh agent instruction files

Browse Source
This commit is contained in:
Bernd Worsch
2026-05-18 16:55:51 +02:00
parent 5c69f01dc5
commit ab26028a42
10 changed files with 348 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
.claude/rules/agents.md Normal file
View File

@@ -0,0 +1,20 @@
## Kaizen Agents
Specialized agent personas available on demand via the state-hub MCP.
**Discover:** `list_kaizen_agents()` — returns all agents with name, description, category
**Load:** `get_kaizen_agent("tdd-workflow")` — returns full instructions; read and follow them
Common agents:
| Agent | Category | When to use |
|-------|----------|-------------|
| `tdd-workflow` | testing | Step-by-step TDD8 workflow for any feature |
| `code-refactoring` | quality | Code quality analysis and safe refactoring |
| `test-maintenance` | testing | Diagnose and fix failing tests |
| `requirements-engineering` | process | Prevent interface/mock mismatches upfront |
| `keepaTodofile` | process | Maintain TODO.md during work |
| `project-management` | process | Track status, determine next steps |
| `datamodel-optimization` | quality | Optimize dataclasses and data structures |
All 17 agents: call `list_kaizen_agents()` for the full list.

8
.claude/rules/architecture.md Normal file
View File

@@ -0,0 +1,8 @@
## Architecture
<!-- TODO: Describe the key design decisions and component structure.
Key modules, data flows, external integrations, state machines, etc. -->
## Quick Reference
`~/state-hub/mcp_server/TOOLS.md` — MCP tool reference

38
.claude/rules/first-session.md Normal file
View File

@@ -0,0 +1,38 @@
## First Session Protocol
Triggered when `get_domain_summary("railiance")` shows **no workstreams**.
The project is registered but work has not yet been structured.
**Step 1 — Read, don't write**
- `~/the-custodian/canon/projects/railiance/project_charter_v0.1.md` — purpose, scope
- `~/the-custodian/canon/projects/railiance/roadmap_v0.1.md` — planned phases
- Scan repo root: README, directory structure, existing code or docs
**Step 2 — Survey in-progress work**
Look for TODOs, open branches, half-finished files. Note done vs. started but incomplete.
**Step 3 — Propose workstreams to Bernd**
Propose 1–3 workstreams — each a coherent strand, weeks to months, anchored to a
roadmap phase. **Wait for approval before creating.**
**Step 4 — Create workplan file first, then DB record (ADR-001)**
```
workplans/railiance-hosts-WP-NNNN-<slug>.md ← write this first
```
Then register in the hub:
```
create_workstream(topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38", title="...", owner="...", description="...")
create_task(workstream_id="<id>", title="...", priority="high|medium|low")
```
**Step 5 — Record the setup**
```
add_progress_event(
summary="First session: structured railiance into N workstreams, M tasks",
event_type="milestone",
topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38",
detail={"workstreams": [...], "tasks_created": M}
)
```
<!-- Delete or archive this file once past first session -->

8
.claude/rules/repo-boundary.md Normal file
View File

@@ -0,0 +1,8 @@
## Repo boundary
This repo owns **railiance-hosts** only. It does not own:
<!-- TODO: List what belongs in adjacent repos, e.g.:
- SSH key management → railiance-infra/
- State hub code → state-hub/
-->

5
.claude/rules/repo-identity.md Normal file
View File

@@ -0,0 +1,5 @@
**Purpose:** Host inventory and node-level configuration for railiance infrastructure. Tracks server specs, network topology, and per-host service assignments.
**Domain:** railiance
**Repo slug:** railiance-hosts
**Topic ID:** ca369340-a64e-442e-98f1-a4fa7dc74a38

84
.claude/rules/session-protocol.md Normal file
View File

@@ -0,0 +1,84 @@
## Session Protocol
State Hub: http://127.0.0.1:8000
**Step 1 — Orient**
Read the offline-safe brief first — it works without a live hub connection:
```bash
cat .custodian-brief.md
```
Then call the MCP tool for richer cross-domain context when MCP tools are exposed:
```
get_domain_summary("railiance")
```
If MCP tools are unavailable in the current agent session, use the REST API:
```bash
curl -s "http://127.0.0.1:8000/state/summary" | python3 -m json.tool
```
If the hub is offline: `cd ~/state-hub && make api`
**Step 2 — Check inbox**
With MCP tools:
```
get_messages(to_agent="railiance-hosts", unread_only=True)
```
Mark read with `mark_message_read(message_id)`. Reply or act on coordination
requests before proceeding.
Without MCP tools:
```bash
curl -s "http://127.0.0.1:8000/messages/?to_agent=railiance-hosts&unread_only=true" \
| python3 -m json.tool
curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
-H "Content-Type: application/json" -d '{}'
```
**Step 3 — Scan workplans**
```bash
ls workplans/
```
For each file with `status: ready`, `active`, or `blocked`, note pending
`todo`/`in_progress` tasks.
**Step 4 — Present brief**
1. **Active workstreams** for `railiance` — title, task counts, blocking decisions
2. **Pending tasks** from `workplans/` + any `[repo:railiance-hosts]` hub tasks
3. **Goal guidance** — if `goal_guidance` in summary:
- `needs_workplan`: surface as top action — *"Repo goal '{title}' has no workplan yet"*
- `alignment_warnings`: flag if active work is not aligned with current goal
4. **Suggested next action** — highest-priority open item
5. **SBOM status** — flag if `last_sbom_at` is unset for this repo
If no workstreams: follow First Session Protocol (`first-session.md`).
**During work:** `record_decision()` · `add_progress_event()` · `resolve_decision()`
> State Hub is a *read model*. Bootstrap tools (`create_workstream`, `create_task`)
> are First Session Protocol only. Work structure belongs in repo files (ADR-001).
**Session close:**
With MCP tools:
```
add_progress_event(summary="...", topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38", workstream_id="<uuid>")
```
Without MCP tools:
```bash
curl -s -X POST http://127.0.0.1:8000/progress/ \
-H "Content-Type: application/json" \
-d '{"topic_id":"ca369340-a64e-442e-98f1-a4fa7dc74a38","workstream_id":"<uuid>","event_type":"note","summary":"what changed","author":"codex"}'
```
If workplan files were modified, ensure the local copy is up to date first:
```bash
git -C <repo_path> pull --ff-only
cd ~/state-hub && make fix-consistency REPO=railiance-hosts
```
For repos where implementation runs on a remote machine (e.g. CoulombCore),
use the combined target which pulls before fixing:
```bash
cd ~/state-hub && make fix-consistency-remote REPO=railiance-hosts
```
**C-15** (DB task ahead of file) is normal in multi-machine workflows — writeback
will sync the file to match DB. **C-16** (repo behind remote) blocks all writes
until you pull — intentional to prevent clobbering remote progress.

19
.claude/rules/stack-and-commands.md Normal file
View File

@@ -0,0 +1,19 @@
## Stack
<!-- TODO: Fill in language, frameworks, and key dependencies -->
- **Language:**
- **Key deps:**
## Dev Commands
```bash
# TODO: Fill in the standard commands for this repo
# Install dependencies
# Run tests
# Lint / type check
# Build / package (if applicable)
```

28
.claude/rules/workplan-convention.md Normal file
View File

@@ -0,0 +1,28 @@
## Workplan Convention (ADR-001)
File location: `workplans/railiance-hosts-WP-NNNN-<slug>.md`
ID prefix: `RAILIANCE-WP`
Work items originate as files in this repo **before** being registered in the hub.
Canonical workplan/workstream frontmatter statuses are:
`proposed`, `ready`, `active`, `blocked`, `backlog`, `finished`, `archived`.
Use `proposed` for a newly drafted plan, `ready` after review against current
repo state, and `finished` when implementation is complete. `stalled` and
`needs_review` are derived health labels, not stored statuses.
Closed workplans may be moved to `workplans/archived/` with a completion-date
prefix: `YYMMDD-railiance-hosts-WP-NNNN-<slug>.md`. The frontmatter id remains
unchanged; the prefix is only for quick visual reference.
Small opportunistic tasks discovered during another session use **Ad Hoc Tasks**:
`workplans/ADHOC-YYYY-MM-DD.md`, workstream slug `adhoc-YYYY-MM-DD`, and task ids
`ADHOC-YYYY-MM-DD-T01`, `T02`, etc. Use adhocs only for low-risk work completed
directly. Promote anything requiring analysis, design, approval, dependencies, or
multiple planned phases into a normal workplan.
Ecosystem todos from other agents arrive as `[repo:railiance-hosts]` hub tasks —
visible at session start. Pick one up by creating the workplan file, then registering
the workstream.
<!-- Ralph Loop rules and HEUREKA sequence: ~/.claude/CLAUDE.md — do not duplicate here -->

308
AGENTS.md
View File

@@ -1,214 +1,162 @@
# railiance-infra — Codex Instructions # railiance-hosts — Agent Instructions
## Custodian State Hub Integration ## Repo Identity
This project is tracked as the **railiance** domain in the Custodian State Hub. **Purpose:** Host inventory and node-level configuration for railiance infrastructure. Tracks server specs, network topology, and per-host service assignments.
Hub topic ID: `ca369340-a64e-442e-98f1-a4fa7dc74a38`
The State Hub runs locally at http://127.0.0.1:8000. The MCP server (`state-hub`) **Domain:** railiance
exposes tools for reading and writing state without touching the API directly. **Repo slug:** railiance-hosts
**Topic ID:** `ca369340-a64e-442e-98f1-a4fa7dc74a38`
**Workplan prefix:** `RAILIANCE-WP-`
--- ---
### Session Protocol ## State Hub Integration
**On receiving your first message — before writing any response text — execute The Custodian State Hub tracks work across all domains. Interact via HTTP REST —
this orientation sequence. Do not greet, do not ask what to do first.** there is no MCP server for Codex agents.
**Step 1 — Call the State Hub** | Context | URL |
|---------|-----|
| Local workstation | `http://127.0.0.1:8000` |
| Remote via tunnel | `http://127.0.0.1:18000` |
### Orient at session start
```bash
# Offline brief — works without hub connection
cat .custodian-brief.md
# Active workstreams for this domain
curl -s "http://127.0.0.1:8000/workstreams/?topic_id=ca369340-a64e-442e-98f1-a4fa7dc74a38&status=active" \
| python3 -m json.tool
# Check inbox
curl -s "http://127.0.0.1:8000/messages/?to_agent=railiance-hosts&unread_only=true" \
| python3 -m json.tool
``` ```
get_domain_summary("railiance") # workstreams, blocking decisions, recent progress, SBOM status
Mark a message read:
```bash
curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
-H "Content-Type: application/json" -d '{}'
``` ```
If the call fails, the API is offline: `cd ~/the-custodian/state-hub && make api`
**Step 2 — Scan local workplans** ### Log progress (required at session close)
Read every `.md` file under `workplans/`. Use `Glob(pattern="**/*.md", path="workplans/")` ```bash
or Bash `ls workplans/` to discover them. For each file with `status: active`, curl -s -X POST http://127.0.0.1:8000/progress/ \
extract and note: -H "Content-Type: application/json" \
- The workplan title and ID -d '{
- All tasks whose `status` is `todo` or `in_progress` "summary": "what was done",
"event_type": "note",
"author": "codex",
"workstream_id": "<uuid>",
"task_id": "<uuid>"
}'
```
**Step 3 — Present orientation to the user** Omit `workstream_id` / `task_id` when not applicable.
Output a concise brief covering: ### Update task status
1. **Active workstreams** (from state hub) for the `railiance` domain — title,
task counts, any blocking decisions
2. **Pending tasks for this repo** — from local `workplans/` files (Step 2)
plus any state hub tasks with `[repo:railiance-infra]` in their title
3. **Goal guidance** — if the summary contains a `goal_guidance` key, act on it:
- **`needs_workplan`** entries: for each active repo goal with no linked workstream,
surface it as the top suggested action — *"Repo goal '{title}' has no workplan yet.
Suggest: create workplans/RAIL-HO-WP-NNNN-<slug>.md and register a workstream
with repo_goal_id='{goal_id}'"*. Treat this as higher priority than continuing
existing work unless Bernd says otherwise.
- **`alignment_warnings`** entries: if active workstreams exist but are not linked
to the current repo goal, name the most recently active one and note:
*"Current work on '{recent_workstream_title}' may not be aligned with the active
goal '{active_goal_title}'. Continue unless you hear otherwise — but flag it."*
4. **Suggested next action** — the highest-priority open item across all sources,
with goal alignment taken into account
5. **SBOM status** — is `last_sbom_at` set for this repo? If not, note it as a gap
If there are no workstreams at all: follow the First Session Protocol below. ```bash
curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
-H "Content-Type: application/json" \
-d '{"status": "in_progress"}'
# values: todo | in_progress | done | blocked
```
### Flag a task for human review
```bash
curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
-H "Content-Type: application/json" \
-d '{"needs_human": true, "intervention_note": "reason"}'
```
---
## Session Protocol
**Start:**
1. `cat .custodian-brief.md` — domain goal and open workstreams (offline-safe)
2. Check inbox: `GET /messages/?to_agent=railiance-hosts&unread_only=true`; mark read
3. Scan workplans: `ls workplans/` — note `status: ready`, `active`, or `blocked` files and open tasks
4. Check blocked tasks: `GET /tasks/?needs_human=true`
**During work:** **During work:**
- Use `record_decision()` for any decision that affects direction or dependencies. - Update task statuses in workplan files as tasks progress
- Use `add_progress_event()` for notable events (milestones, blockers, insights). - Record significant decisions via `POST /decisions/`
- Use `resolve_decision()` to close a decision once the choice is made.
> **Design boundary:** The State Hub is a *read model*. Two write operations are **Close:**
> permanently sanctioned: **Resolving Decisions** and **Suggesting Next Steps**. 1. Update workplan file task statuses to reflect progress
> The bootstrap tools (`create_workstream`, `create_task`, `update_task_status`) 2. Log: `POST /progress/` with a summary of what changed
> are only for First Session Protocol. Formal work structure — workplans, tasks — 3. Note for the custodian operator: after workplan file changes, run from
> belongs in the domain repo as files (ADR-001), not managed through the hub alone. `~/state-hub`:
```bash
**At the end of every session:** make fix-consistency REPO=railiance-hosts
- Call `add_progress_event()` with a summary of what was accomplished or decided. ```
Include `topic_id: ca369340-a64e-442e-98f1-a4fa7dc74a38` and the relevant `workstream_id`. This syncs task status from files into the hub DB.
--- ---
### Repo Boundary Rule ## Workplan Convention (ADR-001)
This agent is responsible for files **in this repo only**. Work items originate as files in this repo — not in the hub. The hub is a
read/cache/index layer that rebuilds from files.
- **Do not** write files or make commits in any other repository **File location:** `workplans/RAILIANCE-WP-NNNN-<slug>.md`
- **Do not** create workplan files in other repos on their behalf
- When you identify work for another registered repo (**ecosystem todo**):
create a state hub task with `[repo:<slug>]` in the title — the other repo's
agent will see it at session start and create its own workplan
- When you identify work for an upstream repo (**third-party todo**):
create a contribution artifact in `contrib/` and register it
Terminology and workflows: `http://localhost:3000/docs/inter-repo-communication` **Archived location:** finished workplans may move to
`workplans/archived/YYMMDD-RAILIANCE-WP-NNNN-<slug>.md`. The `YYMMDD` prefix is
the completion/archive date; the frontmatter `id` does not change.
**Ad Hoc Tasks:** small opportunistic fixes discovered during a session use
`workplans/ADHOC-YYYY-MM-DD.md` with task ids `ADHOC-YYYY-MM-DD-T01`, etc. Use
this only for low-risk work completed directly; create a normal workplan for
anything needing analysis, design, approval, dependencies, or multiple phases.
**Frontmatter:**
```yaml
--- ---
id: RAILIANCE-WP-NNNN
### First Session Protocol type: workplan
title: "..."
Triggered when `get_domain_summary("railiance")` shows **no workstreams** for the `railiance` domain: railiance
topic. The project is registered but work has not yet been structured. repo: railiance-hosts
status: proposed | ready | active | blocked | backlog | finished | archived
**Step 1 — Understand the project (read, don't write)** owner: codex
- `~/the-custodian/canon/projects/railiance/project_charter_v0.1.md` — purpose, scope topic_slug: ...
- `~/the-custodian/canon/projects/railiance/roadmap_v0.1.md` — planned phases created: "YYYY-MM-DD"
- Scan the repo root: README, directory structure, existing code or docs updated: "YYYY-MM-DD"
state_hub_workstream_id: "<uuid>" # written by fix-consistency — do not edit
**Step 2 — Survey in-progress work**
- Look for TODOs, open branches, half-finished files, notes
- Note what is already done vs. what is clearly started but incomplete
**Step 3 — Propose workstreams to Bernd**
Propose 1–3 workstreams — each a coherent strand of work lasting weeks to months,
named clearly, anchored to a roadmap phase. **Wait for approval before creating.**
**Step 4 — Create workplan file first, then DB record**
Per ADR-001, work items originate as files in the repo:
```
workplans/RAIL-HO-WP-NNNN-<slug>.md ← write this first
```
Then register in the hub:
```
create_workstream(topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38", title="...", owner="...", description="...")
create_task(workstream_id="<id>", title="...", priority="high|medium|low")
```
**Step 5 — Record the setup**
```
add_progress_event(
summary="First session: structured railiance work into N workstreams, M tasks",
event_type="milestone",
topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38",
detail={"workstreams": [...], "tasks_created": M}
)
```
--- ---
### Workplan Convention (ADR-001)
Work items MUST originate as files in this repo before being registered in the hub.
**File location:** `workplans/<ID>-<slug>.md`
**Frontmatter required:** `id`, `type: workplan`, `domain`, `repo`, `status`,
`state_hub_workstream_id`, `state_hub_task_id` (per task)
When another domain's agent identifies work for this repo, it creates a state hub
task with `[repo:railiance-infra]` in the title (an **ecosystem todo**). You will
see it at session start via `get_domain_summary("railiance")`. When you pick it up, create
the corresponding workplan file in `workplans/` (ADR-001) and begin work.
---
### Contribution Tracking
Track upstream contributions in `contrib/` — bug reports (BR), feature requests
(FR), extension-point proposals (EP), upstream PRs (UPR).
```
contrib/
bug-reports/ # br-YYYY-MM-DD--org--repo--slug.md
feature-requests/ # fr-YYYY-MM-DD--org--repo--slug.md
extension-points/ # EP-RAIL-NNN--org--repo--slug.md
upstream-prs/ # upr-YYYY-MM-DD--org--repo--slug.md
``` ```
Templates: `~/the-custodian/canon/standards/contrib-templates/` Use `proposed` for a new draft, `ready` after review against current repo
Convention: `~/the-custodian/canon/standards/contribution-convention_v0.1.md` state, and `finished` after implementation. `stalled` and `needs_review` are
derived health labels, not frontmatter statuses.
**Task block format** (one per `##` section):
``` ```
register_contribution(type="br|fr|ep|upr", title="...", target_org="...", ## Task Title
target_repo="...", body_path="contrib/...", related_workstream_id="<uuid>")
update_contribution_status(contribution_id="<uuid>", status="submitted") ` ` `task
id: RAILIANCE-WP-NNNN-T01
status: todo | in_progress | done | blocked
priority: high | medium | low
state_hub_task_id: "<uuid>" # written by fix-consistency — do not edit
` ` `
Task description text.
``` ```
--- Status progression: `todo` → `in_progress` → `done` (or `blocked`)
### SBOM To create a new workplan:
1. Write the file following the format above
After updating dependencies, re-ingest the SBOM: 2. Notify the custodian operator to run `make fix-consistency REPO=railiance-hosts`
```bash (or send a message to the hub agent via `POST /messages/`)
cd ~/the-custodian/state-hub
make ingest-sbom REPO=railiance-infra SCAN=1 REPO_PATH=$(pwd)
```
Check compliance: `http://localhost:3000/repos`
Standard: `~/the-custodian/canon/standards/sbom-convention_v0.1.md`
---
### Remote Execution & State Hub Tunnel
This repo is designed to be worked on **from the HostEurope server** (or any
remote Linux box with access to the managed hosts). The State Hub runs locally
on Bernd's workstation at `127.0.0.1:8000` and is not publicly reachable.
**Before SSHing to the remote server, start a reverse tunnel on your local machine:**
```bash
ssh -R 8000:127.0.0.1:8000 <user>@<remote-host>
```
This forwards the remote's `localhost:8000` back to your local State Hub.
Codex on the remote host then reaches the MCP server and `get_domain_summary`
work as normal.
**Verify the tunnel is live from the remote:**
```bash
curl http://127.0.0.1:8000/state/health
# expected: {"status":"ok"}
```
**If the tunnel is not up (degraded mode):**
The State Hub call in Step 1 will fail. In that case:
- Skip Step 1 — proceed from local workplans only (Step 2)
- Note that goal guidance and progress logging will be unavailable
- Log any progress events manually from your local machine after the session
---
### Quick Reference
`~/the-custodian/state-hub/mcp_server/TOOLS.md` — compact MCP tool reference

223
CLAUDE.md
View File

@@ -1,214 +1,11 @@
# railiance-infra — Claude Code Instructions # railiance-hosts — Claude Code Instructions
## Custodian State Hub Integration @SCOPE.md
@.claude/rules/repo-identity.md
This project is tracked as the **railiance** domain in the Custodian State Hub. @.claude/rules/session-protocol.md
Hub topic ID: `ca369340-a64e-442e-98f1-a4fa7dc74a38` @.claude/rules/first-session.md
@.claude/rules/workplan-convention.md
The State Hub runs locally at http://127.0.0.1:8000. The MCP server (`state-hub`) @.claude/rules/stack-and-commands.md
exposes tools for reading and writing state without touching the API directly. @.claude/rules/architecture.md
@.claude/rules/repo-boundary.md
--- @.claude/rules/agents.md
### Session Protocol
**On receiving your first message — before writing any response text — execute
this orientation sequence. Do not greet, do not ask what to do first.**
**Step 1 — Call the State Hub**
```
get_domain_summary("railiance") # workstreams, blocking decisions, recent progress, SBOM status
```
If the call fails, the API is offline: `cd ~/the-custodian/state-hub && make api`
**Step 2 — Scan local workplans**
Read every `.md` file under `workplans/`. Use `Glob(pattern="**/*.md", path="workplans/")`
or Bash `ls workplans/` to discover them. For each file with `status: active`,
extract and note:
- The workplan title and ID
- All tasks whose `status` is `todo` or `in_progress`
**Step 3 — Present orientation to the user**
Output a concise brief covering:
1. **Active workstreams** (from state hub) for the `railiance` domain — title,
task counts, any blocking decisions
2. **Pending tasks for this repo** — from local `workplans/` files (Step 2)
plus any state hub tasks with `[repo:railiance-infra]` in their title
3. **Goal guidance** — if the summary contains a `goal_guidance` key, act on it:
- **`needs_workplan`** entries: for each active repo goal with no linked workstream,
surface it as the top suggested action — *"Repo goal '{title}' has no workplan yet.
Suggest: create workplans/RAIL-HO-WP-NNNN-<slug>.md and register a workstream
with repo_goal_id='{goal_id}'"*. Treat this as higher priority than continuing
existing work unless Bernd says otherwise.
- **`alignment_warnings`** entries: if active workstreams exist but are not linked
to the current repo goal, name the most recently active one and note:
*"Current work on '{recent_workstream_title}' may not be aligned with the active
goal '{active_goal_title}'. Continue unless you hear otherwise — but flag it."*
4. **Suggested next action** — the highest-priority open item across all sources,
with goal alignment taken into account
5. **SBOM status** — is `last_sbom_at` set for this repo? If not, note it as a gap
If there are no workstreams at all: follow the First Session Protocol below.
**During work:**
- Use `record_decision()` for any decision that affects direction or dependencies.
- Use `add_progress_event()` for notable events (milestones, blockers, insights).
- Use `resolve_decision()` to close a decision once the choice is made.
> **Design boundary:** The State Hub is a *read model*. Two write operations are
> permanently sanctioned: **Resolving Decisions** and **Suggesting Next Steps**.
> The bootstrap tools (`create_workstream`, `create_task`, `update_task_status`)
> are only for First Session Protocol. Formal work structure — workplans, tasks —
> belongs in the domain repo as files (ADR-001), not managed through the hub alone.
**At the end of every session:**
- Call `add_progress_event()` with a summary of what was accomplished or decided.
Include `topic_id: ca369340-a64e-442e-98f1-a4fa7dc74a38` and the relevant `workstream_id`.
---
### Repo Boundary Rule
This agent is responsible for files **in this repo only**.
- **Do not** write files or make commits in any other repository
- **Do not** create workplan files in other repos on their behalf
- When you identify work for another registered repo (**ecosystem todo**):
create a state hub task with `[repo:<slug>]` in the title — the other repo's
agent will see it at session start and create its own workplan
- When you identify work for an upstream repo (**third-party todo**):
create a contribution artifact in `contrib/` and register it
Terminology and workflows: `http://localhost:3000/docs/inter-repo-communication`
---
### First Session Protocol
Triggered when `get_domain_summary("railiance")` shows **no workstreams** for the `railiance`
topic. The project is registered but work has not yet been structured.
**Step 1 — Understand the project (read, don't write)**
- `~/the-custodian/canon/projects/railiance/project_charter_v0.1.md` — purpose, scope
- `~/the-custodian/canon/projects/railiance/roadmap_v0.1.md` — planned phases
- Scan the repo root: README, directory structure, existing code or docs
**Step 2 — Survey in-progress work**
- Look for TODOs, open branches, half-finished files, notes
- Note what is already done vs. what is clearly started but incomplete
**Step 3 — Propose workstreams to Bernd**
Propose 1–3 workstreams — each a coherent strand of work lasting weeks to months,
named clearly, anchored to a roadmap phase. **Wait for approval before creating.**
**Step 4 — Create workplan file first, then DB record**
Per ADR-001, work items originate as files in the repo:
```
workplans/RAIL-HO-WP-NNNN-<slug>.md ← write this first
```
Then register in the hub:
```
create_workstream(topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38", title="...", owner="...", description="...")
create_task(workstream_id="<id>", title="...", priority="high|medium|low")
```
**Step 5 — Record the setup**
```
add_progress_event(
summary="First session: structured railiance work into N workstreams, M tasks",
event_type="milestone",
topic_id="ca369340-a64e-442e-98f1-a4fa7dc74a38",
detail={"workstreams": [...], "tasks_created": M}
)
```
---
### Workplan Convention (ADR-001)
Work items MUST originate as files in this repo before being registered in the hub.
**File location:** `workplans/<ID>-<slug>.md`
**Frontmatter required:** `id`, `type: workplan`, `domain`, `repo`, `status`,
`state_hub_workstream_id`, `state_hub_task_id` (per task)
When another domain's agent identifies work for this repo, it creates a state hub
task with `[repo:railiance-infra]` in the title (an **ecosystem todo**). You will
see it at session start via `get_domain_summary("railiance")`. When you pick it up, create
the corresponding workplan file in `workplans/` (ADR-001) and begin work.
---
### Contribution Tracking
Track upstream contributions in `contrib/` — bug reports (BR), feature requests
(FR), extension-point proposals (EP), upstream PRs (UPR).
```
contrib/
bug-reports/ # br-YYYY-MM-DD--org--repo--slug.md
feature-requests/ # fr-YYYY-MM-DD--org--repo--slug.md
extension-points/ # EP-RAIL-NNN--org--repo--slug.md
upstream-prs/ # upr-YYYY-MM-DD--org--repo--slug.md
```
Templates: `~/the-custodian/canon/standards/contrib-templates/`
Convention: `~/the-custodian/canon/standards/contribution-convention_v0.1.md`
```
register_contribution(type="br|fr|ep|upr", title="...", target_org="...",
target_repo="...", body_path="contrib/...", related_workstream_id="<uuid>")
update_contribution_status(contribution_id="<uuid>", status="submitted")
```
---
### SBOM
After updating dependencies, re-ingest the SBOM:
```bash
cd ~/the-custodian/state-hub
make ingest-sbom REPO=railiance-infra SCAN=1 REPO_PATH=$(pwd)
```
Check compliance: `http://localhost:3000/repos`
Standard: `~/the-custodian/canon/standards/sbom-convention_v0.1.md`
---
### Remote Execution & State Hub Tunnel
This repo is designed to be worked on **from the HostEurope server** (or any
remote Linux box with access to the managed hosts). The State Hub runs locally
on Bernd's workstation at `127.0.0.1:8000` and is not publicly reachable.
**Before SSHing to the remote server, start a reverse tunnel on your local machine:**
```bash
ssh -R 8000:127.0.0.1:8000 <user>@<remote-host>
```
This forwards the remote's `localhost:8000` back to your local State Hub.
Claude on the remote host then reaches the MCP server and `get_domain_summary`
work as normal.
**Verify the tunnel is live from the remote:**
```bash
curl http://127.0.0.1:8000/state/health
# expected: {"status":"ok"}
```
**If the tunnel is not up (degraded mode):**
The State Hub call in Step 1 will fail. In that case:
- Skip Step 1 — proceed from local workplans only (Step 2)
- Note that goal guidance and progress logging will be unavailable
- Log any progress events manually from your local machine after the session
---
### Quick Reference
`~/the-custodian/state-hub/mcp_server/TOOLS.md` — compact MCP tool reference