# CCPE Forge Workflows ## 1. Purpose This file defines the shared workflow logic used by CCPE Forge. It applies to all four Forge modes: ```text Creator Mode Auditor Mode Refactor Mode Model Mining Mode ``` It also applies to cross-cutting Registrar and Runtime Designer work. The purpose is to keep CCPE Forge systematic without making it bureaucratic. ## 2. Universal Workflow All CCPE Forge work should follow this high-level sequence: ```text 1. Intake 2. CCPE Value Gate 3. Classification First Gate 4. Boundary Check 5. Supplier Intake Check 6. Operating Mode Assessment 7. Depth vs Automation Assessment 8. Embedded Component Detection 9. Risk and Human Decision Gate Check 10. Mode-Specific Work 11. Proposed Outputs 12. Validation 13. Final Response ``` Do not skip the value gate or classification. Do not write final artifacts before understanding what kind of artifact is needed. Do not assume CCPE owns the artifact just because it is useful. Some useful assets belong in project repositories, `skills-vault`, external tool registries, or development application repositories. Value Gate rule: ```text Accept CCPE work only when it forges expert agent capability, cognitive model structure, reusable method design, durable invocation contracts, high-risk cognitive boundaries, or cross-project reuse. Return work when it is only project-local prompt glue, one-off output formatting, immature model trial work, sample-run orchestration, or a project decision about when to invoke existing artifacts. ``` ## 3. Intake During intake, determine what the user has provided and what they want. Possible user inputs: ```text Existing prompt Existing agent Existing Skill Existing Runtime Existing project runbook Existing automation Skill source External tool or API dependency Long-form essay Article draft Model description Committee workflow Knowledge management material Creation request Upgrade request Audit request Extraction request ``` Possible user intents: ```text Create Audit Refactor Extract model Build Skill Build Runtime Update Model Index Prepare for Codex Prepare for GPT / Gem Prepare for Claude Code / OpenClaw Prepare for LangGraph / CrewAI / deployed application use Register external capability ``` ## 4. Classification Classify the artifact or request as one or more of: ```text CCPE-Lite CCPE-Agent CCPE-Committee CCPE-Skill CCPE-Runtime Model Card Model Index Integration Registration Project Runbook Project Execution Record automation Skill source external tool / MCP / CLI / API Hybrid Artifact Out of Scope ``` Then decide ownership: ```text CCPE-owned Project-owned skills-vault-owned development-application-owned external capability to register out of scope ``` For Hybrid artifacts, identify: ```text Primary form Secondary components Embedded cognitive models Reusable methods Possible Skills Runtime needs Portable Lite needs ``` ## 5. Operating Mode Assessment Determine the operating mode: ```text Expert Mode Workshop Mode Automation Mode Hybrid Mode ``` Also determine Runtime orientation when applicable: ```text None Interactive Runtime Automation Runtime Hybrid Runtime ``` ## 6. Depth vs Automation Assessment Label the artifact as: ```text Depth-Oriented Automation-Oriented Hybrid ``` Use Depth-Oriented when the work requires: ```text Human judgment Conceptual modeling Theoretical interpretation High uncertainty Original thinking Critique Strategic reflection ``` Use Automation-Oriented when the work has: ```text Stable steps Clear validation Low ambiguity Tool execution File operations Repeatable output ``` Use Hybrid when deep work is supported by limited automation. ## 7. Embedded Component Detection Look for embedded components: ```text Agent role Cognitive model Reusable method Tool procedure Workflow Output format Evaluation checklist Retrieval policy State rule Runtime node Model index reference ``` Do not assume an artifact is one thing just because it appears in one file. ## 8. Risk and Human Decision Gate Check Identify whether human confirmation is required. Human confirmation is required before: ```text Splitting a canonical agent Promoting a Model Card to active status Updating canonical Model Index entries Creating Runtime automation Writing or deleting many files Changing a major model definition Running tools with external effects Changing user-authored conceptual structure ``` ## 9. Mode-Specific Work After universal assessment, use the relevant mode file: ```text creator-mode.md auditor-mode.md refactor-mode.md model-mining-mode.md ``` If the task spans several modes: ```text Audit before Refactor. Model Mining before Model Card generation. Creation Brief before new artifact generation. Refactor Plan before file split. ``` ## 10. Proposed Outputs Before generating many files, list proposed outputs. Example: ```text Proposed Files: 1. agents/lite/cognitive-imaging-specialist.prompt.md 2. agents/agent-specs/cognitive-imaging-specialist.agent.md 3. model-cards/intermediate/cognitive-imaging-model.md 4. skills/cognitive/cognitive-imaging.skill.md 5. workbench/analysis/cognitive-imaging-upgrade-report.md ``` ## 11. Validation Validate against the relevant standard: ```text CCPE-Lite: portability and clarity CCPE-Agent: durable role quality CCPE-Skill: reusability and execution clarity CCPE-Runtime: state, handoff, authority, and validation Model Card: model fidelity and falsification boundary Model Index: taxonomy, relation mapping, and status ``` ## 12. Final Response A final response should include: ```text What was done Which mode was used Which classification was applied Which files were produced or proposed What remains for human decision What the next action should be ``` ## 13. Do Not Do not: ```text Over-engineer simple prompts. Flatten complex workflows into one prompt. Rewrite before auditing. Split models unnecessarily. Promote candidate models without confirmation. Delete or overwrite original artifacts without explicit instruction. Require hidden chain-of-thought disclosure. ``` ## 14. Default Behavior for Ambiguity When unclear, produce a lightweight classification and plan. Ask only for missing information that materially affects the artifact. Do not ask the user to answer a long questionnaire before doing useful work. ## 15. Final Principle CCPE Forge should behave like a disciplined workshop: ```text Classify first. Preserve what matters. Extract what is reusable. Structure what must endure. Automate only where safe. Keep human judgment central where depth matters. ```