By xiaolai
Govern Executable Operating Units (EOUs) through auditable lifecycle stages: generate candidate units from workflows, audit for boundary quality and governance risk, diagnose failures with F-code taxonomy, propose change proposals, and promote or retire units based on maturity gates.
Audit a generated candidate EOU set for boundary quality, minimality, overlap, authority, operational value, and governance risk before any candidate advances to specification. <example> Context: A generation run has just produced a candidate set; the owner wants to know which candidates survive audit before promotion. user: "$audit-candidate-eou-set foundry/self-evolution/candidate-sets/cs-generate-eou-candidates-20260520-1430.yml" assistant: "I'll run the eight tests (boundary, non-overlap, minimality, authority, operational value, counter-generation, set composition, high-stakes) and write the audit report under foundry/audits/candidate-set-audits/." </example> <example> Context: User wants to audit a candidate set that contains a generating EOU without a corresponding audit path. user: "$audit-candidate-eou-set ./my-candidates.yml" assistant: "I'll audit. Heads-up that if any candidate has authority_level approve/publish or proposes weakening validators, I'll escalate to FAIL regardless of other test outcomes." </example>
Audit value_invocations in run traces for EOUs with classification.judgment_authorized:true. Verifies invocations against the captured_workflow's declared priority (no F15), checks for drift over multiple runs (no F16), detects hallucinated value ids (no F17), catches silent decisions on contested cases (F14), and runs counterfactual-swap audit as the V1 anti-theater defense. <example> Context: An EOU with judgment_authorized:true has accumulated several run traces with value_invocations. The owner wants to verify the invocations are load-bearing, not citation theater. user: "$audit-judgment compose-dish" assistant: "I'll load compose-dish.yml, its app's captured_workflow, and the run traces under foundry/runs/compose-dish/. I'll check each value_invocation entry against F14-F17, then run counterfactual-swap audit on up to 5 sampled invocations. Verdict report goes to foundry/audits/judgment-audits/compose-dish.judgment-audit.yml." </example> <example> Context: An EOU with judgment_authorized:false is passed to audit-judgment. user: "$audit-judgment plate-a-dish" assistant: "plate-a-dish has judgment_authorized:false (or absent). Rule 97 does not apply; the audit-judgment layer is N/A for non-agentic EOUs. I'll emit the 'rule does not apply' status and return without running checks." </example>
Create a formal EOU Change Proposal from a diagnosed failure or refactor option, capturing simulation, regression case, audit, and approval requirements per rule 92. <example> Context: $eou-diagnose has produced a diagnosis recommending a change. Owner wants to convert it into an actionable ECP. user: "$ecp-propose foundry/audits/incidents/inc-0042.diagnosis.yml" assistant: "I'll read the diagnosis, target_eou, and proposed change; draft an ECP under foundry/self-evolution/ecp/proposed/ with simulation, regression case, audit, and approval blocks. Status starts at proposed." </example> <example> Context: User wants an ECP for a refactor option produced by $eou-refactor. user: "$ecp-propose ./refactor-options/ro-split-audit-eou.yml" assistant: "I'll draft the ECP. If the target requires a constitution change, I'll stop and direct you to the constitutional ECP process instead." </example>
Audit an EOU spec — classification, authority, validators, failure modes, trace, blast radius, responsibility. <example> Context: Auditing an EOU before promoting it to active. user: "$eou-audit eou-diagnose" assistant: "Loading spec + governance + maturity model; report goes to foundry/audits/eou-audits/." </example> <example> Context: Re-audit after applying an ECP. user: "$eou-audit foundry/eous/audit-foundry.yml" assistant: "Re-running. Rule 94 (executor != approver) is hard-checked first." </example>
Diagnose an EOU failure using the F-code taxonomy and recommend the smallest-blast-radius repair, producing either a diagnosis (path to $ecp-propose) or a no-change record. <example> Context: An incident has been filed; owner wants a structured diagnosis before deciding whether to open an ECP. user: "$eou-diagnose foundry/incidents/inc-0042.yml" assistant: "I'll classify the failure under one or more F-codes, rank repair options by blast radius, and emit either a diagnosis YAML (decision: change) or a no-change record under foundry/audits/incidents/." </example> <example> Context: User wants to diagnose from an audit finding rather than a full incident. user: "$eou-diagnose foundry/audits/eou-audits/eou-promote.audit.yml" assistant: "I'll diagnose the audit's findings; if evidence is insufficient for a change, I'll write a no-change record explicitly rather than silently doing nothing." </example>
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Recursive governance for Executable Operating Units (EOUs) — installable as a Claude Code plugin into any project that needs to turn messy human workflows into structured, auditable, improvable operating units.
An EOU is an operational hypothesis, not a prompt or a checklist:
Given inputs X, context Y, procedure Z, and validation tests T,
this unit should produce output O within acceptable risk R.
Every EOU uses faceted classification — no single vague type label decides authority or risk:
function + target_object + automation_mode + authority_level + risk_level + lifecycle_stage
| Layer | What ships |
|---|---|
| Schemas | schemas/*.schema.yml — the contract (EOU, ECP, registry-entry, run-trace, no-trace-justification, candidate-set, incident, audit-report) |
| Engine artifacts (v0.5.0+) | engine/ — canonical, plugin-owned, app-inherited: constitution-defaults.yml, failure-taxonomy.yml, maturity-model.yml, refactoring-patterns.yml, runtime-contract.yml, governance.yml, plus 11 canonical meta-EOUs under engine/meta-eous/ |
| Engine theory | engine/{eou-contract, eou-foundry-v2, eou-system}.md |
| Governance rules | 7 rules covering classification, ECP requirement, recursive governance, no-self-approval, generating-EOU constraints, and constitutional reads |
| Skills | 11 Foundry skills (see Skills table below) |
| Templates | Constitution, registry, generic EOU, generating-EOU starters |
| Scaffolding | /eou-foundry:init creates a new application dir with a fresh foundry/ that inherits engine artifacts from the plugin |
| Validators | scripts/validate_foundry.py (full pipeline: constitution merge, registry, ECPs, regression, run traces, trace gate, candidate sets, activation evidence, maturity evidence, dependency DAG, engine artifacts, overrides) |
| Design docs | 6 dev-docs: foundations, architecture, doctrine, vocabulary principles, V6 design pulls, values over rules |
engine/ docs and its own workshop-specific
skills/rules. The plugin governs the EOU contract; the application owns
its domain.foundry/constitution.yml,
registry.yml, eous/, incidents/, audits/, runs/ are owned and
versioned by the application, not the plugin.self-evolution/.From the xiaolai marketplace (recommended):
# one-time, if you haven't already added the xiaolai marketplace:
claude plugin marketplace add xiaolai/claude-plugin-marketplace
# then in any project:
claude plugin install eou-foundry@xiaolai --scope project
From a local checkout (for plugin development):
claude plugin marketplace add /path/to/eou-foundry
claude plugin install eou-foundry@eou-foundry-local --scope project
From a workspace directory:
/eou-foundry:init my-app
That creates ./my-app/foundry/ populated from the plugin's templates and
runs validate_foundry.py against it. The new app is its own git repo.
| Skill | Purpose |
|---|---|
/eou-foundry:generate-eou-candidates | Generate a ranked candidate EOU set from a messy workflow |
/eou-foundry:audit-candidate-eou-set | Audit a generated candidate set for boundary quality and minimality |
/eou-foundry:eou-specify | Convert an approved candidate into a formal EOU spec |
/eou-foundry:eou-audit | Audit an EOU spec against the schema (judgment-heavy) |
/eou-foundry:eou-validate | Validate the foundry's structural integrity (deterministic) |
/eou-foundry:eou-diagnose | Diagnose an EOU failure using the F-code taxonomy |
/eou-foundry:eou-refactor | Generate candidate refactor options (proposal-only) |
/eou-foundry:eou-promote | Evaluate whether an EOU can be promoted to the next maturity level (recommendation only) |
/eou-foundry:foundry-audit | Audit the consuming project's whole foundry/ system-wide |
/eou-foundry:ecp-propose | Draft a formal ECP from a diagnosed failure or refactor option |
/eou-foundry:generate-regression-cases | Convert incidents and audit failures into candidate regression cases |
Pre-v0.5.0, every scaffolded app carried snapshot copies of the engine artifacts (failure taxonomy, maturity model, governance rules, etc.). Apps drifted from the engine as the plugin evolved.
npx claudepluginhub xiaolai/eou-foundry --plugin eou-foundryNatural-Language Programming Manager — score, check, fix, and test NL artifacts across Claude Code, Codex CLI, and Antigravity. Tier-aware scoring with per-tool overlays.
A 260-token system prompt that overrides three structural presumptions every RLHF-trained LLM inherits from training: that you want confirmation, that old scarcity still applies, that best practices are ceilings.
English language coach for non-native speakers — auto-corrects prompts, translates non-English, refines with :: prefix, tracks improvement over time
One plugin to bridge and delegate across Claude Code, Codex CLI, and Gemini CLI — single-source AGENTS.md, shared skills, mirrored hooks and MCP servers, and full Claude↔Codex bidirectional delegation.
Auto-updated multi-skill reference for the whole Anthropic doc ecosystem. 8 skills covering claude-code, claude-agent-sdk, anthropic-api, anthropic-platform-features, claude-connectors, claude-cowork, mcp-spec, and anthropic-pulse (news + research digests). Pipeline refreshes daily.
Harness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Tools to maintain and improve CLAUDE.md files - audit quality, capture session learnings, and keep project memory current.
Persistent file-based planning for AI coding agents. Crash-proof markdown plans (task_plan.md, findings.md, progress.md) that survive context loss and /clear, with an opt-in completion gate and multi-agent shared state. Manus-style. Works with Claude Code, Codex CLI, Cursor, Kiro, OpenCode and 60+ agents via the SKILL.md standard. Includes Arabic, German, Spanish, and Chinese (Simplified and Traditional).
v9.44.1 — Patch release for Gemini environment/version detection and qwen auth gating. Run /octo:setup.
Superpowers Plus core skills library for Claude Code: planning, execution routing, TDD, debugging, and collaboration workflows
Unity Development Toolkit - Expert agents for scripting/refactoring/optimization, script templates, and Agent Skills for Unity C# development