From cbe82f806b5a97a40e141bb7bf90f87eac15f059 Mon Sep 17 00:00:00 2001 From: tegwick Date: Wed, 23 Sep 2026 22:44:01 +0200 Subject: [PATCH] Register frontend pattern research and establish preliminary intent Assistant: codex Assistant-Model: gpt-6-astra Assistant-Session: 01a0cffe-206f-7323-89d3-b20ca4cf4bf9 --- .gitignore | 5 + .repo-classification.yaml | 6 + AGENTS.md | 265 ++++++++++++++++++ INTENT.md | 120 ++++++++ REVIEW.md | 41 +++ SCOPE.md | 37 +++ workplans/FEP-WP-0001-statehub-bootstrap.md | 65 +++++ .../FEP-WP-0002-seed-language-validation.md | 53 ++++ 8 files changed, 592 insertions(+) create mode 100644 .gitignore create mode 100644 .repo-classification.yaml create mode 100644 AGENTS.md create mode 100644 INTENT.md create mode 100644 REVIEW.md create mode 100644 SCOPE.md create mode 100644 workplans/FEP-WP-0001-statehub-bootstrap.md create mode 100644 workplans/FEP-WP-0002-seed-language-validation.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e4e0199 --- /dev/null +++ b/.gitignore @@ -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 diff --git a/.repo-classification.yaml b/.repo-classification.yaml new file mode 100644 index 0000000..023a1a6 --- /dev/null +++ b/.repo-classification.yaml @@ -0,0 +1,6 @@ +category: research +domain: infotech +capability_tags: + - frontend-architecture + - pattern-language + - knowledge-representation diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..0ed804b --- /dev/null +++ b/AGENTS.md @@ -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//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": "", + "task_id": "" + }' +``` + +Omit `workplan_id` / `task_id` when not applicable. + +### Update task status + +```bash +curl -s -X PATCH "http://127.0.0.1:8000/tasks/" \ + -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/" \ + -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: `, 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 "" --json +warden route show --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` + + + + +--- + +## 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-.md` + +**Archived location:** finished workplans may move to +`workplans/archived/YYMMDD-FEP-WP-NNNN-.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: "" # 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: "" # 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. diff --git a/INTENT.md b/INTENT.md new file mode 100644 index 0000000..c43314e --- /dev/null +++ b/INTENT.md @@ -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. diff --git a/REVIEW.md b/REVIEW.md new file mode 100644 index 0000000..8731db7 --- /dev/null +++ b/REVIEW.md @@ -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. diff --git a/SCOPE.md b/SCOPE.md new file mode 100644 index 0000000..1f15ed3 --- /dev/null +++ b/SCOPE.md @@ -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. diff --git a/workplans/FEP-WP-0001-statehub-bootstrap.md b/workplans/FEP-WP-0001-statehub-bootstrap.md new file mode 100644 index 0000000..ec66c5c --- /dev/null +++ b/workplans/FEP-WP-0001-statehub-bootstrap.md @@ -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. diff --git a/workplans/FEP-WP-0002-seed-language-validation.md b/workplans/FEP-WP-0002-seed-language-validation.md new file mode 100644 index 0000000..4177025 --- /dev/null +++ b/workplans/FEP-WP-0002-seed-language-validation.md @@ -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.