Flow
Request → Discover → Inspect → ExtractFacts → KnowledgeBase → Generate

Productions
EvidenceBeforeGeneration ::= <UserRequest> "->" <ResourceDiscovery> "->" <DomainInspection> "->" <FactExtraction> "->" <KnowledgeBase> "->" <GeneratedAgent>
GeneratedAgent ::= "allowed_only_if_evidence_grounded"

Before
An agent generated from the request text and prior model knowledge, never inspecting the target.

After
request -> discover resources -> inspect domain -> extract facts -> knowledge base -> generate only from verified evidence

Flow
SemanticVerb → AdapterMapping → RuntimeAction → Result

Productions
SemanticBoundary ::= <SemanticOperation> "->" <AdapterMapping> "->" <RuntimeExecution> "->" <EvidenceResult>
SemanticOperation ::= "DECLARE_RESOURCE" | "DISCOVER_RESOURCES" | "READ_RESOURCE" | "SEARCH_CONTENT" | "ANALYZE_CONTENT" | "EXTRACT_FACTS" | "CALCULATE_METRIC" | "COMPOSE_ARTIFACT" | "VALIDATE_ARTIFACT" | "PERSIST_ARTIFACT" | "REPORT_RESULT" | "REQUEST_DECISION"
CoreConstraint ::= "no_runtime_specific_paths_or_commands"

Before
The agent core hardcodes a specific search command and an absolute path, so it only runs on one runtime.

After
semantic op{DISCOVER/READ/SEARCH/ANALYZE} -> adapter maps to the runtime -> the core carries no runtime path or command

Flow
CapabilitySet → Probe → Available|Unavailable|Substituted → RuntimeMode

Productions
CapabilityProfile ::= <RequiredCapabilitySet> "->" <CapabilityProbeSet> "->" <CapabilityVerdict>
CapabilityVerdict ::= "full" | "degraded" | "blocked"
Capability ::= "filesystem" | "search" | "execution" | "persistence" | "validation" | "user_interaction"

Before
The agent assumes it can execute and write, then fails when it cannot.

After
required capabilities{filesystem, search, execution, persistence, validation} -> probe each -> mode{full | degraded | blocked}

Flow
TargetAgent → ExistingRegistry → NameCollision? → DomainCollision? → Decision

Productions
CreationCollision ::= <TargetAgentName> "->" <ExistingAgentMap> "->" <CollisionCheck> "->" <AgentOperationMode>
AgentOperationMode ::= "CREATE" | "REFINE" | "RENAME" | "REPLACE" | "CANCEL"
CollisionCheck ::= "name_collision" | "domain_collision" | "none"

Before
A new agent silently overwrites an existing one of the same name.

After
target name -> existing registry -> name/domain collision? -> user decision{CREATE|REFINE|RENAME|REPLACE|CANCEL}

Flow
DomainPath → Normalize → Hash → CacheLookup → AgeCheck → UseCache|Investigate

Productions
DomainCache ::= <DomainPath> "->" <DomainHash> "->" <CacheEntry> "->" <CacheAge> "->" <CacheDecision>
CacheDecision ::= "use_cached_domain" | "reject_stale_cache" | "no_cache_investigate"

Before
Stale cached domain intelligence reused as if it were current.

After
domain path -> normalize + hash -> cache lookup -> age vs TTL -> {use cached | reject stale | investigate}

Flow
TargetPath → InvestigationType → ScopeModel → ResourceSet → InterfaceFacts

Productions
ScopeExtraction ::= <TargetPath> "->" <InvestigationDepth> "->" <DomainScope>
InvestigationDepth ::= "single-resource" | "directory" | "module" | "repository" | "auto"
DomainScope ::= <ResourceScope> | <DirectoryScope> | <ModuleScope> | <RepositoryScope>

Before
A repository investigated at single-file depth, missing every boundary.

After
target -> investigation depth{single-resource|directory|module|repository} -> scope-matched facts{interfaces, deps, boundaries}

Flow
StaticPlan + OptionalExecutablePlan → Analyze → ExtractStructure → CacheResults

Productions
DomainInvestigation ::= <InvestigationPlan> "->" <AnalysisExecution> "->" <DomainKnowledge>
InvestigationPlan ::= <StaticAnalysisPlan> "," <OptionalExecutableAnalysisPlan>
ExecutionConstraint ::= "non_destructive" "," "observable_output_required" "," "source_mutation_forbidden"

Before
Investigation runs a script that mutates the source it is inspecting.

After
static plan (+ optional safe executable) -> analyze, never mutate the source -> observable output -> domain knowledge

Flow
DomainFacts → Statistics → EvidenceSources → KnowledgeBase

Productions
DomainKnowledgeBase ::= <DomainScope> "," <DomainStructure> "," <PurposeSet> "," <DependencyMap> "," <InterfaceSet> "," <PatternSet> "," <Statistics> "," <EvidenceSourceSet>
Statistics ::= "resource_count" "," "interface_count" "," "dependency_count" "," "resource_types" "," "architectural_patterns"

Before
Generation proceeds with no explicit evidence substrate to cite.

After
domain facts + structure + purposes + deps + interfaces + patterns + statistics + evidence sources -> reusable knowledge base

Flow
KnowledgeBase → RiskFactors → ComplexityScore → Reversibility → Uncertainty

Productions
DomainCharacteristics ::= <RiskLevel> "," <ComplexityScore> "," <Reversibility> "," <UncertaintyLevel>
RiskLevel ::= "low" | "medium" | "high"
Reversibility ::= "reversible" | "partially-reversible" | "irreversible"
UncertaintyLevel ::= "low" | "medium" | "high"

Before
Every agent given the same phase count regardless of how risky its domain is.

After
knowledge base -> risk{low|medium|high} + complexity + reversibility{reversible|partial|irreversible} + uncertainty

Flow
ExistingSpecs → PhaseCount → GateCount → OperationUsage → ReusablePatterns

Productions
ExistingPatternExtraction ::= <ExistingAgentSpecSet> "->" <StructuralMetricSet> "->" <ReusablePatternSet>
StructuralMetricSet ::= "phase_count" "," "validation_gate_count" "," "semantic_operation_count"

Before
A new agent invented in a shape that ignores the local agent grammar.

After
existing specs -> count{phases, gates, semantic ops} -> reusable structures -> baseline conventions

Flow
KnowledgeDocs → RelevanceAnalysis → RelevantDocs → PrincipleInput

Productions
KnowledgeRelevance ::= <KnowledgeDocumentSet> "->" <RelevanceScoreSet> "->" <RelevantKnowledgeSet>
RelevanceDecision ::= "include" | "exclude"

Before
Every knowledge doc fed into reasoning, relevant or not.

After
knowledge docs -> read descriptions -> score relevance vs domain -> include relevant, exclude the rest

Flow
StructuralPrinciples + DomainDocs → Applicability → CorePrinciples

Productions
PrincipleExtraction ::= <CandidatePrincipleSet> "->" <ApplicabilityAnalysis> "->" <CorePrincipleSet>
CorePrinciple ::= "phase_gated_execution" | "validation_boundaries" | "declaration_before_use" | "evidence_before_composition" | "adapter_separation" | "auditability"

Before
Runtime-specific principles baked into the portable core.

After
structural candidates + domain docs -> test applicability -> core principles{phase-gated, validation-boundaries, declaration-before-use, evidence-before-composition, adapter-separation, auditability}; runtime-specific excluded

Flow
Risk + Complexity + Uncertainty → PhaseCount → PhaseBoundaries

Productions
PhaseBoundarySelection ::= <RiskLevel> "," <ComplexityScore> "," <UncertaintyLevel> "->" <PhaseStructure>
PhaseStructure ::= <ThreePhase> | <FivePhase> | <SevenPhase>
ThreePhase ::= "Discovery" "," "Generation" "," "Verification"
FivePhase ::= "Discovery" "," "Analysis" "," "Generation" "," "Verification" "," "Finalization"
SevenPhase ::= "Discovery" "," "Analysis" "," "Planning" "," "Validation" "," "Generation" "," "Verification" "," "Finalization"

Before
A high-risk irreversible domain given a 3-phase agent.

After
risk + complexity + uncertainty -> phase count{3 | 5 | 7} -> validation density proportional to difficulty

Flow
PhaseSet → RequirementDerivation → ValidationGateSet

Productions
PhaseValidation ::= <PhaseSet> "->" <ValidationRequirementSet> "->" <ValidationGateSet>
PhaseValidationGate ::= <PhaseName> ":" <RequirementSet>
RequirementSet ::= <Requirement> | <Requirement> "," <RequirementSet>

Before
A phase ends with no verifiable exit condition.

After
phase -> derive requirements{purpose, adapter-separation, evidence-grounding, safety} -> a validation gate per phase

Flow
KnowledgeBase + Principles + Phases → PortableContract

Productions
PortableAgentContract ::= <Identity> "," <Purpose> "," <DomainModel> "," <CapabilityRequirements> "," <PhaseSpecifications> "," <ValidationStrategy> "," <SafetyConstraints> "," <OutputContract>
OutputContract ::= "portable_agent_contract" | "invocation_contract" | "audit_report" | "final_report"

Before
The agent authored directly as a runtime artifact, welded to one runtime.

After
knowledge base + principles + phases -> runtime-neutral contract{identity, purpose, domain model, capabilities, phase specs, validation strategy, constraints, outputs} = the canonical artifact

Flow
PreChecks → DuringChecks → PostChecks → ValidationStrategy

Productions
GenerationValidationStrategy ::= <PreGenerationChecks> "," <DuringGenerationChecks> "," <PostGenerationChecks>
PreGenerationChecks ::= "capabilities_detected" "," "history_checked" "," "domain_knowledge_available"
DuringGenerationChecks ::= "phase_gates_enforced" "," "evidence_grounded_content" "," "adapter_separated"
PostGenerationChecks ::= "schema_valid" "," "audit_complete" "," "unsupported_assumptions_absent"

Before
The artifact validated only after it is written, never during.

After
pre{capabilities detected, history checked, knowledge available} + during{phase gates, evidence-grounded, adapter-separated} + post{schema valid, audit complete, no unsupported assumptions}

Flow
ReplaceIntent → Approval → ArchiveExisting → VerifyArchive → Persist|Block

Productions
ReplacementSafety ::= <AgentOperationMode> "->" <ArchivePolicy> "->" <SafetyCheck> "->" <PersistenceDecision>
ArchivePolicy ::= "archive_required_if_replace" | "archive_not_required"
PersistenceDecision ::= "safe_to_persist" | "blocked"

Before
An existing agent overwritten with no archive — the original is lost.

After
REPLACE -> require approval -> archive existing -> verify the archive -> persist only if recoverable, else block

Flow
PortableContract → AdapterSchema → RenderedArtifact → Validate → Persist

Productions
AdapterRendering ::= <PortableContract> "->" <AdapterConfig> "->" <ArtifactSet> "->" <AdapterValidation> "->" <Persistence>
ArtifactSet ::= "agent_specification" "," "invocation_contract" "," "audit_report"
AdapterConstraint ::= "adapter_may_add_metadata_but_not_alter_core_intent"

Before
The runtime artifact edited directly, diverging from the portable contract.

After
portable contract -> adapter schema -> artifacts{agent spec, invocation contract, audit} -> adapter may add metadata, never alter core intent

Flow
GenerationState → AuditFields → AuditReport

Productions
AuditReport ::= <AgentIdentity> "," <DomainReference> "," <AgentOperationMode> "," <RuntimeEnvironment> "," <RiskMetrics> "," <ValidationGateSet> "," <EvidenceSourceSet> "," <CapabilityProfile> "," <AdapterIdentity> "," <PortabilityStatus>

Before
A generated agent with no provenance — no record of how or from what it was built.

After
generation state -> audit{identity, domain, mode, risk metrics, gates, evidence sources, capability profile, adapter identity, portability status}

Flow
PersistedSpec → MarkerSearch → CountMetrics → LeakageCheck → ComplianceVerdict

Productions
SemanticCompliance ::= <PersistedArtifact> "->" <SemanticMarkerSet> "->" <MetricCheck> "->" <RuntimeLeakageCheck> "->" <ComplianceVerdict>
ComplianceVerdict ::= "compliant" | "non_compliant"

Before
The in-memory plan judged compliant, but the STORED artifact never re-checked.

After
re-read persisted spec -> search{semantic ops, phase markers, gates} + leakage check -> compliant only if counts pass and zero runtime leakage

Flow
GeneratedSpec → UnsupportedClaimSearch → EvidenceReferenceCheck → GroundingScore → Accept|Reject

Productions
EvidenceGrounding ::= <GeneratedArtifact> "->" <ClaimAnalysis> "->" <KnowledgeBaseComparison> "->" <GroundingVerdict>
GroundingVerdict ::= "grounded" | "unsupported_claims_present" | "insufficient_evidence_references"

Before
The generated agent asserts architecture claims that trace to nothing.

After
generated spec -> find claims -> compare against the knowledge base -> grounding score -> reject below threshold

Flow
GeneratedSpec → EmbodimentMarkers → Score → Pass|Fail

Productions
AlgorithmicEmbodiment ::= <GeneratedArtifact> "->" <EmbodimentMarkerSet> "->" <EmbodimentScore> "->" <EmbodimentVerdict>
EmbodimentMarkerSet ::= "phase_gates" "," "declaration_before_use" "," "calculated_metrics" "," "thresholds" "," "iterative_discovery"
EmbodimentVerdict ::= "embodied" | "insufficiently_embodied"

Before
The agent describes phase gates in prose but does not embody them.

After
generated spec -> markers{phase gates, declaration-before-use, calculated metrics, thresholds, iterative discovery} -> embodied | insufficiently-embodied

Flow
ValidationResults + ArtifactRefs + Limitations → FinalReport

Productions
FinalGenerationReport ::= <GenerationSummary> "," <RiskSummary> "," <ComplianceSummary> "," <ArtifactReferences> "," <LimitationSet>
ComplianceSummary ::= "semantic_operations" "," "adapter" "," "evidence_grounding" "," "algorithmic_embodiment"

Before
A report that conflates the artifact, its validation status, and its limitations.

After
validation results + artifact refs + limitations{degraded mode, unsupported capabilities} -> report distinguishing all three

Flow
ValidationVerdicts → AuditPresence → Accept|Regenerate|Blocked

Productions
AgentGenerationCompletion ::= <ValidationVerdictSet> "->" <AuditCheck> "->" <AcceptanceVerdict>
AcceptanceVerdict ::= "agent_accepted" | "regenerate_required" | "blocked"

Before
A generated agent declared ready while its evidence-grounding failed and its algorithmic embodiment was insufficient.

After
semantic compliance passed + evidence grounded above threshold + algorithmically embodied + audit recorded -> agent_accepted; else regenerate | blocked

Flow
Config → Capabilities → History → Cache → Discovery → Knowledge → Analysis → Principles → Phases → Contract → AdapterRender → Validate → Audit → Report

Productions
AgentCreatorKernel ::= <ConfigurationLoad> "->" <CapabilityProfile> "->" <CreationCollision> "->" <DomainCache> "->" <ScopeExtraction> "->" <DomainInvestigation> "->" <DomainKnowledgeBase> "->" <DomainCharacteristics> "->" <PrincipleExtraction> "->" <PhaseBoundarySelection> "->" <PortableAgentContract> "->" <AdapterRendering> "->" <SemanticCompliance> "->" <EvidenceGrounding> "->" <AlgorithmicEmbodiment> "->" <AuditReport> "->" <FinalGenerationReport>

Derivation map

Before
A target domain turned straight into an agent by assumption, ungated.

After
config -> capabilities -> history -> cache -> discover evidence -> knowledge -> risk analysis -> principles -> phases -> portable contract -> adapter render -> validate{semantic/grounding/embodiment} -> audit -> report

Flow
Context → Capability → History → Evidence → Knowledge → Risk → Phases → Contract → Adapter → Validation → Audit → Report

Productions
AgentGenerationConcern ::= <ContextContract> "->" <CapabilityContract> "->" <CollisionPolicy> "->" <EvidenceModel> "->" <KnowledgeBase> "->" <PhaseDesign> "->" <PortableContract> "->" <AdapterArtifactSet> "->" <ValidationSet> "->" <AuditTrail> "->" <FinalReport>
ValidationSet ::= "semantic_compliance" "," "adapter_compliance" "," "evidence_grounding" "," "algorithmic_embodiment" "," "runtime_specific_leakage_absent"

Flow
WorkflowObjective → AgentPhases → ExecutionClassification → ParallelDiscovery → SequentialAction → Handoff

Productions
HybridWorkflowOrchestration ::= <WorkflowObjective> "->" <AgentSequence> "->" <ExecutionModeClassification> "->" <ParallelBatchSet> "->" <SequentialActionSet> "->" <WorkflowCompletion>
ExecutionMode ::= "PARALLEL" | "SEQUENTIAL"
ParallelPhase ::= "DISCOVERY" | "INVESTIGATION" | "RESEARCH" | "ANALYSIS" | "EXPLORATION"
SequentialPhase ::= "CREATE" | "WRITE" | "EXECUTE" | "VERIFY" | "IMPLEMENT" | "REFACTOR"

Before
Every agent runs sequentially, even independent discovery — the workflow crawls.

After
objective -> agent sequence -> classify by verb -> parallel discovery (forked context) + sequential action (normal context) -> handoff

Flow
DSLSources → Requirements → ComplianceGate → Proceed|Block

Productions
DSLComplianceLoading ::= <DSLSpecSet> "->" <WorkflowRequirementSet> "->" <ComplianceValidationGate>
WorkflowRequirementSet ::= "agent_dsl_syntax" "," "agent_oriented_content" "," "stable_filename_convention" "," "handoff_protocol" "," "hybrid_parallel_sequential" "," "context_isolation" "," "agent_spawn_mechanism" "," "capability_invocation"

Before
Workflow generated free-form, ignoring the DSL and handoff contracts.

After
load DSL + keyword + workflow + checklist specs -> require{agent-DSL syntax, handoff protocol, hybrid execution, context isolation, agent spawn} -> compliance gate

Flow
ModificationError → RereadMerge → CompleteRewrite → Verify

Productions
FileModificationRecovery ::= <FileModificationError> "->" <RecoveryProtocolSelection> "->" <RereadAndMerge> "->" <CompleteRewrite> "->" <RecoveryLog>
RecoveryProtocol ::= "reread-merge-complete-rewrite" | "snapshot-restore-on-failure"
ForbiddenRecovery ::= "retry_edit_without_recovery" | "ask_user_for_tool_error_recovery"

Before
A stale-write conflict re-reads the file and retries the same edit, or stops to ask the user.

After
modification error -> re-read current -> merge the delta into full state -> write complete version -> verify -> log; never retry-without-recovery, never ask for a tool error

Flow
AgentClass → ContextMode → ParallelEligibility → ExecutionPolicy

Productions
ContextForkingConfiguration ::= <AgentClass> "->" <ContextMode> "->" <ParallelPolicy> "->" <ExecutionConfiguration>
AgentClass ::= "discovery" | "investigation" | "documentation" | "action" | "validation"
ContextMode ::= "fork" | "normal"
ParallelPolicy ::= "parallel_true" | "parallel_false"

Before
Every agent shares one context — discovery pollutes the action agent's state.

After
agent class -> discovery/investigation/documentation -> fork ; action/validation -> normal -> per-class parallel eligibility preserved

Flow
AgentPurpose → PrimaryVerb → VerbClass → ExecutionMode

Productions
VerbExecutionClassification ::= <AgentPurpose> "->" <PrimaryVerb> "->" <VerbSetMatch> "->" <AgentExecutionMode>
ParallelVerb ::= "ANALYZE" | "FIND" | "EXTRACT" | "READ" | "DISCOVER" | "INVESTIGATE" | "RESEARCH" | "EXPLORE" | "TRACE"
SequentialVerb ::= "CREATE" | "WRITE" | "EXECUTE" | "VERIFY" | "IMPLEMENT" | "LINK" | "ITERATE" | "REFACTOR" | "DEPLOY"

Before
Execution mode assigned by phase number, not by what the agent does.

After
agent purpose -> primary verb -> {ANALYZE/FIND/DISCOVER -> PARALLEL(fork)} | {CREATE/WRITE/VERIFY -> SEQUENTIAL(normal)}

Flow
WorkspaceConfig → Zones → AgentDefinitions → ArtifactBasePath

Productions
WorkspaceConfigurationDiscovery ::= <WorkspaceConfigFile> "->" <WorkspaceConfig> "->" <ZoneConfig> "->" <AgentDefinitionSet> "->" <ArtifactPathPolicy>
ArtifactPathPolicy ::= "shared_zone/workflow_name" "," "workflow_zone" "," "task_zone" "," "no_hardcoded_paths"

Before
Artifact paths hardcoded — the workflow only runs in one layout.

After
workspace-config -> zones + root + agent defs -> artifact base = shared_zone/workflow_name; no hardcoded paths

Flow
CoreDocuments → PreCreate → AgentReadEdit → SingleSourceValidation

Productions
SharedDocumentWorkspace ::= <CoreDocumentSet> "->" <PreCreation> "->" <SharedAccessProtocol> "->" <IterativeRefinement> "->" <SingleSourceOfTruthGate>
SharedAccessProtocol ::= "all_agents_same_documents" "," "orchestrator_creates" "," "agents_refine" "," "append_mode_false"

Before
Each agent writes its own output file; findings diverge across N versions.

After
pre-create core documents once -> every agent reads + edits the same set -> no duplicate versions -> single source of truth

Flow
WorkflowObjective → WorkflowType → CoreDocuments → PurposeMap

Productions
WorkflowDocumentSelection ::= <WorkflowObjective> "->" <WorkflowType> "->" <CoreDocumentSet> "->" <DocumentPurposeMap>
WorkflowType ::= "cleanup" | "analysis" | "refactoring" | "documentation" | "implementation" | "security" | "performance" | "infrastructure" | "migration"
CoreDocumentConstraint ::= "document_count_between_5_and_8" "," "distinct_logical_purpose" "," "semantic_names_only"

Before
Generic output.md / results.md documents with overlapping purpose.

After
objective -> workflow_type{cleanup|analysis|refactoring|security|migration} -> 5-8 distinct-purpose documents -> one non-overlapping purpose each

Flow
AgentCount → AgentObjectSet → AgentSequence

Productions
AgentSequenceDefinition ::= <AgentCount> "->" <AgentObjectSet> "->" <AgentSequence>
AgentObject ::= <AgentName> "," <AgentType> "," <PhaseNumber> "," <Purpose> "," <Methodology> "," <InputArtifacts> "," <OutputArtifacts> "," <ValidationGates> "," <DocumentResponsibilities> "," <ExecutionMode> "," <Graph4D>

Before
A plan that is just a list of agent names, no executable metadata.

After
agent_count -> agent objects{name, type, phase, purpose, inputs, outputs, validation gates, doc responsibilities, execution mode, 4D graph}

Flow
Document → Read → DetectStale → Remove → Replace → Deduplicate

Productions
AgentDocumentResponsibility ::= <CoreDocument> "->" <ReadCurrentState> "->" <ContradictionDetection> "->" <StaleContentRemoval> "->" <AccurateReplacement> "->" <SingleSourceValidation>
ProhibitedDocumentOperation ::= "append_only" | "duplicate_findings" | "new_version_file"

Before
Agents append findings, accumulating duplicates and contradictions.

After
document -> read current state -> detect contradictions -> remove stale -> replace with new -> single source of truth (never append, never a new version file)

Flow
AgentObject → SpawnInvocation → AgentExecution

Productions
AgentActivationInvocation ::= <AgentObject> "->" <SpawnCall> "->" <ExecutionResult>
SpawnCall ::= "agent_type" "," "prompt" "," "description" "," "model" "," "context_if_parallel"
ForbiddenOrchestration ::= "simulate_agent_execution_in_orchestrator"

Before
The orchestrator simulates the agent's work in its own session.

After
agent object -> spawn primitive{agent_type, prompt, model, context-if-parallel} -> real activation; never simulate in the orchestrator

Flow
ParallelAgents → ConcurrentSpawnBatch → WaitAll → MergeFindings

Productions
ParallelBatchExecution ::= <ParallelAgentSet> "->" <ConcurrentSpawnBatch> "->" <CompletionWait> "->" <SharedDocumentMerge>
ConcurrentSpawnBatch ::= "single_batch_concurrent_spawn"
ParallelSafety ::= "context_fork" "," "discovery_or_investigation_only" "," "shared_artifact_refinement"

Before
Parallel agents launched in separate messages, so they run one after another anyway.

After
adjacent parallel agents -> ONE concurrent batch of forked-context spawns -> wait for all -> merge via shared documents

Flow
PreviousHandoff → SpawnCall → WaitCompletion → NextHandoff

Productions
SequentialAgentExecution ::= <HandoffContext> "->" <SequentialSpawnInvocation> "->" <CompletionSignal> "->" <NextAgentActivation>
SequentialConstraint ::= "one_spawn_at_a_time" "," "wait_for_completion" "," "context_normal"

Before
Two mutating agents launched at once, producing conflicting edits.

After
prior handoff -> one normal-context spawn at a time -> wait for completion -> activate the next

Flow
Agent → Z + X + Y + W Graph

Productions
FourDAgentGraph ::= <AgentObject> "->" <SequentialAxis> "," <LateralAxis> "," <DiagonalAxis> "," <PropagationAxis>
SequentialAxis ::= "Z: prior_required_agents"
LateralAxis ::= "X: peer_parallel_agents"
DiagonalAxis ::= "Y: cross_phase_artifact_dependencies"
PropagationAxis ::= "W: superseded_state, propagated_contracts, breaks_if_changed"

Before
An agent records only its order, not its cross-phase data or downstream ripple.

After
agent -> Z{prior required agents} + X{peer parallel} + Y{cross-phase artifact deps} + W{superseded state, propagated contracts, breaks-if-changed}

Flow
AgentCompletion → HandoffContext → OrchestratorAction

Productions
HandoffSignal ::= <AgentCompleted> "," <PhaseStatus> "," <ArtifactsLocation> "," <NextAgent> "," <ExecutionMode> "," <ContextUsed> "," <KeyFindings> "," <CriticalFiles> "," <ValidationGatesPassed> "," <ParallelResults> "," <Graph4D> "," <OrchestratorAction>
OrchestratorAction ::= "ACTIVATE_NEXT_AGENT" | "PAUSE_FOR_USER" | "WORKFLOW_COMPLETE"

Before
An agent finishes with a prose summary the orchestrator cannot route on.

After
agent completion -> handoff{completed, phase status, artifacts, next agent, execution mode, context, findings, validation, 4D graph, orchestrator_action}

Flow
HandoffSignal → ActionType → Execute|Pause|Complete

Productions
OrchestratorActionHandling ::= <HandoffSignal> "->" <ActionType> "->" <OrchestrationDecision>
ActionType ::= "ACTIVATE_NEXT_AGENT" | "PAUSE_FOR_USER" | "WORKFLOW_COMPLETE"
ContinuationRule ::= "never_ask_should_I_continue" "," "use_orchestrator_action"

Before
The orchestrator asks the user 'should I continue?' after every agent.

After
handoff -> orchestrator_action{ACTIVATE_NEXT_AGENT | PAUSE_FOR_USER | WORKFLOW_COMPLETE} -> auto-continue unless a critical decision or repeated recovery failure

Flow
PreCreateDocs → ParallelBatch|SequentialTask → Handoff → Checkpoint → Complete

Productions
WorkflowCoordinationSequence ::= <DocumentPreCreation> "->" <AgentExecutionStepSet> "->" <CheckpointUpdateSet> "->" <WorkflowCompletionState>
WorkflowCompletionState ::= "WORKFLOW_PROGRESS_100_percent" "," "core_documents_refined" "," "final_output_ready"

Before
Coordination left implicit — no one knows the exact spawn order.

After
pre-create docs -> parallel batches where eligible + sequential tasks one at a time -> handoffs -> checkpoint updates -> 100% complete

Flow
ValidationFail → Diagnose → Research → Relaunch → RetryLimit|Recover

Productions
WorkflowRecoveryLoop ::= <FailedAgentResult> "->" <SharedDocumentRead> "->" <UnmetExpectationAnalysis> "->" <ResolutionResearch> "->" <AgentRelaunch> "->" <RecoveryDecision>
RecoveryDecision ::= "continue_after_recovery" | "pause_for_user_after_limit"

Before
A failed agent is silently skipped and the workflow continues.

After
validation fail -> read shared docs -> diagnose unmet expectation -> research the error -> relaunch with adapted context -> pause for user after the bound

Flow
Workflow → Checklist → AgentUpdates → ResumableProgress

Productions
ChecklistIntegration ::= <WorkflowName> "->" <ChecklistFrontmatter> "->" <PhaseStructure> "->" <TaskBreakdown> "->" <ProgressTracking> "->" <SuccessCriteria>
ChecklistCoordinationRule ::= "orchestrator_precreates" "," "all_agents_edit_same_checklist" "," "phase_complete_before_handoff" "," "resume_by_reading_checklist"

Before
Workflow state lives only in the orchestrator context; a restart loses it.

After
workflow -> progress checklist{execution model, linear phases + severity metadata, task checkboxes, success criteria} -> any agent resumes by reading it

Flow
AgentPhase → DocumentationSection → InvocationExample

Productions
PhaseDocumentationTemplate ::= <AgentObject> "->" <PhaseHeader> "->" <ExecutionModeDescription> "->" <MethodologySummary> "->" <Graph4DRendering> "->" <ArtifactSection> "->" <FocusSection> "->" <OutputSection> "->" <AgentActivationExample>

Before
A phase documented with no execution mode, graph, or invocation example.

After
agent phase -> header + execution mode + context + methodology + 4D graph + artifacts + focus + deliverable + agent activation example

Flow
AgentSequence → PrincipleSet → WorkflowValueStatement

Productions
WorkflowPrinciplesMapping ::= <AgentSequence> "->" <AgentContributionSet> "->" <WorkflowPrincipleSet>
WorkflowPrinciple ::= "grounded_in_codebase_reality" | "fully_automated" | "context_aware" | "self_recovering" | "dynamically_scalable" | "hybrid_execution" | "context_forking" | "workspace_integrated"

Before
A workflow that never states what its structure guarantees.

After
agent sequence -> per-agent contribution{first grounds, final guarantees quality} -> principles{grounded, automated, context-aware, self-recovering, scalable}

Flow
CapabilityNeed → CapabilityPattern → ContextMode → Invocation

Productions
CapabilityInvocationProtocol ::= <CapabilityNeed> "->" <CapabilitySelection> "->" <CapabilityInvocation> "->" <CapabilityResultIntegration>
CapabilityInvocation ::= "invoke(capability=name, args=args)"
CapabilityContextRule ::= "discovery_capability_context_fork" | "validation_capability_context_normal"

Before
Every capability baked into every agent instead of a shared, invocable one.

After
capability need -> select -> invoke(capability, args){discovery -> forked, validation -> normal} -> integrate result

Flow
Sections → FinalTemplate → OutputPath → Write

Productions
TemplateAssembly ::= <WorkflowFrontmatter> "->" <WorkspaceConfigSection> "->" <WorkflowOverview> "->" <PhaseDocumentationSet> "->" <ChecklistRequirements> "->" <AgentOrchestrationProtocol> "->" <HandoffSignalFormat> "->" <WorkflowCoordination> "->" <CapabilityIntegrationProtocol> "->" <WorkflowPrinciples> "->" <OutputArtifact>
OutputArtifact ::= "{workflow_output_dir}/{workflow_name}-WORKFLOW.{workflow_ext}"

Before
Workflow sections written ad hoc, missing the handoff format or coordination.

After
assemble{frontmatter, workspace config, overview, phase docs, checklist, orchestration protocol, handoff format, coordination, capabilities, principles} -> {name}-WORKFLOW file

Flow
GeneratedWorkflow → UserChoice → Execute|Edit|Cancel

Productions
FirstTimeInitiation ::= <GeneratedWorkflow> "->" <WorkflowSummary> "->" <UserChoice> "->" <InitialAction>
UserChoice ::= "Execute Workflow" | "Edit Template" | "Cancel"

Before
The generated workflow auto-executes without the user's go-ahead.

After
generated workflow -> summary -> user choice{Execute | Edit Template | Cancel} -> generation and first execution are separate approvals

Flow
WorkflowTemplate → GateSet → Valid|Invalid

Productions
WorkflowValidationGate ::= <GeneratedWorkflow> "->" <DSLComplianceCheck> "->" <WorkspaceConfigCheck> "->" <AgentSequenceCheck> "->" <ExecutionModeCheck> "->" <Graph4DCheck> "->" <HandoffProtocolCheck> "->" <ChecklistIntegrationCheck> "->" <CapabilityIntegrationCheck> "->" <ArtifactPathCheck> "->" <CompletionVerdict>
CompletionVerdict ::= "workflow_template_valid" | "workflow_template_invalid"

Before
A workflow shipped without checking its handoff, 4D graphs, or dynamic paths.

After
template -> checks{DSL, workspace, agent sequence, execution mode, 4D graph, handoff, checklist, capabilities, artifact paths} -> valid | invalid

Flow
Specs → Workspace → Documents → Agents → Graphs → Handoffs → Coordination → Checklist → Capabilities → Template → Validation

Productions
WorkflowCreationKernel ::= <DSLComplianceLoading> "->" <FileModificationRecovery> "->" <ContextForkingConfiguration> "->" <WorkspaceConfigurationDiscovery> "->" <WorkflowDocumentSelection> "->" <SharedDocumentWorkspace> "->" <AgentSequenceDefinition> "->" <VerbExecutionClassification> "->" <FourDAgentGraph> "->" <HandoffSignal> "->" <WorkflowCoordinationSequence> "->" <ChecklistIntegration> "->" <PhaseDocumentationTemplate> "->" <CapabilityInvocationProtocol> "->" <TemplateAssembly> "->" <WorkflowValidationGate>

Derivation map

Before
An objective turned straight into a hardcoded, single-threaded agent script.

After
load specs -> discover workspace -> select docs -> define agents -> classify execution -> 4D graphs -> handoffs -> coordinate -> checklist + capabilities -> assemble -> validate

Flow
Grammar → Workspace → Documents → Agents → ExecutionMode → Context → Graph → Handoff → Coordination → Validation

Productions
WorkflowOrchestrationConcern ::= <GrammarContract> "->" <WorkspaceContract> "->" <SharedArtifactContract> "->" <AgentSequenceContract> "->" <HybridExecutionContract> "->" <ContextForkingContract> "->" <Graph4DContract> "->" <HandoffContract> "->" <ChecklistContract> "->" <CapabilityContract> "->" <ValidationGate>
HybridExecutionContract ::= "parallel_discovery" "," "sequential_actions" "," "spawn_primitive_required" "," "no_orchestrator_simulation" "," "single_source_of_truth_documents"

Flow
Principle → Invariant → Violation → Propagation → Detection → Remediation

Productions
AntiPatternInversion ::= <HealthyPrinciple> "->" <RequiredInvariant> "->" <InvariantViolation> "->" <FailurePropagation> "->" <DetectionSignalSet> "->" <RemediationInverse>
AntiPatternRecord ::= <Name> "," <TriggerCondition> "," <DegenerationPath> "," <DetectionSignals> "," <DamageModel> "," <RemediationInverse>

Before
Principle: Low Coupling — stated as a goal only; its violations are noticed ad hoc, named inconsistently, and caught late, with no derived failure algorithm.

After
Low Coupling -> invariant{no bidirectional dependency} -> violation{Cyclic Dependency} -> propagation{a convenience import closes a cycle, then spreads across modules} -> detection{dependency-cycle scan} -> remediation{invert the dependency / introduce a port}

Flow
Shortcut → Repetition → Normalization → DependencyFormation → Institutionalization → HighCostRepair

Productions
AntiPatternPropagation ::= <LocalShortcut> "->" <RepeatedUse> "->" <ImplicitConvention> "->" <DependentCodeFormation> "->" <ArchitecturalDebt> "->" <RemediationCostIncrease>
DebtAmplifier ::= "copy_paste" | "missing_contract" | "missing_owner" | "missing_metric" | "missing_boundary" | "missing_version" | "missing_observability"

Before
A one-off shortcut — inline a secret to ship a fix — treated as an isolated, cheap, local choice.

After
Shortcut{inline secret} -> repetition{reused under deadline} -> normalization{becomes the team convention} -> dependency-formation{configs read it directly} -> institutionalization{deploy scripts assume it} -> high-cost-repair{rotate the secret and rewire every dependent}

Flow
AntiPattern → MissingControl → InverseControl → Migration → AbsenceCheck → PreventionGate

Productions
AntiPatternRemediationAlgebra ::= <AntiPatternRecord> "->" <MissingControl> "->" <InverseArchitecturalControl> "->" <MigrationPlan> "->" <EliminationVerification> "->" <RecurrencePrevention>
MissingControl ::= "boundary" | "contract" | "owner" | "version" | "telemetry" | "schema" | "policy" | "state_isolation" | "dependency_rule"
RecurrencePrevention ::= "static_check" | "contract_test" | "schema_gate" | "architecture_test" | "policy_as_code" | "review_gate" | "runtime_monitor"

Before
The anti-pattern is deleted at one call site; the propagation path stays open, so it reappears elsewhere next sprint.

After
Secret Sprawl -> missing-control{no secret authority} -> inverse-control{central store + injected access} -> migration{repoint every reader} -> absence-check{scan finds zero inline secrets} -> prevention-gate{lint rule rejects new inline secrets}

Flow
Smell → Trigger → Degeneration → Detection → Measurement → Remediation → Prevention

Productions
ArchitectureSmellRecord ::= <SmellName> "," <TriggerCondition> "," <EnablingConditionSet> "," <DegenerationPath> "," <DetectionSignalSet> "," <MetricSet> "," <DamageModel> "," <RemediationInverse> "," <PreventionGate>
PreventionGate ::= "static_check" | "architecture_test" | "contract_test" | "schema_gate" | "review_gate" | "fitness_function" | "runtime_monitor"

Before
Smell described in prose ('this class is too big') — unmeasurable, unenforceable, re-argued case by case.

After
God Object : trigger{unrelated methods accrete} -> degeneration{fan-in/out grows} -> detection{LCOM + responsibility count} -> measurement{cohesion score below threshold} -> remediation{Extract Class} -> prevention{architecture test on cohesion}

Flow
SmellRecord → DetectionRule → MetricThreshold → Severity → RefactorHint → Gate

Productions
AntiPatternRuleCompiler ::= <ArchitectureSmellRecordSet> "->" <DetectionRuleSet> "->" <MetricThresholdSet> "->" <SeverityPolicy> "->" <RemediationPlaybookSet> "->" <PreventionGateSet>
CompiledRule ::= <RuleName> "," <Scope> "," <Detector> "," <Threshold> "," <PriorityRank> "," <FailureMessage> "," <RefactorHint> "," <PreventionGate>

Before
A smell catalog read by humans — each entry is advice that nothing executes.

After
SmellRecord{God Object} -> detection-rule{find unrelated method clusters} -> metric-threshold{LCOM > 0.7} -> severity{error} -> refactor-hint{Extract Class} -> gate{fails the build}

Flow
Smell → MissingControl → RuleFamily → RemediationFamily

Productions
SmellTaxonomy ::= <SmellSet> "->" <MissingControlClassification> "->" <RuleFamilySet> "->" <RemediationFamilySet>
MissingControlClassification ::= "missing_boundary" | "missing_contract" | "missing_type" | "missing_owner" | "missing_version" | "missing_validation" | "missing_observability" | "missing_state_control" | "missing_release_control" | "missing_security_control" | "missing_evidence" | "excessive_abstraction" | "excessive_coupling" | "excessive_manual_process"

Before
Dozens of smells listed flat, each handed its own bespoke, unrelated fix.

After
smell-set{Magic Value, Secret Sprawl, Hardcoded Path} -> missing-control{single source of truth} -> rule-family{no-inline-authority checks} -> remediation-family{centralize then inject}

Productions
AntiPatternRelationshipRecord ::= <AntiPatternName> ":" "Anti-Pattern" "," <scope> "," <caused_by> "," <conflicts_with> "," <degrades> "," <enables_failure> "," <detected_by> "," <measured_by> "," <refactored_by> "," <prevented_by> "," <severity>

Before
An anti-pattern named as free text with no typed edges — not resolvable, not gate-checkable, not linkable to the principle it violates.

After
Cyclic Dependency : Anti-Pattern, scope{module}, caused_by{convenience import}, conflicts_with{Low Coupling}, degrades{modularity}, enables_failure{build deadlock}, detected_by{cycle scan}, refactored_by{invert dependency}, prevented_by{dependency rule}, severity{mandatory}

Flow
Shortcut → Drift → Coupling → Fragility → Detection → Inversion

Productions
ArchitectureAntiPattern ::= <TriggerCondition> "->" <MissingControl> "->" <DegenerationPath> "->" <DamageModel> "->" <DetectionSignalSet> "->" <RemediationInverse> "->" <PreventionGate>
RemediationInverse ::= "introduce_boundary" | "declare_contract" | "centralize_authority" | "assign_owner" | "version_change" | "add_observability" | "isolate_state" | "enforce_policy"

Flow
Concept → Type → Scope → Requires → Violations → Detection → Measurement → Refactor → Enforcement → Severity

Productions
ArchitecturalRelationshipRecord ::= <ConceptName> ":" <RecordType> "," <ScopeSet> "," <RequiresSet> "," <ReinforcesSet> "," <EnablesSet> "," <ConflictSet> "," <TensionSet> "," <ViolationSet> "," <DetectionSet> "," <MetricSet> "," <RefactorSet> "," <EnforcementSet> "," <EnforcementSeverity>
RecordType ::= "Principle" | "Quality Attribute" | "Contract" | "Architecture Style" | "Pattern" | "Mechanism" | "Metric" | "Practice"
EnforcementSeverity ::= "mandatory" | "recommended" | "contextual" | "discouraged" | "mandatory_for_context"

Before
'Low Coupling' as a bare name in a list — not measurable, not enforceable.

After
Low Coupling : Quality-Attribute, scope{module}, requires{Abstraction}, conflicts_with{Tight Coupling}, detected_by{cycle scan}, measured_by{coupling metric}, refactored_by{invert dependency}, enforced_by{dependency rule}, severity{mandatory}

Flow
Records → Nodes → TypedEdges → Graph → QueryableArchitectureModel

Productions
ArchitectureGraph ::= <ConceptNodeSet> "," <RelationshipEdgeSet>
ConceptNode ::= <ConceptName> "," <RecordType> "," <ScopeSet> "," <EnforcementSeverity>
RelationshipEdge ::= <SourceConcept> "->" <RelationType> "->" <TargetConceptOrSignal>
RelationType ::= "requires" | "reinforces" | "enables" | "conflicts_with" | "tensions_with" | "violated_by" | "detected_by" | "measured_by" | "refactored_by" | "enforced_by"

Before
A flat list of relationship records — no way to ask 'what does Foo require, transitively?'

After
records -> nodes{concepts} + typed-edges{requires, reinforces, enables, conflicts_with} -> traversable graph

Flow
Issue → ForceFamily → CandidateConcepts → ApplicableContracts

Productions
ForceClassification ::= <DesignIssue> "->" <ForceFamily> "->" <ConceptQuery> "->" <ApplicableConceptSet>
ForceFamily ::= "modularity" | "contract_compatibility" | "semantic_consistency" | "domain_boundary" | "runtime_extensibility" | "object_creation" | "structural_mediation" | "behavioral_variation" | "event_messaging" | "state_transaction" | "correctness_verification" | "resilience_recovery" | "observability_traceability" | "causality_ordering" | "performance_scaling" | "security_governance" | "architecture_evolution" | "control_coordination" | "metaprogramming_modeling" | "streaming_dataflow" | "ai_governance"

Before
A design issue answered by pattern-name recall ('use a Factory').

After
issue{concrete constructor everywhere} -> force{object_creation} -> concept-query -> applicable{Construction Boundary}

Flow
TargetConcept → RequiresEdges → TransitiveClosure → DependencyOrder

Productions
DependencyClosure ::= <TargetConcept> "->" <RequiresTraversal> "->" <RequiredConceptSet> "->" <TopologicalOrder>
RequiresTraversal ::= "follow requires edges until fixed point"
TopologicalOrder ::= "prerequisites_before_dependents"

Before
Adopt Foo without checking what Foo needs — its prerequisites are silently unmet.

After
target{Foo} -> follow requires-edges to fixed point -> {Bar, Baz} -> topological order{Baz, Bar, Foo}

Flow
ImplementedConcept → Reinforces + Enables → CapabilityImpact

Productions
ReinforcementPropagation ::= <SatisfiedConcept> "->" <ReinforcesTraversal> "->" <EnablesTraversal> "->" <ImpactSet>
ImpactSet ::= <QualityGainSet> "," <CapabilityGainSet>
QualityGain ::= <ReinforcedConcept> "," <Confidence> "," <EvidenceRequired>

Before
Foo implemented; its second-order gains go unnoticed and unclaimed.

After
satisfied{Foo} -> reinforces -> {Bar quality} -> enables -> {Baz capability} -> impact set with confidence

Flow
CandidateConcept → Conflicts + Tensions → TradeoffAnalysis → Decision

Productions
ConflictTensionResolution ::= <CandidateConceptSet> "->" <ConflictSet> "->" <TensionSet> "->" <ResolutionPolicy>
ResolutionPolicy ::= "reject_combination" | "accept_with_mitigation" | "document_tradeoff" | "require_architecture_decision" | "contextual_override"

Before
Two chosen concepts silently conflict at runtime; nobody decided the trade-off.

After
candidates{Foo, Bar} -> conflict{prohibitive} -> tension{trade-off} -> policy{require architecture decision}

Flow
Severity → EnforcementMode → GateBehavior

Productions
SeverityPolicy ::= <EnforcementSeverity> "->" <EnforcementMode>
EnforcementMode ::= "blocking_gate" | "review_warning" | "context_required" | "exception_required" | "informational"
SeverityMapping ::= "mandatory -> blocking_gate" | "recommended -> review_warning" | "contextual -> context_required" | "discouraged -> exception_required"

Before
Every finding treated the same — a style nit blocks like a critical flaw.

After
severity{mandatory} -> blocking-gate ; severity{recommended} -> review-warning ; severity{contextual} -> context-required

Flow
ApplicableConcept → DetectionSignals → Observations → ViolationRecords

Productions
ViolationDetection ::= <ApplicableConceptSet> "->" <DetectionSignalSet> "->" <ObservedEvidenceSet> "->" <ViolationRecordSet>
ViolationRecord ::= <Concept> "," <ViolationPattern> "," <EvidenceLocationSet> "," <MetricValueSet> "," <EnforcementSeverity> "," <RecommendedRefactorSet>

Before
'Foo is violated' asserted from opinion, with no observable signal.

After
concept{Foo} -> detected_by signals run on code -> observations -> violation-record{concept, pattern, evidence, severity}

Flow
MeasuredBy → MetricDefinition → Measurement → NormalizedScore → Confidence

Productions
MeasurementNormalization ::= <MetricDescriptorSet> "->" <MetricDefinitionSet> "->" <MetricValueSet> "->" <NormalizedScoreSet>
MetricDefinition ::= <MetricName> "," <Scope> "," <CollectionMethod> "," <ThresholdPolicy> "," <ConfidencePolicy>

Before
Architecture judged by free-form opinion, no comparable numbers.

After
measured_by{coupling} -> metric-definition{scope, method, threshold} -> values -> normalized score + confidence

Flow
Violation → RefactorCandidates → RiskRank → SelectedPlan

Productions
RefactorSelection ::= <ViolationRecord> "->" <RefactorActionSet> "->" <RefactorRanking> "->" <RefactorPlan>
RefactorRanking ::= "severity" "," "required_dependency_count" "," "blast_radius" "," "reinforcement_gain" "," "rollback_feasibility"

Before
A fix chosen ad hoc, unrelated to the violated concept's remediation contract.

After
violation{Foo} -> refactored_by candidates -> rank{severity, blast-radius, reinforcement-gain} -> refactor plan

Flow
EnforcementDescriptor → GateType → ValidationProcedure → Pass|Fail

Productions
EnforcementGate ::= <Concept> "->" <EnforcementDescriptorSet> "->" <GateSet> "->" <GateResultSet>
GateType ::= "static_analysis" | "architecture_test" | "schema_validation" | "contract_test" | "lint_rule" | "fitness_function" | "runtime_monitor" | "policy_as_code" | "review_gate"

Before
'enforced_by: review' — a human promise that erodes under deadline.

After
enforced_by{Foo} -> gate-type{static-analysis | contract-test | fitness-function} -> pass/fail in CI

Flow
Scope → RelevantConcepts → DependencyClosure → Detection → Measurement → Findings

Productions
ArchitectureAssessment ::= <TargetScope> "->" <RelevantConceptSelection> "->" <DependencyClosure> "->" <ViolationDetection> "->" <MeasurementNormalization> "->" <FindingPrioritization> "->" <AssessmentReport>
FindingPrioritization ::= "mandatory_first" "," "high_blast_radius" "," "high_reinforcement_gain" "," "low_refactor_cost"

Before
'The architecture is fine' — an unscoped, evidence-free claim.

After
scope -> relevant concepts -> dependency-closure -> violation-detection -> measurement -> prioritized findings

Flow
Module → Responsibility → Cohesion → Coupling → Visibility → BoundaryHealth

Productions
ModularBoundaryCompliance ::= <ModuleSet> "->" <ResponsibilityAnalysis> "->" <CohesionMetric> "->" <CouplingMetric> "->" <VisibilityLeakCheck> "->" <BoundaryScore>
BoundaryScore ::= <ResponsibilityScore> "," <CohesionScore> "," <CouplingScore> "," <EncapsulationScore> "," <ReplaceabilityScore>

Before
Modularity checked as one vague vibe.

After
modules -> responsibility + cohesion + coupling + visibility-leak -> boundary score{per-dimension}

Flow
Boundary → Contract → Version → CompatibilityMatrix → Gate

Productions
ContractCompatibility ::= <BoundaryContract> "->" <SchemaOrInterfaceValidation> "->" <SemanticValidation> "->" <VersionPolicy> "->" <CompatibilityMatrix> "->" <CompatibilityVerdict>
CompatibilityMatrix ::= "producer_current_consumer_current" | "producer_new_consumer_old" | "producer_old_consumer_new" | "unknown_field_handling" | "breaking_diff_check"

Before
A schema changed and downstreams broke — compatibility was never checked.

After
boundary-contract -> schema/semantic validation -> version-policy -> compatibility-matrix{new-producer/old-consumer} -> verdict

Flow
Concepts → Conflicts → CanonicalAuthority → Normalization → Enforcement

Productions
CanonicalSemantics ::= <SemanticArtifactSet> "->" <ConflictDetection> "->" <CanonicalAuthoritySelection> "->" <NormalizationPolicy> "->" <TranslationBoundary> "->" <GovernanceGate>
SemanticArtifact ::= "schema" | "domain_model" | "field" | "term" | "rule" | "configuration"

Before
Three models of 'Foo' drift apart; no single authority.

After
artifacts{Foo-a, Foo-b} -> conflict-detection -> canonical authority -> normalize variants -> SSOT gate

Flow
Domain → Contexts → Language → Ownership → ContextMap → ACL

Productions
DomainBoundaryGovernance ::= <DomainScope> "->" <BoundedContextSet> "->" <UbiquitousLanguageSet> "->" <OwnershipMap> "->" <ContextMap> "->" <AntiCorruptionBoundarySet>
ContextRelationship ::= "upstream" | "downstream" | "shared_kernel" | "customer_supplier" | "anti_corruption_layer" | "separate_ways"

Before
One shared model spans every context; a change for Foo breaks Bar.

After
domain -> bounded-contexts -> ubiquitous-language -> ownership-map -> context-map -> anti-corruption boundaries

Flow
Component → Manifest → CapabilityDeclaration → Discovery → ContractValidation → Binding

Productions
SelfDescribingDiscovery ::= <RuntimeEntity> "->" <Manifest> "->" <CapabilityDeclaration> "->" <DiscoveryMechanism> "->" <ConformanceValidation> "->" <BindingDecision>
Manifest ::= "identity" "," "version" "," "capabilities" "," "dependencies" "," "contracts" "," "configuration" "," "health"

Before
A runtime component's capabilities are unknowable without reading its source.

After
entity -> manifest{identity, capabilities, contracts} -> discovery -> conformance-validation -> bind only if it matches

Flow
VariantPressure → ExtensionPoint → PluginContract → Registry → Discovery → Isolation

Productions
RuntimeExtensibility ::= <VariantPressure> "->" <ExtensionPointDesign> "->" <PluginContract> "->" <RegistrationPolicy> "->" <RuntimeDiscovery> "->" <FailureIsolation>
RegistrationPolicy ::= "manual_registration" | "manifest_based" | "service_registry" | "convention_based" | "configuration_based"

Before
Every new variant edits the core switch statement.

After
variant-pressure -> extension-point -> plugin-contract -> registry -> runtime-discovery -> failure-isolation

Flow
ProblemForce → PatternFamily → CandidatePattern → ApplicabilityCheck

Productions
PatternSelection ::= <ProblemForce> "->" <PatternFamily> "->" <CandidatePatternSet> "->" <ApplicabilityVerdict>
PatternFamily ::= "creational" | "structural" | "behavioral"
CandidatePattern ::= "factory" | "factory_method" | "abstract_factory" | "builder" | "prototype" | "adapter" | "facade" | "proxy" | "bridge" | "decorator" | "strategy" | "template_method" | "observer" | "mediator"

Before
A pattern applied as decoration ('let's add a Facade') with no force to justify it.

After
force{interface mismatch} -> family{structural} -> candidate{Adapter} -> applicability verdict

Flow
SystemForces → StyleCandidates → TradeoffMatrix → SelectedStyle → FitnessFunctions

Productions
ArchitectureStyleSelection ::= <SystemForces> "->" <ArchitectureStyleSet> "->" <TradeoffMatrix> "->" <SelectedStyle> "->" <StyleFitnessFunctionSet>
SystemForces ::= "domain_complexity" "," "team_topology" "," "deployment_autonomy" "," "consistency_requirement" "," "operational_maturity" "," "scaling_pressure"

Before
'We'll do microservices' chosen before the system's forces are known.

After
forces{domain-complexity, team-topology, deployment-autonomy} -> style-candidates -> trade-off matrix -> selected style + fitness functions

Flow
StateChange → EventContract → Outbox → Broker → IdempotentConsumer → Trace

Productions
EventMessagingConsistency ::= <StateChange> "->" <EventClassification> "->" <MessageContract> "->" <PublicationReliability> "->" <ConsumerIdempotency> "->" <OrderingPolicy> "->" <ObservabilityTrace>
EventClassification ::= "domain_event" | "integration_event" | "stream_event"
PublicationReliability ::= "transactional_outbox" | "append_only_log" | "broker_acknowledgement"

Before
Events published ad hoc; a consumer replays and double-applies.

After
state-change -> event-contract -> transactional-outbox -> broker -> idempotent-consumer -> ordering + trace

Flow
Command → TransactionBoundary → Invariants → Concurrency → Commit|Rollback → Idempotency

Productions
StateTransactionSafety ::= <Command> "->" <TransactionBoundary> "->" <InvariantCheck> "->" <ConcurrencyControl> "->" <CommitDecision> "->" <SideEffectPolicy>
ConcurrencyControl ::= "optimistic_locking" | "pessimistic_locking" | "serial_execution" | "state_isolation"
SideEffectPolicy ::= "idempotent" | "outbox_published" | "compensatable" | "controlled_side_effect"

Before
Two mutations with no boundary; a crash between them corrupts state.

After
command -> transaction-boundary -> invariant-check -> concurrency-control -> commit/rollback -> idempotent side-effect

Flow
Input → Canonicalize → DeterministicCore → Spec → Verification → Evidence

Productions
CorrectnessVerification ::= <InputSet> "->" <Canonicalization> "->" <DeterministicCore> "->" <SpecificationSet> "->" <VerificationMethodSet> "->" <CorrectnessEvidence>
VerificationMethod ::= "type_check" | "static_analysis" | "schema_validation" | "contract_test" | "property_based_test" | "specification_test" | "formal_verification" | "runtime_validation"

Before
Correctness asserted by 'it worked on my machine'.