Register frontend pattern research and establish preliminary intent

Assistant: codex
Assistant-Model: gpt-6-astra
Assistant-Session: 01a0cffe-206f-7323-89d3-b20ca4cf4bf9
This commit is contained in:
tegwick 2026-09-23 22:44:01 +02:00
parent 9c8a49212a
commit cbe82f806b
8 changed files with 592 additions and 0 deletions

5
.gitignore vendored Normal file
View file

@ -0,0 +1,5 @@
# state-hub: track .claude/rules
# Claude Code local state (track shared rules; ignore machine-specific files)
.claude/*
!.claude/rules/
!.claude/rules/*.md

View file

@ -0,0 +1,6 @@
category: research
domain: infotech
capability_tags:
- frontend-architecture
- pattern-language
- knowledge-representation

265
AGENTS.md Normal file
View file

@ -0,0 +1,265 @@
# frontend-patterns — Agent Instructions
## Repo Identity
**Purpose:** Framework-independent frontend architecture pattern language for human and agent reference.
**Domain:** infotech
**Repo slug:** frontend-patterns
**Topic ID:** `fe2aaa78-9c20-4feb-b3d2-4fe0529572a3`
**Workplan prefix:** `FEP-WP-`
---
## State Hub Integration
The Custodian State Hub tracks work across all domains. Codex uses HTTP REST and
the `statehub` CLI by default. MCP is opt-in because the current Codex MCP bridge
adds severe call latency; the full administrative MCP surface remains available
to clients that need it.
| Context | URL |
|---------|-----|
| Local workstation | `http://127.0.0.1:8000` |
| Remote via tunnel | `http://127.0.0.1:18000` |
| Optional local edge relay | http://127.0.0.1:18080 |
When an operator has enabled the edge relay, set API_BASE to the relay URL.
Queueable writes return an explicit queued receipt if the central hub is
unreachable. Treat that as pending local evidence, then ask the operator to run
statehub outbox status/replay after connectivity returns.
Codex workspace-write sandboxes need network access enabled to reach the host's
loopback listener. Bootstrap this once with `make -C ~/state-hub configure-codex`
and restart Codex. The canonical REST health endpoint is `/state/health`, not
`/health`. If a sandboxed loopback probe fails, retry it with escalated execution
before declaring State Hub unavailable; a managed Codex permission profile may
still enforce isolated networking. Experimental MCP can be enabled explicitly
with `make -C ~/state-hub configure-codex WITH_MCP=1`.
### Orient at session start
```bash
# Offline brief — works without hub connection
cat .custodian-brief.md
# Active workplans for this domain
curl -s "http://127.0.0.1:8000/workplans/?topic_id=fe2aaa78-9c20-4feb-b3d2-4fe0529572a3&status=active" \
| python3 -m json.tool
# Check inbox
curl -s "http://127.0.0.1:8000/messages/?to_agent=frontend-patterns&unread_only=true" \
| python3 -m json.tool
```
Mark a message read:
```bash
curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
-H "Content-Type: application/json" -d '{}'
```
### Log progress (required at session close)
```bash
curl -s -X POST http://127.0.0.1:8000/progress/ \
-H "Content-Type: application/json" \
-d '{
"summary": "what was done",
"event_type": "note",
"author": "codex",
"workplan_id": "<uuid>",
"task_id": "<uuid>"
}'
```
Omit `workplan_id` / `task_id` when not applicable.
### Update task status
```bash
curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
-H "Content-Type: application/json" \
-d '{"status": "progress"}'
# values: wait | todo | progress | done | cancel
```
### 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 workplans (offline-safe)
2. Check inbox: `GET /messages/?to_agent=frontend-patterns&unread_only=true`; mark read
3. Scan workplans: `ls workplans/` — note `status: ready`, `active`, or `blocked` files and open tasks
4. Check human-needed tasks: `GET /tasks/?needs_human=true`
**During work:**
- Update task statuses in workplan files as tasks progress
- Record significant decisions via `POST /decisions/`
**Close:**
1. Update workplan file task statuses to reflect progress
2. If finishing a workplan: hand off **residuals** as live work records first
(intake with `origin: residual` + `origin_ref: <WP-id>`, or a next workplan /
decision / engagement). Do not park leftovers only in prose or `SCOPE.md`.
Canon: `the-custodian/canon/standards/work-record-types_v0.1.md` § Residuals.
3. Log: `POST /progress/` with a summary of what changed (name handoff ids)
4. After workplan file changes, run:
```bash
uv run --project ~/repo-manager rmgr sync --path . --push
```
This assigns only missing deterministic identifiers, verifies the pushed
Forgejo commit and `primary/railliance01`, then requests one central
reconciliation. A queued receipt is pending evidence; rerun after
connectivity returns. Use `statehub fix-consistency` for a separate deep audit.
---
## Credential and access routing
**Audience:** Codex, Claude Code, Grok, and custodian agents that call **llm-connect**
for inference. Run this check **before** requesting secrets, API keys, SSH access,
login tokens, or database passwords — in any repo, not only `ops-warden`.
ops-warden **issues SSH certificates only** (`warden sign`, `cert_command`). Every
other credential need belongs to another subsystem. **Do not** message
`ops-warden` on State Hub expecting a secret value; the reply is a pointer, not a key.
### Lookup (do this first)
```bash
warden route find "<describe your need>" --json
warden route show <catalog-id> --json
```
Requires the `warden` CLI from `~/ops-warden` (`uv tool install .` or `uv run warden`).
| Agent runtime | How to orient |
| --- | --- |
| **Codex / Grok** (shell, HTTP State Hub) | `warden route` commands above; inbox `to_agent=frontend-patterns` is for coordination, not secret vending |
| **Claude Code** (MCP when available) | `get_domain_summary("custodian")` for workplans; **still** use `warden route` for credential ownership |
| **llm-connect** (inference service) | Never put secret retrieval in prompts; route custody to OpenBao/operator paths surfaced by `warden route` |
### Quick routing table
| I need… | Owner | ops-warden executes? |
| --- | --- | --- |
| SSH cert (`adm`/`agt`/`atm`) | ops-warden | **Yes** — `warden sign` |
| API key, DB password, provider token | OpenBao (`railiance-platform`) | No — route only |
| Login / OIDC / MFA | key-cape / Keycloak | No — route only |
| Authorization decision | flex-auth | No — route only |
| activity-core → issue-core emission | activity-core + issue-core | No — `warden route show activity-core-issue-sink` |
| SSH tunnel | ops-bridge (+ `cert_command` from warden) | No — route only |
### Anti-patterns (do not do these)
- `POST /messages/` to `ops-warden` asking for `ISSUE_CORE_API_KEY`, `OPENROUTER_API_KEY`, etc.
- Inventing `warden secret`, `warden login`, `warden bao`, `warden tunnel` — they do not exist
- Pasting secrets into Git, State Hub, workplans, logs, or chat
### Other capabilities (reuse-surface)
Non-credential capabilities are usually discovered through **reuse-surface** federation
(`reuse-surface` registry / `capability.*` indexes). Credential routing is inlined in
every repo's agent instructions because it is high-frequency, high-risk, and easy to
get wrong.
**Canon:** `~/ops-warden/wiki/CredentialRouting.md` · catalog `~/ops-warden/registry/routing/catalog.yaml`
<!-- REPO-AGENTS-EXTENSIONS -->
<!-- Append repo-specific agent instructions below this marker.
The state-hub template sync preserves content after this line. -->
---
## Workplan Convention (ADR-001)
Work items originate as files in this repo — not in the hub. The hub is a
read/cache/index layer that rebuilds from files.
**File location:** `workplans/FEP-WP-NNNN-<slug>.md`
**Archived location:** finished workplans may move to
`workplans/archived/YYMMDD-FEP-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`, workplan id
`FEP-WP-ADHOC-YYYY-MM-DD`, and task ids
`FEP-WP-ADHOC-YYYY-MM-DD-T01`, etc. `FEP-WP` includes its final `-WP`
token. Unqualified historic `ADHOC-*` ids are grandfathered and must not be
copied into new records. 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: FEP-WP-NNNN
type: workplan
title: "..."
domain: infotech
repo: frontend-patterns
status: proposed | ready | active | blocked | backlog | finished | archived
owner: codex
topic_slug: ...
created: "YYYY-MM-DD"
updated: "YYYY-MM-DD"
state_hub_workstream_id: "<uuid>" # deterministic UUIDv5; managed by Repo Manager
---
```
Use `proposed` for a new draft, `ready` after review against current repo
state, and `finished` after implementation. `stalled` and `needs_review` are
derived health labels, not frontmatter statuses.
**Terminology:** workplan is the fleet term; `workstream` appears only in legacy
API/MCP/frontmatter bridges until `STATE-WP-0069` retires them — see
`the-custodian/canon/standards/workplan-terminology-fleet_v0.1.md`.
**Task block format** (one per `##` section):
```
## Task Title
` ` `task
id: FEP-WP-NNNN-T01
status: wait | todo | progress | done | cancel
priority: high | medium | low
state_hub_task_id: "<uuid>" # deterministic UUIDv5; managed by Repo Manager
` ` `
Task description text.
```
Status progression: `todo` → `progress` → `done`; use `wait` for waiting/blocked work and `cancel` for stopped work.
**Residuals when finishing:** actionable leftovers become live work records
before `status: finished` — usually an intake (`origin: residual`,
`origin_ref: FEP-WP-NNNN`) or a spawned workplan. Residual is a *role*,
not a kind. Fleet list lives on State Hub, not in `SCOPE.md`.
To create a new workplan:
1. Write the file following the format above
2. Run `uv run --project ~/repo-manager rmgr sync --path . --push`.
3. Run `statehub fix-consistency` only when a separate deep audit is needed.
## Repository workflow
This is a Markdown research repository. No install, build, run, lint or automated
application test command exists yet. Review documentation and use `git diff --check`
for whitespace. Inspect new files as well as tracked diffs.
Read `INTENT.md`, `SCOPE.md` and `REVIEW.md` for scope and maturity. Treat source
interpretations, candidate patterns and research stubs as provisional. Preserve
unrelated uncommitted work. Future validators belong to FEP-WP-0002.

120
INTENT.md Normal file
View file

@ -0,0 +1,120 @@
# INTENT
Status: preliminary · Reviewed: 2026-09-23
This records the initial direction inferred from the repository scaffold. The
responsibility model, vocabulary and sequences remain hypotheses to test against
sources and contrasting applications.
## Mission
Establish **frontend-patterns** as a durable, framework-independent pattern language for frontend architecture and design.
The repository should help a human or software agent answer questions such as:
- What architectural problem am I actually trying to solve?
- Which forces are active?
- Which patterns are applicable?
- Which patterns conflict?
- Which decisions must be made before this one?
- What context will applying this pattern create?
- Which implementation approaches realize this pattern?
- What failure modes should I expect?
- Which evidence and known uses support the pattern?
- How does a named frontend architecture decompose into reusable patterns?
## Why this exists
Frontend knowledge is fragmented across:
- framework documentation,
- architecture articles,
- rendering taxonomies,
- state-management schools,
- local-first research,
- microfrontend literature,
- design-system practice,
- accessibility guidance,
- performance engineering,
- distributed-systems concepts,
- GUI architecture traditions.
These sources often discuss similar forces using incompatible vocabularies.
The project aims to reconcile them into a coherent language.
## Non-goals
The project is not primarily:
- a framework comparison site,
- a component cookbook,
- a list of React idioms,
- a collection of code snippets,
- a prescriptive "one true architecture",
- a popularity ranking of frontend technologies.
Implementation examples are useful only insofar as they illuminate patterns.
## Desired properties
The language should be:
- **Generative** — capable of helping construct architectures.
- **Relational** — patterns explicitly connect to other patterns.
- **Contextual** — every pattern exists in a context with forces.
- **Evidence-aware** — claims distinguish observation, established practice and hypothesis.
- **Multi-scale** — patterns range from application topology to interaction details.
- **Technology-independent** — named tools map into the language but do not define it.
- **Agent-readable** — structured metadata supports retrieval and reasoning.
- **Human-readable** — prose explains why and when a pattern matters.
- **Evolvable** — concepts can mature without destabilizing the whole canon.
## Success condition
The repository is successful when a practitioner or agent can start with a frontend problem description and derive a small, explainable configuration of compatible patterns, then map those patterns to implementation options.
## Initial scope and maturity
The deliverable is a versioned Markdown knowledge base: vocabulary, patterns,
relations, architecture decompositions, decision sequences, technology mappings
and traceable evidence. A running application or framework is not required.
The current repository is a scaffold. Pattern families contain candidate lists;
architecture descriptions and most sequences are research stubs. There are no
completed canonical pattern records, technology mappings, graph exports or
automated validators. The first source case is an initial interpretation, not a
completed source review.
## Preliminary priorities
1. Reconcile schema and template: stable identifiers, relation spelling, force
identifiers, prerequisites, scales and evidence maturity need clear meanings.
2. Record identifiable sources with dates or versions and claim-level references;
distinguish source claims, our interpretations and untested hypotheses.
3. Develop a small connected set of complete patterns before expanding the catalog.
Each needs competing forces, consequences, failure modes and supporting evidence.
4. Exercise that set in contrasting server-authoritative and local-first scenarios.
Record alternatives, decision sequences, resulting contexts and gaps.
5. Add metadata validation and graph export once the contract survives those examples.
## Evidence of useful progress
A preliminary demonstration should trace an application problem through explicit
forces to a connected pattern configuration and implementation options. Each
selected pattern should have a stable identity, justified relations, traceable
evidence and stated maturity. Explain rejected alternatives and unresolved forces.
Pattern count alone is not success. Progress should improve conceptual precision,
evidence quality or the ability to explain a concrete design decision.
## Open decisions
- Whether the nine responsibilities are sufficient and independent.
- How prerequisites differ from relations between patterns.
- How evidence maturity differs from editorial or publication status.
- How to represent patterns spanning multiple scales.
- Which metadata and evaluation cases enable reliable agent retrieval.
`research/plan/ResearchProgram.md` provides a provisional roadmap; its milestones
describe planned work, not completed capabilities.

41
REVIEW.md Normal file
View file

@ -0,0 +1,41 @@
# Preliminary repository review
Reviewed: 2026-09-23. Scope: the local Markdown scaffold, including pre-existing
uncommitted content. External source claims were not independently verified.
The scaffold has a coherent purpose and useful separation between research,
vocabulary, patterns and implementations. Reasoning from forces and resulting
contexts is its central strength. It is not yet an evidence-backed pattern corpus.
## Findings
1. **Metadata is inconsistent.** `canon/PatternSchema.md` uses `conflicts_with`,
while `canon/Relations.md` and `templates/Pattern.md` use `conflicts-with`.
Forces have prose labels in the vocabulary but underscore IDs in the schema.
Resolve serialization and identity before tools depend on them.
2. **Prerequisites and graph edges are ambiguous.** Schema `requires` values name
conditions such as `authoritative_state`, whereas relation definitions permit
patterns or their contexts. Examples use names instead of `FEP-*` IDs.
Define target types and reference resolution.
3. **Evidence is prospective.** The source catalog lists families, not individually
identifiable references. The Carniato case is a stub without a source URL,
date/version or claim references. README's “research-backed” description should
be treated as an ambition until supporting evidence is recorded.
4. **Maturity and scales need definitions.** Schema `status` and `evidence.maturity`
both use `hypothesis`; the catalog uses `seed`. Catalog scales include `L3/L6`
and `cross-scale`, whereas the template uses one scale. Define valid states
and representations before automated validation.
5. **Generative usefulness is untested.** Pattern families contain only READMEs;
six architecture records and four specialized sequences are stubs. There are
no technology mappings. Test a connected pattern set on contrasting scenarios
before claiming coverage or expanding the catalog.
## Follow-up
`workplans/FEP-WP-0002-seed-language-validation.md` tracks these findings.
The preliminary intent preserves the mission and adds current maturity,
bounded priorities, success criteria and open decisions.
There is no application runtime, dependency manifest or automated test suite.
Validation for this change covers documentation, placeholders, classification
and State Hub registration/projection consistency.

37
SCOPE.md Normal file
View file

@ -0,0 +1,37 @@
# SCOPE
## Purpose
Develop a framework-independent frontend architecture pattern language for human
and agent reference, following the preliminary direction in `INTENT.md`.
## In scope
- `canon/`: responsibilities, forces, scales, relations and the pattern schema.
- `patterns/`: patterns with context, evidence, trade-offs and failure modes.
- `research/`: sources, interpretations, candidate concepts and counterexamples.
- `sequences/` and `architectures/`: decisions and configurations through patterns.
- `technologies/`: descriptive mappings to implementation options.
- `templates/`: authoring structures and future metadata validation.
## Out of scope
- Building or operating a frontend application or framework.
- Ranking frameworks or prescribing a universal architecture.
- Treating candidate lists or unsourced interpretations as established evidence.
## Current state
Research scaffold as of 2026-09-23. No application runtime, dependency manifest,
build pipeline or automated test suite is present. See `REVIEW.md` for findings
and `workplans/` for tracked follow-up work.
## Registration
- Repository: `frontend-patterns`
- Category: `research`
- Domain / topic: `infotech / canon`
- Workplan prefix: `FEP-WP`
The topic groups this research with semantic coordination work; it does not imply
that the proposed language is an adopted fleet standard.

View file

@ -0,0 +1,65 @@
---
id: FEP-WP-0001
type: workplan
title: "Bootstrap State Hub integration"
domain: infotech
repo: frontend-patterns
status: finished
owner: codex
topic_slug: canon
created: "2026-09-23"
updated: "2026-09-23"
---
# Bootstrap State Hub integration
Framework-independent frontend architecture pattern language for human and agent reference.
## Review Generated Integration Files
```task
id: FEP-WP-0001-T01
status: done
priority: high
```
Review `INTENT.md`, `SCOPE.md`, `AGENTS.md`, and `.custodian-brief.md`.
Replace generated placeholders with repo-specific facts where needed.
## Verify Local Developer Workflow
```task
id: FEP-WP-0001-T02
status: done
priority: high
```
Identify the repo's install, test, lint, build, and run commands. Add or refine
those commands in the agent instructions so future coding sessions can verify
changes confidently.
## Seed First Real Workplan
```task
id: FEP-WP-0001-T03
status: done
priority: medium
```
Create the first implementation workplan for the repository's most important
next change. After workplan file updates, run the sync locally from this repo
checkout:
```bash
statehub fix-consistency
```
## Completion evidence
Registered repository, remote, root Git fingerprint and bnt-lap001 checkout with
State Hub under infotech/canon. Reviewed the scaffold in `REVIEW.md`, refined
`INTENT.md` and `SCOPE.md`, resolved the generated credential-routing placeholder,
and documented the Markdown-only workflow in `AGENTS.md`.
Residual research findings are handed off to proposed workplan FEP-WP-0002.
Registration/projection verification is recorded in the State Hub progress log.

View file

@ -0,0 +1,53 @@
---
id: FEP-WP-0002
type: workplan
title: "Validate the seed frontend pattern language"
domain: infotech
repo: frontend-patterns
status: proposed
owner: codex
topic_slug: canon
created: "2026-09-23"
updated: "2026-09-23"
---
# Validate the seed frontend pattern language
Follow-up from `REVIEW.md` and FEP-WP-0001. This records future research.
## Reconcile the metadata contract
```task
id: FEP-WP-0002-T01
status: todo
priority: high
```
Resolve relation spelling, force and pattern IDs, prerequisite target types,
multi-scale representation and editorial status versus evidence maturity.
Done when schema and template agree and a worked example resolves every reference.
## Establish traceable source evidence
```task
id: FEP-WP-0002-T02
status: todo
priority: high
```
Complete the first source case and a contrasting local-first source review.
Record source identity, URL, date/version, claim references, interpretations and
counterexamples. Reconcile README maturity claims with the evidence.
## Validate a connected seed corpus
```task
id: FEP-WP-0002-T03
status: todo
priority: medium
```
Author a small connected pattern set and exercise it in server-authoritative and
local-first scenarios. Show forces, alternatives, ordering rationale, resulting
contexts and failure modes. Record gaps, then define the minimum metadata
validator and graph export needed by these examples.